Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Doctrine\DBAL\Schema;

use Doctrine\DBAL\Exception;

use Doctrine\DBAL\Schema\Exception\InvalidTableName;

use Doctrine\DBAL\Schema\Visitor\Visitor;

use Doctrine\DBAL\Types\Type;

use Doctrine\Deprecations\Deprecation;

use function array_filter;

use function array_keys;

use function array_merge;

use function in_array;

use function preg_match;

use function strlen;

use function strtolower;

use const ARRAY_FILTER_USE_KEY;

/**

 * Object Representation of a table.

 */

class Table extends AbstractAsset

{

    /** @var Column[] */

    protected $_columns = [];

    /** @var Index[] */

    protected $_indexes = [];

    /** @var string|null */

    protected $_primaryKeyName;

    /** @var UniqueConstraint[] */

    protected $uniqueConstraints = [];

    /** @var ForeignKeyConstraint[] */

    protected $_fkConstraints = [];

    /** @var mixed[] */

    protected $_options = [

        'create_options' => [],

    ];

    /** @var SchemaConfig|null */

    protected $_schemaConfig;

    /** @var Index[] */

    private array $implicitIndexes = [];

    /**

     * @param Column[]               $columns

     * @param Index[]                $indexes

     * @param UniqueConstraint[]     $uniqueConstraints

     * @param ForeignKeyConstraint[] $fkConstraints

     * @param mixed[]                $options

     *

     * @throws SchemaException

     * @throws Exception

     */

    public function __construct(

        string $name,

        array $columns = [],

        array $indexes = [],

        array $uniqueConstraints = [],

        array $fkConstraints = [],

        array $options = []

    ) {

        if ($name === '') {

            throw InvalidTableName::new($name);

        }

        $this->_setName($name);

        foreach ($columns as $column) {

            $this->_addColumn($column);

        }

        foreach ($indexes as $idx) {

            $this->_addIndex($idx);

        }

        foreach ($uniqueConstraints as $uniqueConstraint) {

            $this->_addUniqueConstraint($uniqueConstraint);

        }

        foreach ($fkConstraints as $constraint) {

            $this->_addForeignKeyConstraint($constraint);

        }

        $this->_options = array_merge($this->_options, $options);

    }

    /** @return void */

    public function setSchemaConfig(SchemaConfig $schemaConfig)

    {

        $this->_schemaConfig = $schemaConfig;

    }

    /** @return int */

    protected function _getMaxIdentifierLength()

    {

        if ($this->_schemaConfig instanceof SchemaConfig) {

            return $this->_schemaConfig->getMaxIdentifierLength();

        }

        return 63;

    }

    /**

     * Sets the Primary Key.

     *

     * @param string[]     $columnNames

     * @param string|false $indexName

     *

     * @return self

     *

     * @throws SchemaException

     */

    public function setPrimaryKey(array $columnNames, $indexName = false)

    {

        if ($indexName === false) {

            $indexName = 'primary';

        }

        $this->_addIndex($this->_createIndex($columnNames, $indexName, true, true));

        foreach ($columnNames as $columnName) {

            $column = $this->getColumn($columnName);

            $column->setNotnull(true);

        }

        return $this;

    }

    /**

     * @param string[] $columnNames

     * @param string[] $flags

     * @param mixed[]  $options

     *

     * @return self

     *

     * @throws SchemaException

     */

    public function addIndex(array $columnNames, ?string $indexName = null, array $flags = [], array $options = [])

    {

        $indexName ??= $this->_generateIdentifierName(

            array_merge([$this->getName()], $columnNames),

            'idx',

            $this->_getMaxIdentifierLength(),

        );

        return $this->_addIndex($this->_createIndex($columnNames, $indexName, false, false, $flags, $options));

    }

    /**

     * @param string[] $columnNames

     * @param string[] $flags

     * @param mixed[]  $options

     *

     * @return self

     */

    public function addUniqueConstraint(

        array $columnNames,

        ?string $indexName = null,

        array $flags = [],

        array $options = []

    ): Table {

        $indexName ??= $this->_generateIdentifierName(

            array_merge([$this->getName()], $columnNames),

            'uniq',

            $this->_getMaxIdentifierLength(),

        );

        return $this->_addUniqueConstraint($this->_createUniqueConstraint($columnNames, $indexName, $flags, $options));

    }

