SchemaManager::truncate() - Code Metrics - Inspection of "Refactor exception system" - b2pweb/bdf-prime - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#13)

by Vincent
created 2020-11-24 10:04 UTC
SchemaManager::truncate() A

↳ Parent: SchemaManager
Complexity

Conditions	2
Paths	2
Size

Total Lines	8
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	3
CRAP Score	2.2559
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	5
c	1
b	0
f	0
dl	0
loc	8
ccs	3
cts	5
cp	0.6
rs	10
cc	2
nc	2
nop	2
crap	2.2559
<?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\DBALException 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
 */
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();
        return $this->connection->/** @scrutinizer ignore-call */ getSchemaManager();
    }
    
    /**
     * Get the queries to execute
     * 
     * @return array
     */
    public function toSql()
    {
        return $this->queries;
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function flush()
    {
        $lastResult = false;
        $queries = $this->queries;
        
        $this->clear();
        
        foreach ($queries as $query) {
            $lastResult = $this->connection->exec($query);
            $lastResult = $this->connection->exec($query);
        }
        
        return $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();
    }

    /**

     * {@inheritdoc}
     */

    public function hasDatabase($database)
    {
        try {
            $databases = $this->getDoctrineManager()->listDatabases($database);
            $databases = $this->getDoctrineManager()->/** @scrutinizer ignore-call */ listDatabases($database);
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }

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

    /**
     * {@inheritdoc}
     */

    public function getDatabases()
    {
        try {
            return $this->getDoctrineManager()->listDatabases();
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

     * {@inheritdoc}
     */

    public function createDatabase($database)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getCreateDatabaseSQL($database)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

     * {@inheritdoc}
     */

    public function dropDatabase($database)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getDropDatabaseSQL($database)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

     * {@inheritdoc}
     */

    public function hasTable($tableName)
    {
        try {
            return $this->getDoctrineManager()->tablesExist($tableName);
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

     * {@inheritdoc}
     */

    public function loadTable($tableName)
    {
        try {
            $manager = $this->getDoctrineManager();

            $foreignKeys = [];

            if ($this->platform->grammar()->supportsForeignKeyConstraints()) {
                $foreignKeys = $manager->listTableForeignKeys($tableName);
            }

            return new PrimeTableAdapter(
                new DoctrineTable(
                    $tableName,
                    $manager->listTableColumns($tableName),
                    $manager->listTableIndexes($tableName),
                    $foreignKeys
                ),
                $this->connection->platform()->types()
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }

    }

    /**

     * {@inheritdoc}
     */

    public function drop($tableName)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getDropTableSQL($tableName)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

     * {@inheritdoc}
     */

    public function truncate($tableName, $cascade = false)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getTruncateTableSQL($tableName, $cascade)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

     * {@inheritdoc}
     */
    public function diff(TableInterface $newTable, TableInterface $oldTable)
    {
        $comparator = new Comparator();
        $comparator = /** @scrutinizer ignore-deprecated */ new Comparator();
        $comparator->setListDropColumn($this->useDrop);

        return $comparator->compare(
            $this->schema($oldTable),
            $this->schema($newTable)
        );
    }

    /**

     * {@inheritdoc}
     */

    public function rename($from, $to)
    {
        $diff = new DoctrineTableDiff($from);
        $diff->newName = $to;

        try {
            return $this->push(
                $this->platform->grammar()->getAlterTableSQL($diff)
            );
        } catch (DoctrineDBALException $e) {
            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());
        }

        foreach ((array)$queries as $query) {

            $this->queries[] = $query;
        }

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

        return $this;
    }
}

b2pweb / bdf-prime

Pull Request — master (#13)

SchemaManager::truncate() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
