Doctrine\ORM\Mapping\Driver\DatabaseDriver

Complexity

Total Complexity

77

Size/Duplication

Total Lines	511
Duplicated Lines	0 %

Test Coverage

Coverage

52.53%

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	isTransient()	0	3	1
A	setNamespace()	0	3	1
A	setFieldNameForColumn()	0	3	1
A	setClassNameForTable()	0	3	1
A	getAllClassNames()	0	5	1
A	setTables()	0	13	3
B	buildFieldMappings()	0	41	9
C	loadMetadataForClass()	0	100	15
C	convertColumnAnnotationToFieldMetadata()	0	54	17
A	getFieldNameForColumn()	0	14	3
A	getTableForeignKeys()	0	5	2
A	getTablePrimaryKeys()	0	9	2
B	reverseEngineerMappingFromDatabase()	0	46	9
A	buildTable()	0	24	3
A	getClassNameForTable()	0	5	1
B	buildToOneAssociationMappings()	0	38	7

<?php

declare(strict_types=1);

namespace Doctrine\ORM\Mapping\Driver;

use Doctrine\Common\Inflector\Inflector;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Doctrine\DBAL\Schema\Column;
use Doctrine\DBAL\Schema\ForeignKeyConstraint;
use Doctrine\DBAL\Schema\Identifier;
use Doctrine\DBAL\Schema\Index;
use Doctrine\DBAL\Schema\SchemaException;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Mapping;
use Doctrine\ORM\Sequencing\Generator;
use InvalidArgumentException;
use function array_diff;
use function array_keys;
use function array_merge;
use function count;
use function current;
use function in_array;
use function reset;
use function sort;
use function str_replace;
use function strtolower;

/**
 * The DatabaseDriver reverse engineers the mapping metadata from a database.
 */
class DatabaseDriver implements MappingDriver
{
    /** @var AbstractSchemaManager */
    private $sm;

    /** @var Table[]|null */
    private $tables;

    /** @var string[] */
    private $classToTableNames = [];

    /** @var Table[] */
    private $manyToManyTables = [];

    /** @var Table[] */
    private $classNamesForTables = [];

    /** @var Table[][] */
    private $fieldNamesForColumns = [];

    /**
     * The namespace for the generated entities.
     *
     * @var string|null
     */
    private $namespace;

    public function __construct(AbstractSchemaManager $schemaManager)
    {
        $this->sm = $schemaManager;
    }

    /**
     * Set the namespace for the generated entities.
     *
     * @param string $namespace
     */
    public function setNamespace($namespace)
    {
        $this->namespace = $namespace;
    }