    /**

     * Drops the primary key from this table.

     *

     * @return void

     *

     * @throws SchemaException

     */

    public function dropPrimaryKey()

    {

        if ($this->_primaryKeyName === null) {

            return;

        }

        $this->dropIndex($this->_primaryKeyName);

        $this->_primaryKeyName = null;

    }

    /**

     * Drops an index from this table.

     *

     * @param string $name The index name.

     *

     * @return void

     *

     * @throws SchemaException If the index does not exist.

     */

    public function dropIndex($name)

    {

        $name = $this->normalizeIdentifier($name);

        if (! $this->hasIndex($name)) {

            throw SchemaException::indexDoesNotExist($name, $this->_name);

        }

        unset($this->_indexes[$name]);

    }

    /**

     * @param string[]    $columnNames

     * @param string|null $indexName

     * @param mixed[]     $options

     *

     * @return self

     *

     * @throws SchemaException

     */

    public function addUniqueIndex(array $columnNames, $indexName = null, array $options = [])

    {

        $indexName ??= $this->_generateIdentifierName(

            array_merge([$this->getName()], $columnNames),

            'uniq',

            $this->_getMaxIdentifierLength(),

        );

        return $this->_addIndex($this->_createIndex($columnNames, $indexName, true, false, [], $options));

    }

    /**

     * Renames an index.

     *

     * @param string      $oldName The name of the index to rename from.

     * @param string|null $newName The name of the index to rename to.

     *                                  If null is given, the index name will be auto-generated.

     *

     * @return self This table instance.

     *

     * @throws SchemaException If no index exists for the given current name

     *                         or if an index with the given new name already exists on this table.

     */

    public function renameIndex($oldName, $newName = null)

    {

        $oldName           = $this->normalizeIdentifier($oldName);

        $normalizedNewName = $this->normalizeIdentifier($newName);

        if ($oldName === $normalizedNewName) {

            return $this;

        }

        if (! $this->hasIndex($oldName)) {

            throw SchemaException::indexDoesNotExist($oldName, $this->_name);

        }

        if ($this->hasIndex($normalizedNewName)) {

            throw SchemaException::indexAlreadyExists($normalizedNewName, $this->_name);

        }

        $oldIndex = $this->_indexes[$oldName];

        if ($oldIndex->isPrimary()) {

            $this->dropPrimaryKey();

            return $this->setPrimaryKey($oldIndex->getColumns(), $newName ?? false);

        }

        unset($this->_indexes[$oldName]);

        if ($oldIndex->isUnique()) {

            return $this->addUniqueIndex($oldIndex->getColumns(), $newName, $oldIndex->getOptions());

        }

        return $this->addIndex($oldIndex->getColumns(), $newName, $oldIndex->getFlags(), $oldIndex->getOptions());

    }

    /**

     * Checks if an index begins in the order of the given columns.

     *

     * @param string[] $columnNames

     *

     * @return bool

     */

    public function columnsAreIndexed(array $columnNames)

    {

        foreach ($this->getIndexes() as $index) {

            if ($index->spansColumns($columnNames)) {

                return true;

            }

        }

        return false;

    }

    /**

     * @param string[] $columnNames

     * @param string   $indexName

     * @param bool     $isUnique

     * @param bool     $isPrimary

     * @param string[] $flags

     * @param mixed[]  $options

     *

     * @throws SchemaException

     */

    private function _createIndex(

        array $columnNames,

        $indexName,

        $isUnique,

        $isPrimary,

        array $flags = [],

        array $options = []

    ): Index {

        if (preg_match('(([^a-zA-Z0-9_]+))', $this->normalizeIdentifier($indexName)) === 1) {

            throw SchemaException::indexNameInvalid($indexName);

        }

        foreach ($columnNames as $columnName) {

            if (! $this->hasColumn($columnName)) {

                throw SchemaException::columnDoesNotExist($columnName, $this->_name);

            }

        }

        return new Index($indexName, $columnNames, $isUnique, $isPrimary, $flags, $options);

    }

    /**

     * @param string  $name

     * @param string  $typeName

     * @param mixed[] $options

     *

     * @return Column

     *

     * @throws SchemaException

     */

