b2pweb / bdf-prime

src/Schema/SchemaManager.php

<?php

namespace Bdf\Prime\Schema;

use Bdf\Prime\Exception\DBALException;
use Bdf\Prime\Schema\Adapter\Doctrine\DoctrineTable as PrimeTableAdapter;
use Bdf\Prime\Schema\Transformer\Doctrine\TableTransformer;
use Doctrine\DBAL\Exception as DoctrineDBALException;
use Doctrine\DBAL\Schema\Schema as DoctrineSchema;
use Doctrine\DBAL\Schema\SchemaConfig;
use Doctrine\DBAL\Schema\SchemaDiff as DoctrineSchemaDiff;
use Doctrine\DBAL\Schema\TableDiff as DoctrineTableDiff;
use Doctrine\DBAL\Schema\Table as DoctrineTable;

/**
 * SchemaManager using doctrine schemas
 *
 * @extends AbstractSchemaManager<\Bdf\Prime\Connection\ConnectionInterface&\Doctrine\DBAL\Connection>
 * @property \Bdf\Prime\Connection\ConnectionInterface&\Doctrine\DBAL\Connection $connection protected
 */
class SchemaManager extends AbstractSchemaManager
{
    /**
     * Queries to execute
     *
     * @var array
     */
    private $queries = [];


    /**
     * Get the doctrine schema manager
     *
     * @return \Doctrine\DBAL\Schema\AbstractSchemaManager
     */
    public function getDoctrineManager()
    {
        return $this->connection->getSchemaManager();

The function Doctrine\DBAL\Connection::getSchemaManager() has been deprecated: Use {@see createSchemaManager()} instead.

    }

    /**
     * Get the queries to execute
     *
     * @return array
     */
    public function toSql()
    {
        return $this->queries;
    }

    /**
     * {@inheritdoc}
     */
    public function pending(): array
    {
        return $this->queries;
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        $this->queries = [];

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function flush(): bool
    {
        $lastResult = false;
        $queries = $this->queries;

        $this->clear();

        foreach ($queries as $query) {
            $lastResult = $this->connection->executeStatement($query);
        }

        return (bool) $lastResult;
    }

    /**
     * {@inheritdoc}
     */
    public function schema($tables = [])
    {
        if (!is_array($tables)) {
            $tables = [$tables];
        }

        $tables = array_map(function ($table) {
            if ($table instanceof TableInterface) {
                return (new TableTransformer($table, $this->platform))->toDoctrine();
            }

            return $table;
        }, $tables);

        $config = new SchemaConfig();
        $config->setName($this->connection->getDatabase());

        return new DoctrineSchema($tables, [], $config);
    }

    /**
     * {@inheritdoc}
     */
    public function loadSchema()
    {
        return $this->getDoctrineManager()->createSchema();

The function Doctrine\DBAL\Schema\AbstractSchemaManager::createSchema() has been deprecated: Use {@link introspectSchema()} instead.

    }

    /**
     * {@inheritdoc}
     */
    public function hasDatabase(string $database): bool
    {
        try {
            $databases = $this->getDoctrineManager()->listDatabases();
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }

        return in_array(strtolower($database), array_map('strtolower', $databases));
    }

    /**
     * {@inheritdoc}
     */
    public function getDatabases(): array
    {
        try {
            return $this->getDoctrineManager()->listDatabases();
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function createDatabase(string $database)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getCreateDatabaseSQL($database)
            );
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function dropDatabase(string $database)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getDropDatabaseSQL($database)
            );
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function has(string $tableName): bool
    {
        try {
            return $this->getDoctrineManager()->tablesExist($tableName);
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function load(string $name): TableInterface
    {
        try {
            $manager = $this->getDoctrineManager();

            $foreignKeys = [];

            if ($this->platform->grammar()->supportsForeignKeyConstraints()) {

The function Doctrine\DBAL\Platforms\AbstractPlatform::supportsForeignKeyConstraints() has been deprecated: All platforms should support foreign key constraints.

                $foreignKeys = $manager->listTableForeignKeys($name);
            }

            return new PrimeTableAdapter(

The expression return new Bdf\Prime\Schema\Adapter\Doctrine\DoctrineTable(new Doctrine\DBAL\Schema\Table($name, $manager->listTableColumns($name), $manager->listTableIndexes($name), array(), $foreignKeys), $this->connection->platform()->types()) returns the type Bdf\Prime\Schema\Adapter\Doctrine\DoctrineTable which is incompatible with the return type mandated by Bdf\Prime\Schema\Manager\DatabaseStructureManagerInterface::load() of Bdf\Prime\Schema\Manager\T.

                new DoctrineTable(
                    $name,
                    $manager->listTableColumns($name),
                    $manager->listTableIndexes($name),
                    [],
                    $foreignKeys
                ),
                $this->connection->platform()->types()
            );
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function drop(string $tableName)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getDropTableSQL($tableName)
            );
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function truncate(string $tableName, bool $cascade = false)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getTruncateTableSQL($tableName, $cascade)
            );
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function diff($new, $old)
    {
        /** @psalm-suppress InternalMethod */
        $comparator = new Comparator();

The class Bdf\Prime\Schema\Comparator has been deprecated: since 1.3 Use Prime comparators instead

        $comparator->setListDropColumn($this->useDrop);

        return $comparator->compare(
            $this->schema($old),
            $this->schema($new)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function rename(string $from, string $to)
    {
        /** @psalm-suppress InternalMethod */
        $diff = new DoctrineTableDiff($from);
        $diff->newName = $to;

The property Doctrine\DBAL\Schema\TableDiff::$newName has been deprecated: Rename tables via {@link AbstractSchemaManager::renameTable()} instead.

        try {
            return $this->push(
                $this->platform->grammar()->getAlterTableSQL($diff)
            );
        } catch (DoctrineDBALException $e) {
            /** @psalm-suppress InvalidScalarArgument */
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function push($queries)
    {
        if ($queries instanceof DoctrineSchema || $queries instanceof DoctrineSchemaDiff) {
            $queries = $queries->toSql($this->platform->grammar());

The function Doctrine\DBAL\Schema\SchemaDiff::toSql() has been deprecated: Use {@link AbstractPlatform::getAlterSchemaSQL()} instead.

        }

        foreach ((array)$queries as $query) {
            $this->queries[] = $query;
        }

        if ($this->autoFlush) {
            $this->flush();
        }

        return $this;
    }
}