TableManager::addIdColumn() - Code Metrics - Inspection of "feat: foreign key constraints , closes #62" - scrawler-labs/arca-orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( f4a2aa...551259 )

by Pranjal

created 2024-10-11 03:30 UTC

TableManager::addIdColumn() A

↳ Parent: TableManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	17
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	11
c	0
b	0
f	0
nc	2
nop	2
dl	0
loc	17
rs	9.9

<?php
/*
 * This file is part of the Scrawler package.
 *
 * (c) Pranjal Pandey <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Scrawler\Arca\Manager;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Doctrine\DBAL\Schema\Exception\TableDoesNotExist;
use Doctrine\DBAL\Schema\Schema;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Types\Type;
use Scrawler\Arca\Config;
use Scrawler\Arca\Model;

/**
 * Class resposible for creating and modifing table.
 */
final class TableManager
{
    /**
     * Store the instance of SchemaManager.
     */
    private AbstractSchemaManager $manager;

    /**
     * Store the instance of Platform.
     */
    private \Doctrine\DBAL\Platforms\AbstractPlatform $platform;

    /**
     * create TableManager.
     */
    public function __construct(
        private Connection $connection,
        private Config $config,
    ) {
        $this->manager = $this->connection->createSchemaManager();
        $this->platform = $this->connection->getDatabasePlatform();
    }

    /**
     * Creates a table schema from table instance.
     */
    public function createTableSchema(Table $table): Schema
    {
        return new Schema([$table]);
    }

    /**
     * Get Table schema from existing table.
     */
    public function getTableSchema(string $table): Schema
    {
        return new Schema([$this->manager->introspectTable($table)]);
    }

    /**
     * Get Table detail from existing table.
     */
    public function getTable(string $table): Table
    {
        return $this->manager->introspectTable($table);
    }

    /**
     * Create table from model.
     *
     * @param array<TableConstraint> $constraints
     */
    public function createTable(Model $model, array $constraints = []): Table
    {
        $table = new Table($model->getName());
        $table = $this->addPrimaryKey($table);
        $types = $model->getTypes();
        foreach ($model->getSelfProperties() as $key => $value) {
            $key_array = explode('_', $key);
            if ('id' != $key && 'id' == end($key_array)) {
                $table = $this->addIdColumn($table, $key);
            } elseif ('id' != $key) {
                $table->addColumn(
                    $key,
                    $types[$key],
                    ['notnull' => false, 'comment' => $types[$key]]
                );
            }
        }

        foreach ($constraints as $constraint) {
            $table->addForeignKeyConstraint(
                $constraint->getForeignTableName(),
                [$constraint->getLocalColumnName()],
                [$constraint->getForeignColumnName()],
                ['onUpdate' => 'CASCADE', 'onDelete' => 'CASCADE']
            );
        }

        return $table;
    }

    private function addPrimaryKey(Table $table): Table
    {
        if ($this->config->isUsingUUID()) {
            $table->addColumn(
                'id',
                'string',
                ['length' => 36, 'notnull' => true, 'comment' => 'string']
            );
        } else {
            $table->addColumn(
                'id',
                'integer',
                ['unsigned' => true, 'autoincrement' => true, 'comment' => 'integer']
            );
        }
        $table->setPrimaryKey(['id']);

        return $table;
    }

    /**
     * Add id column to table.
     */
    private function addIdColumn(Table $table, string $key): Table
    {
        if ($this->config->isUsingUUID()) {
            $table->addColumn(
                $key,
                'string',
                ['length' => 36, 'notnull' => true, 'comment' => 'string']
            );
        } else {
            $table->addColumn(
                $key,
                'integer',
                ['unsigned' => true, 'notnull' => true, 'comment' => 'integer']
            );
        }

        return $table;
    }

    /**
     * Save table to database.
     */
    public function saveTable(Table $table): void
    {
        $schema = $this->createTableSchema($table);
        $queries = $schema->toSql($this->platform);
        foreach ($queries as $query) {
            $this->connection->executeQuery($query);
        }
    }