    public function addColumn($name, $typeName, array $options = [])

    {

        $column = new Column($name, Type::getType($typeName), $options);

        $this->_addColumn($column);

        return $column;

    }

    /**

     * Change Column Details.

     *

     * @deprecated Use {@link modifyColumn()} instead.

     *

     * @param string  $name

     * @param mixed[] $options

     *

     * @return self

     *

     * @throws SchemaException

     */

    public function changeColumn($name, array $options)

    {

        Deprecation::trigger(

            'doctrine/dbal',

            'https://github.com/doctrine/dbal/pull/5747',

            '%s is deprecated. Use modifyColumn() instead.',

            __METHOD__,

        );

        return $this->modifyColumn($name, $options);

    }

    /**

     * @param string  $name

     * @param mixed[] $options

     *

     * @return self

     *

     * @throws SchemaException

     */

    public function modifyColumn($name, array $options)

    {

        $column = $this->getColumn($name);

        $column->setOptions($options);

        return $this;

    }

    /**

     * Drops a Column from the Table.

     *

     * @param string $name

     *

     * @return self

     */

    public function dropColumn($name)

    {

        $name = $this->normalizeIdentifier($name);

        unset($this->_columns[$name]);

        return $this;

    }

    /**

     * Adds a foreign key constraint.

     *

     * Name is inferred from the local columns.

     *

     * @param Table|string $foreignTable       Table schema instance or table name

     * @param string[]     $localColumnNames

     * @param string[]     $foreignColumnNames

     * @param mixed[]      $options

     * @param string|null  $name

     *

     * @return self

     *

     * @throws SchemaException

     */

    public function addForeignKeyConstraint(

        $foreignTable,

        array $localColumnNames,

        array $foreignColumnNames,

        array $options = [],

        $name = null

    ) {

        $name ??= $this->_generateIdentifierName(

            array_merge([$this->getName()], $localColumnNames),

            'fk',

            $this->_getMaxIdentifierLength(),

        );

        if ($foreignTable instanceof Table) {

            foreach ($foreignColumnNames as $columnName) {

                if (! $foreignTable->hasColumn($columnName)) {

                    throw SchemaException::columnDoesNotExist($columnName, $foreignTable->getName());

                }

            }

        }

        foreach ($localColumnNames as $columnName) {

            if (! $this->hasColumn($columnName)) {

                throw SchemaException::columnDoesNotExist($columnName, $this->_name);

            }

        }

        $constraint = new ForeignKeyConstraint(

            $localColumnNames,

            $foreignTable,

            $foreignColumnNames,

            $name,

            $options,

        );

        return $this->_addForeignKeyConstraint($constraint);

    }

    /**

     * @param string $name

     * @param mixed  $value

     *

     * @return self

     */

    public function addOption($name, $value)

    {

        $this->_options[$name] = $value;

        return $this;

    }

    /**

     * @return void

     *

     * @throws SchemaException

     */

    protected function _addColumn(Column $column)

    {

        $columnName = $column->getName();

        $columnName = $this->normalizeIdentifier($columnName);

        if (isset($this->_columns[$columnName])) {

            throw SchemaException::columnAlreadyExists($this->getName(), $columnName);

        }

        $this->_columns[$columnName] = $column;

    }

    /**

     * Adds an index to the table.

     *

     * @return self

     *

     * @throws SchemaException

     */

    protected function _addIndex(Index $indexCandidate)

    {

        $indexName               = $indexCandidate->getName();

        $indexName               = $this->normalizeIdentifier($indexName);

        $replacedImplicitIndexes = [];

        foreach ($this->implicitIndexes as $name => $implicitIndex) {

            if (! $implicitIndex->isFulfilledBy($indexCandidate) || ! isset($this->_indexes[$name])) {

                continue;

            }

            $replacedImplicitIndexes[] = $name;

        }

        if (

            (isset($this->_indexes[$indexName]) && ! in_array($indexName, $replacedImplicitIndexes, true)) ||

            ($this->_primaryKeyName !== null && $indexCandidate->isPrimary())

        ) {

            throw SchemaException::indexAlreadyExists($indexName, $this->_name);

        }

        foreach ($replacedImplicitIndexes as $name) {

            unset($this->_indexes[$name], $this->implicitIndexes[$name]);

        }

        if ($indexCandidate->isPrimary()) {

            $this->_primaryKeyName = $indexName;

        }

        $this->_indexes[$indexName] = $indexCandidate;

        return $this;

    }

