Create a new auto-incrementing integer (4-byte) column on the table.

@param string $columnName

@return \Doctrine\DBAL\Schema\Column
347116
public function increments($columnName)
    {
        $column = $this->integer($columnName, true, true);
        $this->primary($columnName);

        return $column;
    }
1149290
public function createColumns(array $columns, $tagName = 'td')
    {
        foreach ($columns as $column) {
            if ($column instanceof Column) {
                $column->tagName = $tagName;
                $this->childNodes->push($column);
            } else {
                $columnElement = $this->createColumn($tagName);
                if ($column instanceof Element) {
                    $columnElement->entity->setEntityName($column->entity->getEntityName());
                    $columnElement->childNodes->push($column);
                } else {
                    $columnElement->entity->setEntityName('col-' . $column);
                    $columnElement->textContent->push($column);
                }
            }
        }

        return $this;
    }
960923
public static function getPdoParamName($columnName)
    {
        if (isset(self::$pdoParamAliasesUsed[$columnName])) {
            self::$pdoParamAliasesUsed[$columnName]++;

            return $columnName . self::$pdoParamAliasesUsed[$columnName];
        } else {
            self::$pdoParamAliasesUsed[$columnName] = 1;

            return $columnName;
        }
    }
320939
public function load(string $columnName)
    {
        $this->columnsToLoad[$columnName] = $this->structure->getColumn($columnName);

        return $this;
    }
239103
public function getColumnDefaultValue($tableName, $columnName) {
        $columns = $this->getTableColumns($tableName);
        foreach ($columns as $column) {
            if ($column['Field'] != $columnName)
                continue;
            return $column['Default'];
        }
        throw new \Exception("Column `$columnName` not found in table `$tableName`!");
    }
1229039
public function getColumnName($fieldName)
    {
        return isset($this->columnNames[$fieldName]) ?
                $this->columnNames[$fieldName] : $fieldName;
    }
335456
public function getColumnType($tableName, $columnName) {
        $columns = $this->getTableColumns($tableName);
        foreach ($columns as $column) {
            if ($column['Field'] != $columnName)
                continue;
            $type = explode('(', $column['Type'], 2);
            return $type[0];
        }
        throw new \Exception("Column `$columnName` not found in table `$tableName`!");
    }
458814
public function mediumInteger($column, $autoIncrement = false, $unsigned = false)
    {
        return $this->addColumn('mediumInteger', $column, compact('autoIncrement', 'unsigned'));
    }
700355
protected function createColumn($name, \Doctrine\DBAL\Schema\Column $col) {
		$type = strtolower($col->getType());

		$res = "\n\t\$table->addColumn('$name', '".$type."', [";
		if($col->getNotnull())
			$res .= "\n		'notnull' => true,";
		if($col->getAutoincrement())
			$res .= "\n		'autoincrement' => true,";
		if($col->getDefault())
			$res .= "\n		'default' => '".$col->getDefault()."',";
		if($col->getScale())
			$res .= "\n		'scale' => ".$col->getScale().",";
		if(in_array($type, ['decimal', 'float', 'double']) && $col->getPrecision())
			$res .= "\n		'precision' => ".$col->getPrecision().",";
		if($col->getLength() !== null)
			$res .= "\n		'length' => ".$col->getLength().",";
		if($col->getFixed())
			$res .= "\n		'fixed' => true,";
		if($col->getUnsigned())
			$res .= "\n		'unsigned' => true,";
		$res .= "\n	]);";

		return $res;
	}
590361
protected function addRelationParent($columnName) {
		$table = substr($columnName, 3);
		$parent = new NameManager($this->getNames()->namespace, $table);
		// METHOD:getRelationParent
		$method = $this->buildMethod("fetch{$parent->entityName}");
		$body = <<<MBODY
\${$parent->tableName} = new \\{$parent->namespace_model}\\{$parent->modelName}();
return \${$parent->tableName}->get{$parent->entityName}(\$this->{$columnName});
MBODY;
		$method->setBody($body);
		$tag = new ReturnTag();
		$tag->setTypes("\\{$parent->namespace_entity}\\{$parent->entityName}");
		$docBlock = new DocBlockGenerator();
		$docBlock->setTag($tag);
		$docBlock->setShortDescription("Related {$parent->entityName}");
		$method->setDocBlock($docBlock);
		$this->_class->addMethodFromGenerator($method);
	}
787148
public function withName(string $name) : Column
    {
        if ($this->name === $name) {
            return $this;
        }

        return new self($name, $this->type, $this->isPrimaryKey);
    }
259293
public function to(string $columnName) : ColumnTypeDefinerWithVersioning
    {
        return new ColumnTypeDefinerWithVersioning(
                $this->definition,
                $this->callback,
                $this->phpToDbConverter,
                $this->dbToPhpConverter,
                $this->propertyName,
                $columnName,
                $this->ignoreNullabilityTypeMismatch
        );
    }
65331
public function orderByAsc(string $columnName) : OneToManyRelationDefiner
    {
        $this->orderByColumnNameDirectionMap[$columnName] = Ordering::ASC;

        return $this;
    }
1329503
protected function getColumnCreateAddNoUpdate(array $schema, string $table, string $columnName): string
    {
        $result = $this->getColumnCreate($schema, $table, $columnName);

        return sprintf("%s->addColumn('%s', '%s', %s)", $this->ind3, $result[1], $result[2], $result[3]);
    }
802966
public function smallInteger($column, $autoIncrement = false, $unsigned = false)
    {
        return $this->addColumn('smallInteger', $column, compact('autoIncrement', 'unsigned'));
    }
785632
public function orderByDesc(string $columnName) : OneToManyRelationDefiner
    {
        $this->orderByColumnNameDirectionMap[$columnName] = Ordering::DESC;

        return $this;
    }
557782
public function withParentIdAs(string $columnName)
    {
        call_user_func($this->callback, function ($idString, Table $parentTable) use ($columnName) {
            /** @var IEntityMapper $mapper */
            $mapper = call_user_func($this->mapperLoader);
            $mapper->addForeignKey(ForeignKey::createWithNamingConvention(
                $mapper->getPrimaryTableName(),
                [$columnName],
                $parentTable->getName(),
                [$parentTable->getPrimaryKeyColumnName()],
                $this->identifying
                    ? ForeignKeyMode::CASCADE
                    : ForeignKeyMode::SET_NULL,
                ForeignKeyMode::CASCADE
            ));

            if ($this->orderPersistColumn) {
                $persistHook = new OrderIndexPropertyLoaderHook(
                    $mapper->getObjectType(),
                    $mapper->getPrimaryTable(),
                    $this->orderPersistColumn,
                    $columnName,
                    $mapper->getDefinition()->getPropertyLinkedToColumn($this->orderPersistColumn)
                );

                $mapper->addPersistHook($persistHook);
                $persistHookId = $persistHook->getIdString();
            } else {
                $persistHookId = null;
            }

            return new ToManyRelation(
                $idString,
                $this->loadIds
                    ? new ToManyRelationIdentityReference($mapper, $this->bidirectionalRelationProperty)
                    : new ToManyRelationObjectReference($mapper, $this->bidirectionalRelationProperty, $persistHookId),
                $columnName,
                $this->identifying
                    ? new IdentifyingRelationMode()
                    : new NonIdentifyingRelationMode(),
                $this->orderByColumnNameDirectionMap,
                $this->orderPersistColumn
            );
        });
    }