Backpack\CRUD\app\Library\Database\DatabaseSchema

Complexity

Total Complexity

26

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Importance

Changes	3
Bugs	2	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	mapTable()	0	27	5
A	getCreateSchema()	0	5	2
A	getManager()	0	5	2
A	dbalTypes()	0	13	1
A	generateDatabaseSchema()	0	4	2
A	listTableColumnsNames()	0	5	2
A	getSchemaManager()	0	13	3
A	getIndexColumnNames()	0	11	2
A	getTables()	0	17	4
A	listTableIndexes()	0	3	1
A	getForTable()	0	7	2

<?php

namespace Backpack\CRUD\app\Library\Database;

use Illuminate\Support\Arr;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\LazyCollection;

final class DatabaseSchema
{
    private static $schema;

    /**
     * Return the schema for the table.
     */
    public static function getForTable(string $table, string $connection)
    {
        $connection = $connection ?: config('database.default');

        self::generateDatabaseSchema($connection, $table);

        return self::$schema[$connection][$table] ?? null;
    }

    public static function getTables(string $connection = null): array
    {
        $connection = $connection ?: config('database.default');

        self::$schema[$connection] = LazyCollection::make(self::getCreateSchema($connection)->getTables())->mapWithKeys(function ($table, $key) use ($connection) {

The parameter $key is not used and could be removed.

self::getCreateSchema($connection)->getTables() of type Doctrine\DBAL\Schema\Table[]|array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $items of Illuminate\Support\LazyCollection::make().

The method getTables() does not exist on Doctrine\DBAL\Schema\AbstractSchemaManager.

            $tableName = is_array($table) ? $table['name'] : $table->getName();

            if ($existingTable = self::$schema[$connection][$tableName] ?? false) {
                return [$tableName => $existingTable];
            }
           
            $table = self::mapTable($connection, $tableName);

            return [$tableName => $table];
        })->toArray();

        return self::$schema[$connection];
    }

    public function listTableColumnsNames(string $connection, string $table)
    {
        $table = self::getForTable($table, $connection);

        return $table ? array_keys($table->getColumns()) : [];
    }

    public function listTableIndexes(string $connection, string $table)
    {
        return self::getIndexColumnNames($connection, $table);
    }

    public function getManager(string $connection = null)
    {
        $connection = $connection ?: config('database.default');

        return self::getSchemaManager($connection);
    }

    /**
     * Generates and store the database schema.
     */
    private static function generateDatabaseSchema(string $connection, string $table)
    {
        if (! isset(self::$schema[$connection][$table])) {
            self::$schema[$connection][$table] = self::mapTable($connection, $table);
        }
    }

    private static function mapTable(string $connection, string $tableName)
    {
        try {
            $table = method_exists(self::getCreateSchema($connection), 'getTable') ? 
                        self::getCreateSchema($connection)->getTable($tableName) : 

The method getTable() does not exist on Doctrine\DBAL\Schema\AbstractSchemaManager.

                        self::getCreateSchema($connection)->getColumns($tableName);

The method getColumns() does not exist on Doctrine\DBAL\Schema\AbstractSchemaManager.

The method getColumns() does not exist on Doctrine\DBAL\Schema\Schema.

        } catch (\Exception $e) {
            return new Table($tableName, []);
        }
 
        if(!is_array($table) || empty($table)) {
            return $table;
        }

        $schemaManager = self::getSchemaManager($connection);
        $indexes = $schemaManager->getIndexes($tableName);

The method getIndexes() does not exist on Doctrine\DBAL\Schema\AbstractSchemaManager.

        $indexes = array_map(function ($index) {
            return $index['columns'];
        }, $indexes);

        $table = new Table($tableName, $table);
        
        $indexes = Arr::flatten($indexes);
        $table->setIndexes(array_unique($indexes));

        return $table;
    }

    private static function getIndexColumnNames(string $connection, string $table)
    {
        self::generateDatabaseSchema($connection, $table);

        $indexes = self::$schema[$connection][$table]->getIndexes();
        
        $indexes = \Illuminate\Support\Arr::flatten(array_map(function ($index) {
            return is_string($index) ? $index : $index->getColumns();
        }, $indexes));

        return array_unique($indexes);
    }

    private static function getCreateSchema(string $connection)
    {
        $schemaManager = self::getSchemaManager($connection);

        return method_exists($schemaManager, 'createSchema') ? $schemaManager->createSchema() : $schemaManager;

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

    }

    private static function dbalTypes()
    {
        return [
            'enum' => \Doctrine\DBAL\Types\Types::STRING,
            'jsonb' => \Doctrine\DBAL\Types\Types::JSON,
            'geometry' => \Doctrine\DBAL\Types\Types::STRING,
            'point' => \Doctrine\DBAL\Types\Types::STRING,
            'lineString' => \Doctrine\DBAL\Types\Types::STRING,
            'polygon' => \Doctrine\DBAL\Types\Types::STRING,
            'multiPoint' => \Doctrine\DBAL\Types\Types::STRING,
            'multiLineString' => \Doctrine\DBAL\Types\Types::STRING,
            'multiPolygon' => \Doctrine\DBAL\Types\Types::STRING,
            'geometryCollection' => \Doctrine\DBAL\Types\Types::STRING,
        ];
    }

    private static function getSchemaManager(string $connection)
    {
        $connection = DB::connection($connection);

        if (method_exists($connection, 'getDoctrineSchemaManager')) {
            foreach (self::dbalTypes() as $key => $value) {
                $connection->getDoctrineSchemaManager()->getDatabasePlatform()->registerDoctrineTypeMapping($key, $value);

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

            }

            return $connection->getDoctrineSchemaManager();
        }

        return $connection->getSchemaBuilder();
    }
}