    /**
     * Add missing column to existing table from given table.
     */
    public function updateTable(string $table_name, Table $new_table): void
    {
        $comparator = $this->manager->createComparator();
        $old_table = $this->getTable($table_name);
        $old_schema = $this->getTableSchema($table_name);

        $tableDiff = $comparator->compareTables($old_table, $new_table);
        $mod_table = $old_table;
        foreach ($tableDiff->getAddedColumns() as $column) {
            $mod_table->addColumn(
                $column->getName(),
                Type::getTypeRegistry()->lookupName($column->getType()),
                [
                    'notnull' => $column->getNotnull(),
                    'comment' => $column->getComment(),
                    'default' => $column->getDefault(),
                ]
            );
        }
        $new_schema = $this->createTableSchema($mod_table);
        $schemaDiff = $comparator->compareSchemas($old_schema, $new_schema);

        $queries = $this->platform->getAlterSchemaSQL($schemaDiff);

        foreach ($queries as $query) {
            $this->connection->executeQuery($query);
        }
    }

    /**
     * Check if table exists.
     */
    public function tableExists(string $table_name): bool
    {
        try {
            $this->getTable($table_name);

            return true;
        } catch (TableDoesNotExist $e) {
            return false;
        }
    }

    /**
     * If table exist update it else create it.
     */
    public function saveOrUpdateTable(string $table_name, Table $new_table): void
    {
        if ($this->tableExists($table_name)) {
            $this->updateTable($table_name, $new_table);

            return;
        }

        $this->saveTable($new_table);

        return;
    }
}


