Abstract Class Yiisoft\Db\QueryBuilder\AbstractColumnDefinitionBuilder

                public function __construct(
    protected QueryBuilderInterface $queryBuilder,
) {}

            

                public function build(ColumnInterface $column): string
{
    return $this->buildType($column)
        . $this->buildUnsigned($column)
        . $this->buildNotNull($column)
        . $this->buildPrimaryKey($column)
        . $this->buildAutoIncrement($column)
        . $this->buildUnique($column)
        . $this->buildDefault($column)
        . $this->buildComment($column)
        . $this->buildCheck($column)
        . $this->buildCollate($column)
        . $this->buildReferences($column)
        . $this->buildExtra($column);
}

            

                public function buildAlter(ColumnInterface $column): string
{
    return $this->build($column);
}

            

                protected function buildAutoIncrement(ColumnInterface $column): string
{
    if (empty(static::AUTO_INCREMENT_KEYWORD) || !$column->isAutoIncrement()) {
        return '';
    }
    return match ($column->getType()) {
        ColumnType::TINYINT,
        ColumnType::SMALLINT,
        ColumnType::INTEGER,
        ColumnType::BIGINT => ' ' . static::AUTO_INCREMENT_KEYWORD,
        default => '',
    };
}

            

                protected function buildCheck(ColumnInterface $column): string
{
    $check = $column->getCheck();
    if (empty($check)
        && $column instanceof EnumColumn
        && $column->getDbType() === null
    ) {
        $name = $column->getName();
        if (!empty($name)) {
            $quoter = $this->queryBuilder->getQuoter();
            $quotedItems = implode(
                ',',
                array_map(
                    $quoter->quoteValue(...),
                    $column->getValues(),
                ),
            );
            $quotedName = $quoter->quoteColumnName($name);
            $check = "$quotedName IN ($quotedItems)";
        }
    }
    return !empty($check) ? " CHECK ($check)" : '';
}

            

                protected function buildCollate(ColumnInterface $column): string
{
    if (!$column instanceof CollatableColumnInterface || empty($column->getCollation())) {
        return '';
    }
    /** @psalm-suppress PossiblyNullOperand */
    return ' COLLATE ' . $column->getCollation();
}

            

                protected function buildComment(ColumnInterface $column): string
{
    return '';
}

            

                protected function buildDefault(ColumnInterface $column): string
{
    $uuidExpression = $this->getDefaultUuidExpression();
    if (!empty($uuidExpression)
        && $column->getType() === ColumnType::UUID
        && $column->isAutoIncrement()
        && $column->getDefaultValue() === null
    ) {
        return " DEFAULT $uuidExpression";
    }
    if ($column->isAutoIncrement() && $column->getType() !== ColumnType::UUID
        || !$column->hasDefaultValue()
    ) {
        return '';
    }
    $defaultValue = $column->dbTypecast($column->getDefaultValue());
    $defaultValue = $this->queryBuilder->prepareValue($defaultValue);
    if ($defaultValue === '') {
        return '';
    }
    return " DEFAULT $defaultValue";
}

            

                protected function buildExtra(ColumnInterface $column): string
{
    $extra = $column->getExtra();
    return !empty($extra) ? " $extra" : '';
}

            

                protected function buildNotNull(ColumnInterface $column): string
{
    return match ($column->isNotNull()) {
        true => ' NOT NULL',
        false => ' NULL',
        default => '',
    };
}

            

                protected function buildOnDelete(string $onDelete): string
{
    return " ON DELETE $onDelete";
}

            

                protected function buildOnUpdate(string $onUpdate): string
{
    return " ON UPDATE $onUpdate";
}

            

                protected function buildPrimaryKey(ColumnInterface $column): string
{
    return $column->isPrimaryKey() ? ' PRIMARY KEY' : '';
}

            

                protected function buildReferenceDefinition(ColumnInterface $column): string
{
    $reference = $column->getReference();
    if ($reference === null || $reference->foreignTableName === '') {
        return '';
    }
    $quoter = $this->queryBuilder->getQuoter();
    $sql = $reference->foreignSchemaName === ''
        ? $quoter->quoteTableName($reference->foreignTableName)
        : $quoter->quoteTableName($reference->foreignSchemaName)
            . '.' . $quoter->quoteTableName($reference->foreignTableName);
    if (!empty($reference->foreignColumnNames)) {
        $sql .= ' (' . $this->queryBuilder->buildColumns($reference->foreignColumnNames) . ')';
    }
    if ($reference->onDelete !== null) {
        $sql .= $this->buildOnDelete($reference->onDelete);
    }
    if ($reference->onUpdate !== null) {
        $sql .= $this->buildOnUpdate($reference->onUpdate);
    }
    return $sql;
}

            

                protected function buildReferences(ColumnInterface $column): string
{
    $reference = $this->buildReferenceDefinition($column);
    if ($reference === '') {
        return '';
    }
    return " REFERENCES $reference";
}

            

                public function buildType(ColumnInterface $column): string
{
    $dbType = $this->getDbType($column);
    if (empty($dbType)
        || $dbType[-1] === ')'
        || !in_array(strtolower($dbType), static::TYPES_WITH_SIZE, true)
    ) {
        return $dbType;
    }
    $size = $column->getSize();
    if ($size === null) {
        return $dbType;
    }
    $scale = $column->getScale();
    if ($scale === null || !in_array(strtolower($dbType), static::TYPES_WITH_SCALE, true)) {
        return "$dbType($size)";
    }
    return "$dbType($size,$scale)";
}

            

                protected function buildUnique(ColumnInterface $column): string
{
    if ($column->isPrimaryKey()) {
        return '';
    }
    return $column->isUnique() ? ' UNIQUE' : '';
}

            

                protected function buildUnsigned(ColumnInterface $column): string
{
    return $column->isUnsigned() ? ' UNSIGNED' : '';
}

            

                abstract protected function getDbType(ColumnInterface $column): string;

            

                protected function getDefaultUuidExpression(): string
{
    return '';
}