    /** @return self */

    protected function _addUniqueConstraint(UniqueConstraint $constraint): Table

    {

        $mergedNames = array_merge([$this->getName()], $constraint->getColumns());

        $name        = strlen($constraint->getName()) > 0

            ? $constraint->getName()

            : $this->_generateIdentifierName($mergedNames, 'fk', $this->_getMaxIdentifierLength());

        $name = $this->normalizeIdentifier($name);

        $this->uniqueConstraints[$name] = $constraint;

        // If there is already an index that fulfills this requirements drop the request. In the case of __construct

        // calling this method during hydration from schema-details all the explicitly added indexes lead to duplicates.

        // This creates computation overhead in this case, however no duplicate indexes are ever added (column based).

        $indexName = $this->_generateIdentifierName($mergedNames, 'idx', $this->_getMaxIdentifierLength());

        $indexCandidate = $this->_createIndex($constraint->getColumns(), $indexName, true, false);

        foreach ($this->_indexes as $existingIndex) {

            if ($indexCandidate->isFulfilledBy($existingIndex)) {

                return $this;

            }

        }

        $this->implicitIndexes[$this->normalizeIdentifier($indexName)] = $indexCandidate;

        return $this;

    }

    /** @return self */

    protected function _addForeignKeyConstraint(ForeignKeyConstraint $constraint)

    {

        $constraint->setLocalTable($this);

        if (strlen($constraint->getName()) > 0) {

            $name = $constraint->getName();

        } else {

            $name = $this->_generateIdentifierName(

                array_merge([$this->getName()], $constraint->getLocalColumns()),

                'fk',

                $this->_getMaxIdentifierLength(),

            );

        }

        $name = $this->normalizeIdentifier($name);

        $this->_fkConstraints[$name] = $constraint;

        /* Add an implicit index (defined by the DBAL) on the foreign key

           columns. If there is already a user-defined index that fulfills these

           requirements drop the request. In the case of __construct() calling

           this method during hydration from schema-details, all the explicitly

           added indexes lead to duplicates. This creates computation overhead in

           this case, however no duplicate indexes are ever added (based on

           columns). */

        $indexName = $this->_generateIdentifierName(

            array_merge([$this->getName()], $constraint->getColumns()),

            'idx',

            $this->_getMaxIdentifierLength(),

        );

        $indexCandidate = $this->_createIndex($constraint->getColumns(), $indexName, false, false);

        foreach ($this->_indexes as $existingIndex) {

            if ($indexCandidate->isFulfilledBy($existingIndex)) {

                return $this;

            }

        }

        $this->_addIndex($indexCandidate);

        $this->implicitIndexes[$this->normalizeIdentifier($indexName)] = $indexCandidate;

        return $this;

    }

    /**

     * Returns whether this table has a foreign key constraint with the given name.

     *

     * @param string $name

     *

     * @return bool

     */

    public function hasForeignKey($name)

    {

        $name = $this->normalizeIdentifier($name);

        return isset($this->_fkConstraints[$name]);

    }

    /**

     * Returns the foreign key constraint with the given name.

     *

     * @param string $name The constraint name.

     *

     * @return ForeignKeyConstraint

     *

     * @throws SchemaException If the foreign key does not exist.

     */

    public function getForeignKey($name)

    {

        $name = $this->normalizeIdentifier($name);

        if (! $this->hasForeignKey($name)) {

            throw SchemaException::foreignKeyDoesNotExist($name, $this->_name);

        }

        return $this->_fkConstraints[$name];

    }

    /**

     * Removes the foreign key constraint with the given name.

     *

     * @param string $name The constraint name.

     *

     * @return void

     *

     * @throws SchemaException

     */

    public function removeForeignKey($name)

    {

        $name = $this->normalizeIdentifier($name);

        if (! $this->hasForeignKey($name)) {

            throw SchemaException::foreignKeyDoesNotExist($name, $this->_name);

        }

        unset($this->_fkConstraints[$name]);

    }

    /**

     * Returns whether this table has a unique constraint with the given name.

     */