    /**
     * {@inheritDoc}
     */
    public function isTransient($className) : bool
    {
        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function getAllClassNames() : array
    {
        $this->reverseEngineerMappingFromDatabase();

        return array_keys($this->classToTableNames);
    }

    /**
     * Sets class name for a table.
     *
     * @param string $tableName
     * @param string $className
     */
    public function setClassNameForTable($tableName, $className)
    {
        $this->classNamesForTables[$tableName] = $className;
    }

    /**
     * Sets field name for a column on a specific table.
     *
     * @param string $tableName
     * @param string $columnName
     * @param string $fieldName
     */
    public function setFieldNameForColumn($tableName, $columnName, $fieldName)
    {
        $this->fieldNamesForColumns[$tableName][$columnName] = $fieldName;
    }

    /**
     * Sets tables manually instead of relying on the reverse engineering capabilities of SchemaManager.
     *
     * @param Table[] $entityTables
     * @param Table[] $manyToManyTables
     */
    public function setTables($entityTables, $manyToManyTables)
    {
        $this->tables = $this->manyToManyTables = $this->classToTableNames = [];

        foreach ($entityTables as $table) {
            $className = $this->getClassNameForTable($table->getName());

            $this->classToTableNames[$className] = $table->getName();
            $this->tables[$table->getName()]     = $table;
        }

        foreach ($manyToManyTables as $table) {
            $this->manyToManyTables[$table->getName()] = $table;
        }
    }

    /**
     * {@inheritDoc}
     */
    public function loadMetadataForClass(
        string $className,
        ?Mapping\ComponentMetadata $parent,
        Mapping\ClassMetadataBuildingContext $metadataBuildingContext
    ) : Mapping\ComponentMetadata {
        $this->reverseEngineerMappingFromDatabase();

        if (! isset($this->classToTableNames[$className])) {
            throw new InvalidArgumentException('Unknown class ' . $className);
        }

        $metadata = new Mapping\ClassMetadata($className, $parent);

        $this->buildTable($metadata);
        $this->buildFieldMappings($metadata);
        $this->buildToOneAssociationMappings($metadata);

        $loweredTableName = strtolower($metadata->getTableName());

        foreach ($this->manyToManyTables as $manyTable) {
            foreach ($manyTable->getForeignKeys() as $foreignKey) {
                // foreign key maps to the table of the current entity, many to many association probably exists
                if ($loweredTableName !== strtolower($foreignKey->getForeignTableName())) {
                    continue;
                }

                $myFk    = $foreignKey;
                $otherFk = null;

                foreach ($manyTable->getForeignKeys() as $manyTableForeignKey) {
                    if ($manyTableForeignKey !== $myFk) {
                        $otherFk = $manyTableForeignKey;

                        break;
                    }
                }

                if (! $otherFk) {
                    // the definition of this many to many table does not contain
                    // enough foreign key information to continue reverse engineering.
                    continue;
                }

                $localColumn = current($myFk->getColumns());

                $associationMapping                 = [];
                $associationMapping['fieldName']    = $this->getFieldNameForColumn($manyTable->getName(), current($otherFk->getColumns()), true);
                $associationMapping['targetEntity'] = $this->getClassNameForTable($otherFk->getForeignTableName());

		if (isset($metadata->fieldMappings[$associationMapping['fieldName']])

The property fieldMappings does not seem to exist on Doctrine\ORM\Mapping\ClassMetadata.

                        || isset($metadata->associationMappings[$associationMapping['fieldName']])) {

The property associationMappings does not seem to exist on Doctrine\ORM\Mapping\ClassMetadata.

                        $ii=2;

Equals sign not aligned correctly; expected 1 space but found 0 spaces

                        while ( isset($metadata->fieldMappings[$associationMapping['fieldName'].(string)$ii]) ||

Concat operator must be surrounded by a single space

Expected 1 space(s) after cast statement; 0 found

                                isset($metadata->associationMappings[$associationMapping['fieldName'].(string)$ii])) {

Concat operator must be surrounded by a single space

Expected 1 space(s) after cast statement; 0 found

                                $ii++;
                        }
                        $associationMapping['fieldName'] .= (string)$ii; 

Expected 1 space(s) after cast statement; 0 found

                }

Closing brace indented incorrectly; expected 8 spaces, found 16

                if (current($manyTable->getColumns())->getName() === $localColumn) {
                    $associationMapping['inversedBy'] = $this->getFieldNameForColumn($manyTable->getName(), current($myFk->getColumns()), true);
                    $associationMapping['joinTable']  = new Mapping\JoinTableMetadata();

                    $joinTable = $associationMapping['joinTable'];
                    $joinTable->setName(strtolower($manyTable->getName()));

                    $fkCols = $myFk->getForeignColumns();
                    $cols   = $myFk->getColumns();

                    for ($i = 0, $l = count($cols); $i < $l; $i++) {
                        $joinColumn = new Mapping\JoinColumnMetadata();

                        $joinColumn->setColumnName($cols[$i]);
                        $joinColumn->setReferencedColumnName($fkCols[$i]);

                        $joinTable->addJoinColumn($joinColumn);
                    }

                    $fkCols = $otherFk->getForeignColumns();
                    $cols   = $otherFk->getColumns();

                    for ($i = 0, $l = count($cols); $i < $l; $i++) {
                        $joinColumn = new Mapping\JoinColumnMetadata();

                        $joinColumn->setColumnName($cols[$i]);
                        $joinColumn->setReferencedColumnName($fkCols[$i]);

                        $joinTable->addInverseJoinColumn($joinColumn);
                    }
                } else {
                    $associationMapping['mappedBy'] = $this->getFieldNameForColumn($manyTable->getName(), current($myFk->getColumns()), true);
                }

                $metadata->addProperty($associationMapping);

$associationMapping of type array is incompatible with the type Doctrine\ORM\Mapping\Property expected by parameter $property of Doctrine\ORM\Mapping\ClassMetadata::addProperty().

                break;
            }
        }

        return $metadata;
    }

    /**
     * @throws Mapping\MappingException
     */
    private function reverseEngineerMappingFromDatabase()
    {
        if ($this->tables !== null) {
            return;
        }

        $tables = [];

        foreach ($this->sm->listTableNames() as $tableName) {
            $tables[$tableName] = $this->sm->listTableDetails($tableName);
        }

        $this->tables = $this->manyToManyTables = $this->classToTableNames = [];

        foreach ($tables as $tableName => $table) {
            $foreignKeys = $this->sm->getDatabasePlatform()->supportsForeignKeyConstraints()
                ? $table->getForeignKeys()
                : [];

            $allForeignKeyColumns = [];

            foreach ($foreignKeys as $foreignKey) {
                $allForeignKeyColumns = array_merge($allForeignKeyColumns, $foreignKey->getLocalColumns());
            }

            if (! $table->hasPrimaryKey()) {
                throw new Mapping\MappingException(
                    'Table ' . $table->getName() . ' has no primary key. Doctrine does not ' .
                    "support reverse engineering from tables that don't have a primary key."
                );
            }

            $pkColumns = $table->getPrimaryKey()->getColumns();

            sort($pkColumns);
            sort($allForeignKeyColumns);

            if ($pkColumns === $allForeignKeyColumns && count($foreignKeys) === 2) {
                $this->manyToManyTables[$tableName] = $table;
            } else {
                // lower-casing is necessary because of Oracle Uppercase Tablenames,
                // assumption is lower-case + underscore separated.
                $className = $this->getClassNameForTable($tableName);

                $this->tables[$tableName]            = $table;
                $this->classToTableNames[$className] = $tableName;
            }
        }
    }

    /**
     * Build table from a class metadata.
     */
    private function buildTable(Mapping\ClassMetadata $metadata)
    {
        $tableName     = $this->classToTableNames[$metadata->getClassName()];
        $indexes       = $this->tables[$tableName]->getIndexes();
        $tableMetadata = new Mapping\TableMetadata();

        $tableMetadata->setName($this->classToTableNames[$metadata->getClassName()]);

        foreach ($indexes as $index) {
            /** @var Index $index */
            if ($index->isPrimary()) {
                continue;
            }

            $tableMetadata->addIndex([
                'name'    => $index->getName(),
                'columns' => $index->getColumns(),
                'unique'  => $index->isUnique(),
                'options' => $index->getOptions(),
                'flags'   => $index->getFlags(),
            ]);
        }

        $metadata->setTable($tableMetadata);
    }

    /**
     * Build field mapping from class metadata.
     */
    private function buildFieldMappings(Mapping\ClassMetadata $metadata)
    {
        $tableName      = $metadata->getTableName();
        $columns        = $this->tables[$tableName]->getColumns();
        $primaryKeys    = $this->getTablePrimaryKeys($this->tables[$tableName]);
        $foreignKeys    = $this->getTableForeignKeys($this->tables[$tableName]);
        $allForeignKeys = [];

        foreach ($foreignKeys as $foreignKey) {
            $allForeignKeys = array_merge($allForeignKeys, $foreignKey->getLocalColumns());
        }

        $ids = [];

        foreach ($columns as $column) {
            if (in_array($column->getName(), $allForeignKeys, true)) {
                continue;
            }

            $fieldName     = $this->getFieldNameForColumn($tableName, $column->getName(), false);
            $fieldMetadata = $this->convertColumnAnnotationToFieldMetadata($tableName, $column, $fieldName);

It seems like $tableName can also be of type null; however, parameter $tableName of Doctrine\ORM\Mapping\Driver\DatabaseDriver::convertColumnAnnotationToFieldMetadata() does only seem to accept string, maybe add an additional type check?

            if ($primaryKeys && in_array($column->getName(), $primaryKeys, true)) {

The expression $primaryKeys of type Doctrine\DBAL\Schema\Identifier[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                $fieldMetadata->setPrimaryKey(true);

                $ids[] = $fieldMetadata;
            }

            $metadata->addProperty($fieldMetadata);
        }

        // We need to check for the columns here, because we might have associations as id as well.
        if ($ids && count($primaryKeys) === 1) {
            $fieldMetadata = reset($ids);
            $generator     = $fieldMetadata->getTypeName() === 'bigint'
                ? new Generator\BigIntegerIdentityGenerator()
                : new Generator\IdentityGenerator();

            $valueGenerator = new Mapping\ValueGeneratorMetadata(Mapping\GeneratorType::IDENTITY, $generator);

            $ids[0]->setValueGenerator($valueGenerator);
        }
    }

    /**
     * Parse the given Column as FieldMetadata
     *
     * @return Mapping\FieldMetadata
     */
    private function convertColumnAnnotationToFieldMetadata(string $tableName, Column $column, string $fieldName)
    {
        $options       = [];
        $fieldMetadata = new Mapping\FieldMetadata($fieldName);

        $fieldMetadata->setType($column->getType());
        $fieldMetadata->setTableName($tableName);
        $fieldMetadata->setColumnName($column->getName());

        // Type specific elements
        switch ($column->getType()->getName()) {
            case Type::TARRAY:
            case Type::BLOB:
            case Type::GUID:
            case Type::JSON_ARRAY:
            case Type::OBJECT:
            case Type::SIMPLE_ARRAY:
            case Type::STRING:
            case Type::TEXT:
                if ($column->getLength()) {

The expression $column->getLength() of type integer|null is loosely compared to true; this is ambiguous if the integer can be 0. You might want to explicitly use !== null instead.

                    $fieldMetadata->setLength($column->getLength());
                }

                $options['fixed'] = $column->getFixed();
                break;

            case Type::DECIMAL:
            case Type::FLOAT:
                $fieldMetadata->setScale($column->getScale());
                $fieldMetadata->setPrecision($column->getPrecision());
                break;

            case Type::INTEGER:
            case Type::BIGINT:
            case Type::SMALLINT:
                $options['unsigned'] = $column->getUnsigned();
                break;
        }

        // Comment
        $comment = $column->getComment();
        if ($comment !== null) {
            $options['comment'] = $comment;
        }

        // Default
        $default = $column->getDefault();
        if ($default !== null) {
            $options['default'] = $default;
        }

        $fieldMetadata->setOptions($options);

        return $fieldMetadata;
    }

    /**
     * Build to one (one to one, many to one) association mapping from class metadata.
     */
    private function buildToOneAssociationMappings(Mapping\ClassMetadata $metadata)
    {
        $tableName   = $metadata->getTableName();
        $primaryKeys = $this->getTablePrimaryKeys($this->tables[$tableName]);
        $foreignKeys = $this->getTableForeignKeys($this->tables[$tableName]);

        foreach ($foreignKeys as $foreignKey) {
            $foreignTableName   = $foreignKey->getForeignTableName();
            $fkColumns          = $foreignKey->getColumns();
            $fkForeignColumns   = $foreignKey->getForeignColumns();
            $localColumn        = current($fkColumns);
            $associationMapping = [
                'fieldName'    => $this->getFieldNameForColumn($tableName, $localColumn, true),
                'targetEntity' => $this->getClassNameForTable($foreignTableName),
            ];

            if ($metadata->getProperty($associationMapping['fieldName'])) {
                $associationMapping['fieldName'] .= '2'; // "foo" => "foo2"
            }

            if ($primaryKeys && in_array($localColumn, $primaryKeys, true)) {

The expression $primaryKeys of type Doctrine\DBAL\Schema\Identifier[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                $associationMapping['id'] = true;
            }

            for ($i = 0, $l = count($fkColumns); $i < $l; $i++) {
                $joinColumn = new Mapping\JoinColumnMetadata();

                $joinColumn->setColumnName($fkColumns[$i]);
                $joinColumn->setReferencedColumnName($fkForeignColumns[$i]);

                $associationMapping['joinColumns'][] = $joinColumn;
            }

            // Here we need to check if $fkColumns are the same as $primaryKeys
            if (! array_diff($fkColumns, $primaryKeys)) {
                $metadata->addProperty($associationMapping);

$associationMapping of type array<string,string> is incompatible with the type Doctrine\ORM\Mapping\Property expected by parameter $property of Doctrine\ORM\Mapping\ClassMetadata::addProperty().

            } else {
                $metadata->addProperty($associationMapping);
            }
        }
    }

    /**
     * Retrieve schema table definition foreign keys.
     *
     * @return ForeignKeyConstraint[]
     */
    private function getTableForeignKeys(Table $table)
    {
        return $this->sm->getDatabasePlatform()->supportsForeignKeyConstraints()
            ? $table->getForeignKeys()
            : [];
    }

    /**
     * Retrieve schema table definition primary keys.
     *
     * @return Identifier[]
     */
    private function getTablePrimaryKeys(Table $table)
    {
        try {
            return $table->getPrimaryKey()->getColumns();
        } catch (SchemaException $e) {
            // Do nothing
        }

        return [];
    }

    /**
     * Returns the mapped class name for a table if it exists. Otherwise return "classified" version.
     *
     * @param string $tableName
     *
     * @return string
     */
    private function getClassNameForTable($tableName)
    {
        return $this->namespace . (
            $this->classNamesForTables[$tableName]

Are you sure $this->classNamesForTables[$tableName] ?? Doctrine\Common\Inflector\Inflector::classify(strtolower($tableName)) of type Doctrine\DBAL\Schema\Table|string can be used in concatenation?

                ?? Inflector::classify(strtolower($tableName))
        );
    }

    /**
     * Return the mapped field name for a column, if it exists. Otherwise return camelized version.
     *
     * @param string $tableName
     * @param string $columnName
     * @param bool   $fk         Whether the column is a foreignkey or not.
     *
     * @return string
     */
    private function getFieldNameForColumn($tableName, $columnName, $fk = false)
    {
        if (isset($this->fieldNamesForColumns[$tableName], $this->fieldNamesForColumns[$tableName][$columnName])) {
            return $this->fieldNamesForColumns[$tableName][$columnName];

The expression return $this->fieldNamesForColumns[$tableName][$columnName] returns the type Doctrine\DBAL\Schema\Table which is incompatible with the documented return type string.

        }

        $columnName = strtolower($columnName);

        // Replace _id if it is a foreignkey column
        if ($fk) {
            $columnName = str_replace('_id', '', $columnName);
        }

        return Inflector::camelize($columnName);
    }
}