1			<?php
2			/*
3			* This file is part of the Scrawler package.
4			*
5			* (c) Pranjal Pandey <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace Scrawler\Arca\Manager;
12
13			use Doctrine\DBAL\Connection;
14			use Doctrine\DBAL\Schema\AbstractSchemaManager;
15			use Doctrine\DBAL\Schema\Exception\TableDoesNotExist;
16			use Doctrine\DBAL\Schema\Schema;
17			use Doctrine\DBAL\Schema\Table;
18			use Doctrine\DBAL\Types\Type;
19			use Scrawler\Arca\Config;
20			use Scrawler\Arca\Model;
21
22			/**
23			* Class resposible for creating and modifing table.
24			*/
25			final class TableManager
26			{
27			/**
28			* Store the instance of SchemaManager.
29			*/
30			private AbstractSchemaManager $manager;
31
32			/**
33			* Store the instance of Platform.
34			*/
35			private \Doctrine\DBAL\Platforms\AbstractPlatform $platform;
36
37			/**
38			* create TableManager.
39			*/
40			public function __construct(
41			private Connection $connection,
42			private Config $config,
43			) {
44			$this->manager = $this->connection->createSchemaManager();
45			$this->platform = $this->connection->getDatabasePlatform();
46			}
47
48			/**
49			* Creates a table schema from table instance.
50			*/
51			public function createTableSchema(Table $table): Schema
52			{
53			return new Schema([$table]);
54			}
55
56			/**
57			* Get Table schema from existing table.
58			*/
59			public function getTableSchema(string $table): Schema
60			{
61			return new Schema([$this->manager->introspectTable($table)]);
62			}
63
64			/**
65			* Get Table detail from existing table.
66			*/
67			public function getTable(string $table): Table
68			{
69			return $this->manager->introspectTable($table);
70			}
71
72			/**
73			* Create table from model.
74			*
75			* @param array<TableConstraint> $constraints
76			*/
77			public function createTable(Model $model, array $constraints = []): Table
78			{
79			$table = new Table($model->getName());
80			$table = $this->addPrimaryKey($table);
81			$types = $model->getTypes();
82			foreach ($model->getSelfProperties() as $key => $value) {
83			$key_array = explode('_', $key);
84			if ('id' != $key && 'id' == end($key_array)) {
85			$table = $this->addIdColumn($table, $key);
86			} elseif ('id' != $key) {
87			$table->addColumn(
88			$key,
89			$types[$key],
90			['notnull' => false, 'comment' => $types[$key]]
91			);
92			}
93			}
94
95			foreach ($constraints as $constraint) {
96			$table->addForeignKeyConstraint(
97			$constraint->getForeignTableName(),
98			[$constraint->getLocalColumnName()],
99			[$constraint->getForeignColumnName()],
100			['onUpdate' => 'CASCADE', 'onDelete' => 'CASCADE']
101			);
102			}
103
104			return $table;
105			}
106
107			private function addPrimaryKey(Table $table): Table
108			{
109			if ($this->config->isUsingUUID()) {
110			$table->addColumn(
111			'id',
112			'string',
113			['length' => 36, 'notnull' => true, 'comment' => 'string']
114			);
115			} else {
116			$table->addColumn(
117			'id',
118			'integer',
119			['unsigned' => true, 'autoincrement' => true, 'comment' => 'integer']
120			);
121			}
122			$table->setPrimaryKey(['id']);
123
124			return $table;
125			}
126
127			/**
128			* Add id column to table.
129			*/
130			private function addIdColumn(Table $table, string $key): Table
131			{
132			if ($this->config->isUsingUUID()) {
133			$table->addColumn(
134			$key,
135			'string',
136			['length' => 36, 'notnull' => true, 'comment' => 'string']
137			);
138			} else {
139			$table->addColumn(
140			$key,
141			'integer',
142			['unsigned' => true, 'notnull' => true, 'comment' => 'integer']
143			);
144			}
145
146			return $table;
147			}
148
149			/**
150			* Save table to database.
151			*/
152			public function saveTable(Table $table): void
153			{
154			$schema = $this->createTableSchema($table);
155			$queries = $schema->toSql($this->platform);
156			foreach ($queries as $query) {
157			$this->connection->executeQuery($query);
158			}
159			}
160
161			/**
162			* Add missing column to existing table from given table.
163			*/
164			public function updateTable(string $table_name, Table $new_table): void
165			{
166			$comparator = $this->manager->createComparator();
167			$old_table = $this->getTable($table_name);
168			$old_schema = $this->getTableSchema($table_name);
169
170			$tableDiff = $comparator->compareTables($old_table, $new_table);
171			$mod_table = $old_table;
172			foreach ($tableDiff->getAddedColumns() as $column) {
173			$mod_table->addColumn(
174			$column->getName(),
175			Type::getTypeRegistry()->lookupName($column->getType()),
176			[
177			'notnull' => $column->getNotnull(),
178			'comment' => $column->getComment(),
179			'default' => $column->getDefault(),
180			]
181			);
182			}
183			$new_schema = $this->createTableSchema($mod_table);
184			$schemaDiff = $comparator->compareSchemas($old_schema, $new_schema);
185
186			$queries = $this->platform->getAlterSchemaSQL($schemaDiff);
187
188			foreach ($queries as $query) {
189			$this->connection->executeQuery($query);
190			}
191			}
192
193			/**
194			* Check if table exists.
195			*/
196			public function tableExists(string $table_name): bool
197			{
198			try {
199			$this->getTable($table_name);
200
201			return true;
202			} catch (TableDoesNotExist $e) {
203			return false;
204			}
205			}
206
207			/**
208			* If table exist update it else create it.
209			*/
210			public function saveOrUpdateTable(string $table_name, Table $new_table): void
211			{
212			if ($this->tableExists($table_name)) {
213			$this->updateTable($table_name, $new_table);
214
215			return;
216			}
217
218			$this->saveTable($new_table);
219
220			return;
221			}
222			}
223

scrawler-labs / arca-orm

Push — main ( f4a2aa...551259 )

TableManager::addIdColumn() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like