    public function hasUniqueConstraint(string $name): bool

    {

        $name = $this->normalizeIdentifier($name);

        return isset($this->uniqueConstraints[$name]);

    }

    /**

     * Returns the unique constraint with the given name.

     *

     * @throws SchemaException If the unique constraint does not exist.

     */

    public function getUniqueConstraint(string $name): UniqueConstraint

    {

        $name = $this->normalizeIdentifier($name);

        if (! $this->hasUniqueConstraint($name)) {

            throw SchemaException::uniqueConstraintDoesNotExist($name, $this->_name);

        }

        return $this->uniqueConstraints[$name];

    }

    /**

     * Removes the unique constraint with the given name.

     *

     * @throws SchemaException If the unique constraint does not exist.

     */

    public function removeUniqueConstraint(string $name): void

    {

        $name = $this->normalizeIdentifier($name);

        if (! $this->hasUniqueConstraint($name)) {

            throw SchemaException::uniqueConstraintDoesNotExist($name, $this->_name);

        }

        unset($this->uniqueConstraints[$name]);

    }

    /**

     * Returns ordered list of columns (primary keys are first, then foreign keys, then the rest)

     *

     * @return Column[]

     */

    public function getColumns()

    {

        $primaryKeyColumns = $this->getPrimaryKey() !== null ? $this->getPrimaryKeyColumns() : [];

        $foreignKeyColumns = $this->getForeignKeyColumns();

        $remainderColumns  = $this->filterColumns(

            array_merge(array_keys($primaryKeyColumns), array_keys($foreignKeyColumns)),

            true,

        );

        return array_merge($primaryKeyColumns, $foreignKeyColumns, $remainderColumns);

    }

    /**

     * Returns the foreign key columns

     *

     * @deprecated Use {@see getForeignKey()} and {@see ForeignKeyConstraint::getLocalColumns()} instead.

     *

     * @return Column[]

     */

    public function getForeignKeyColumns()

    {

        Deprecation::trigger(

            'doctrine/dbal',

            'https://github.com/doctrine/dbal/pull/5731',

            '%s is deprecated. Use getForeignKey() and ForeignKeyConstraint::getLocalColumns() instead.',

            __METHOD__,

        );

        $foreignKeyColumns = [];

        foreach ($this->getForeignKeys() as $foreignKey) {

            $foreignKeyColumns = array_merge($foreignKeyColumns, $foreignKey->getLocalColumns());

        }

        return $this->filterColumns($foreignKeyColumns);

    }

    /**

     * Returns only columns that have specified names

     *

     * @param string[] $columnNames

     *

     * @return Column[]

     */

    private function filterColumns(array $columnNames, bool $reverse = false): array

    {

        return array_filter($this->_columns, static function (string $columnName) use ($columnNames, $reverse): bool {

            return in_array($columnName, $columnNames, true) !== $reverse;

        }, ARRAY_FILTER_USE_KEY);

    }

    /**

     * Returns whether this table has a Column with the given name.

     *

     * @param string $name The column name.

     *

     * @return bool

     */

    public function hasColumn($name)

    {

        $name = $this->normalizeIdentifier($name);

        return isset($this->_columns[$name]);

    }

    /**

     * Returns the Column with the given name.

     *

     * @param string $name The column name.

     *

     * @return Column

     *

     * @throws SchemaException If the column does not exist.

     */

    public function getColumn($name)

    {

        $name = $this->normalizeIdentifier($name);

        if (! $this->hasColumn($name)) {

            throw SchemaException::columnDoesNotExist($name, $this->_name);

        }

        return $this->_columns[$name];

    }

    /**

     * Returns the primary key.

     *

     * @return Index|null The primary key, or null if this Table has no primary key.

     */

    public function getPrimaryKey()

    {

        if ($this->_primaryKeyName !== null) {

            return $this->getIndex($this->_primaryKeyName);

        }

        return null;

    }

    /**

     * Returns the primary key columns.

     *

     * @deprecated Use {@see getPrimaryKey()} and {@see Index::getColumns()} instead.

     *

     * @return Column[]

     *

     * @throws Exception

     */

    public function getPrimaryKeyColumns()

    {

        Deprecation::trigger(

            'doctrine/dbal',

            'https://github.com/doctrine/dbal/pull/5731',

            '%s is deprecated. Use getPrimaryKey() and Index::getColumns() instead.',

            __METHOD__,

        );

        $primaryKey = $this->getPrimaryKey();

        if ($primaryKey === null) {

            throw new Exception('Table ' . $this->getName() . ' has no primary key.');

        }

        return $this->filterColumns($primaryKey->getColumns());

    }

    /**

     * Returns whether this table has a primary key.

     *

     * @deprecated Use {@see getPrimaryKey()} instead.

     *

     * @return bool

     */

    public function hasPrimaryKey()

    {

        Deprecation::trigger(

            'doctrine/dbal',

            'https://github.com/doctrine/dbal/pull/5731',

            '%s is deprecated. Use getPrimaryKey() instead.',

            __METHOD__,

        );

        return $this->_primaryKeyName !== null && $this->hasIndex($this->_primaryKeyName);

    }

    /**

     * Returns whether this table has an Index with the given name.

     *

     * @param string $name The index name.

     *

     * @return bool

     */

    public function hasIndex($name)

    {

        $name = $this->normalizeIdentifier($name);

        return isset($this->_indexes[$name]);

    }

    /**

     * Returns the Index with the given name.

     *

     * @param string $name The index name.

     *

     * @return Index

     *

     * @throws SchemaException If the index does not exist.

     */

    public function getIndex($name)

    {

        $name = $this->normalizeIdentifier($name);

        if (! $this->hasIndex($name)) {

            throw SchemaException::indexDoesNotExist($name, $this->_name);

        }

        return $this->_indexes[$name];

    }

    /** @return Index[] */

    public function getIndexes()

    {

        return $this->_indexes;

    }

    /**

     * Returns the unique constraints.

     *

     * @return UniqueConstraint[]

     */

    public function getUniqueConstraints(): array

    {

        return $this->uniqueConstraints;

    }

    /**

     * Returns the foreign key constraints.

     *

     * @return ForeignKeyConstraint[]

     */

    public function getForeignKeys()

    {

        return $this->_fkConstraints;

    }

    /**

     * @param string $name

     *

     * @return bool

     */

    public function hasOption($name)

    {

        return isset($this->_options[$name]);

    }

    /**

     * @param string $name

     *

     * @return mixed

     */

    public function getOption($name)

    {

        return $this->_options[$name];

    }

    /** @return mixed[] */

    public function getOptions()

    {

        return $this->_options;

    }

    /**

     * @deprecated

     *

     * @return void

     *

     * @throws SchemaException

     */

    public function visit(Visitor $visitor)

    {

        Deprecation::triggerIfCalledFromOutside(

            'doctrine/dbal',

            'https://github.com/doctrine/dbal/pull/5435',

            'Table::visit() is deprecated.',

        );

        $visitor->acceptTable($this);

        foreach ($this->getColumns() as $column) {

            $visitor->acceptColumn($this, $column);

        }

        foreach ($this->getIndexes() as $index) {

            $visitor->acceptIndex($this, $index);

        }

        foreach ($this->getForeignKeys() as $constraint) {

            $visitor->acceptForeignKey($this, $constraint);

        }

    }

    /**

     * Clone of a Table triggers a deep clone of all affected assets.

     *

     * @return void

     */

    public function __clone()

    {

        foreach ($this->_columns as $k => $column) {

            $this->_columns[$k] = clone $column;

        }

        foreach ($this->_indexes as $k => $index) {

            $this->_indexes[$k] = clone $index;

        }

        foreach ($this->_fkConstraints as $k => $fk) {

            $this->_fkConstraints[$k] = clone $fk;

            $this->_fkConstraints[$k]->setLocalTable($this);

        }

    }

    /**

     * @param string[] $columnNames

     * @param string[] $flags

     * @param mixed[]  $options

     *

     * @throws SchemaException

     */

    private function _createUniqueConstraint(

        array $columnNames,

        string $indexName,

        array $flags = [],

        array $options = []

    ): UniqueConstraint {

        if (preg_match('(([^a-zA-Z0-9_]+))', $this->normalizeIdentifier($indexName)) === 1) {

            throw SchemaException::indexNameInvalid($indexName);

        }

        foreach ($columnNames as $columnName) {