PostgresColumn::compare() - Code Metrics - Inspection of "Update PostgresColumn.php" - spiral/components - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — feature/pre-split (42159e)

by Anton

created 2016-12-28 22:50 UTC

PostgresColumn::compare() A

↳ Parent: PostgresColumn

Complexity

Conditions	4
Paths	3

Size

Total Lines	16
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	8
nc	3
nop	1
dl	0
loc	16
rs	9.2
c	0
b	0
f	0

<?php
/**
 * Spiral Framework, Core Components
 *
 * @author    Wolfy-J
 */
namespace Spiral\Database\Drivers\Postgres\Schemas;

use Spiral\Database\Entities\Driver;
use Spiral\Database\Injections\Fragment;
use Spiral\Database\Schemas\ColumnInterface;
use Spiral\Database\Schemas\Prototypes\AbstractColumn;

/**
 * @todo investigate potential issue with entity non handling enum correctly when multiple
 * @todo column changes happen in one session (who the hell will do that?)
 */
class PostgresColumn extends AbstractColumn
{
    /**
     * Default timestamp expression (driver specific).
     */
    const DATETIME_NOW = 'now()';

    /**
     * Private state related values.
     */
    const EXCLUDE_FROM_COMPARE = [
        'timezone',
        'constrained',
        'constrainName'
    ];

    /**
     * {@inheritdoc}
     */
    protected $mapping = [
        //Primary sequences
        'primary'     => ['type' => 'serial', 'autoIncrement' => true, 'nullable' => false],
        'bigPrimary'  => ['type' => 'bigserial', 'autoIncrement' => true, 'nullable' => false],

        //Enum type (mapped via method)
        'enum'        => 'enum',

        //Logical types
        'boolean'     => 'boolean',

        //Integer types (size can always be changed with size method), longInteger has method alias
        //bigInteger
        'integer'     => 'integer',
        'tinyInteger' => 'smallint',
        'bigInteger'  => 'bigint',

        //String with specified length (mapped via method)
        'string'      => 'character varying',

        //Generic types
        'text'        => 'text',
        'tinyText'    => 'text',
        'longText'    => 'text',

        //Real types
        'double'      => 'double precision',
        'float'       => 'real',

        //Decimal type (mapped via method)
        'decimal'     => 'numeric',

        //Date and Time types
        'datetime'    => 'timestamp without time zone',
        'date'        => 'date',
        'time'        => 'time without time zone',
        'timestamp'   => 'timestamp without time zone',

        //Binary types
        'binary'      => 'bytea',
        'tinyBinary'  => 'bytea',
        'longBinary'  => 'bytea',

        //Additional types
        'json'        => 'text',
    ];

    /**
     * {@inheritdoc}
     */
    protected $reverseMapping = [
        'primary'     => ['serial'],
        'bigPrimary'  => ['bigserial'],
        'enum'        => ['enum'],
        'boolean'     => ['boolean'],
        'integer'     => ['int', 'integer', 'int4'],
        'tinyInteger' => ['smallint'],
        'bigInteger'  => ['bigint', 'int8'],
        'string'      => ['character varying', 'character'],
        'text'        => ['text'],
        'double'      => ['double precision'],
        'float'       => ['real', 'money'],
        'decimal'     => ['numeric'],
        'date'        => ['date'],
        'time'        => ['time', 'time with time zone', 'time without time zone'],
        'timestamp'   => ['timestamp', 'timestamp with time zone', 'timestamp without time zone'],
        'binary'      => ['bytea'],
        'json'        => ['text'],
    ];

    /**
     * Field is auto incremental.
     *
     * @var bool
     */
    protected $autoIncrement = false;

    /**
     * Indication that column have enum constrain.
     *
     * @var bool
     */
    protected $constrained = false;

    /**
     * Name of enum constraint associated with field.
     *
     * @var string
     */
    protected $constrainName = '';

    /**
     * {@inheritdoc}
     */
    public function getConstraints(): array
    {
        $constraints = parent::getConstraints();

        if ($this->constrained) {
            $constraints[] = $this->constrainName;
        }

        return $constraints;
    }

    /**
     * {@inheritdoc}
     */
    public function abstractType(): string
    {
        if (!empty($this->enumValues)) {
            return 'enum';
        }

        return parent::abstractType();
    }

    /**
     * {@inheritdoc}
     */
    public function primary(): AbstractColumn
    {
        if (!empty($this->type) && $this->type != 'serial') {
            //Change type of already existed column (we can't use "serial" alias here)
            $this->type = 'integer';

            return $this;
        }

        return $this->setType('primary');
    }

    /**
     * {@inheritdoc}
     */
    public function bigPrimary(): AbstractColumn
    {
        if (!empty($this->type) && $this->type != 'bigserial') {
            //Change type of already existed column (we can't use "serial" alias here)
            $this->type = 'bigint';

            return $this;
        }

        return $this->setType('bigPrimary');
    }

    /**
     * {@inheritdoc}
     */
    public function enum($values): AbstractColumn

    {
        $this->enumValues = array_map('strval', is_array($values) ? $values : func_get_args());

        $this->type = 'character';
        foreach ($this->enumValues as $value) {
            $this->size = max((int)$this->size, strlen($value));
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function sqlStatement(Driver $driver): string
    {
        $statement = parent::sqlStatement($driver);

        if ($this->abstractType() != 'enum') {
            //Nothing special
            return $statement;
        }

        //We have add constraint for enum type
        $enumValues = [];
        foreach ($this->enumValues as $value) {
            $enumValues[] = $driver->quote($value);
        }

        $constrain = $driver->identifier($this->enumConstraint());
        $column = $driver->identifier($this->getName());
        $values = implode(', ', $enumValues);

        return "{$statement} CONSTRAINT {$constrain} CHECK ($column IN ({$values}))";
    }

    /**
     * Generate set of operations need to change column.
     *
     * @param Driver         $driver
     * @param AbstractColumn $initial
     *
     * @return array
     */
    public function alterOperations(Driver $driver, AbstractColumn $initial): array
    {
        $operations = [];

        //To simplify comparation
        $currentType = [$this->type, $this->size, $this->precision, $this->scale];
        $initialType = [$initial->type, $initial->size, $initial->precision, $initial->scale];

        $identifier = $driver->identifier($this->getName());

        /*
         * This block defines column type and all variations.
         */
        if ($currentType != $initialType) {
            if ($this->abstractType() == 'enum') {
                //Getting longest value
                $enumSize = $this->size;
                foreach ($this->enumValues as $value) {
                    $enumSize = max($enumSize, strlen($value));
                }

                $type = "ALTER COLUMN {$identifier} TYPE character($enumSize)";
                $operations[] = $type;
            } else {
                $type = "ALTER COLUMN {$identifier} TYPE {$this->type}";

                if (!empty($this->size)) {
                    $type .= "($this->size)";
                } elseif (!empty($this->precision)) {
                    $type .= "($this->precision, $this->scale)";
                }

                //Required to perform cross conversion
                $operations[] = "{$type} USING {$identifier}::{$this->type}";
            }
        }

        //Dropping enum constrain before any operation
        if ($initial->abstractType() == 'enum' && $this->constrained) {
            $operations[] = 'DROP CONSTRAINT ' . $driver->identifier($this->enumConstraint());
        }

        //Default value set and dropping
        if ($initial->defaultValue != $this->defaultValue) {
            if (is_null($this->defaultValue)) {
                $operations[] = "ALTER COLUMN {$identifier} DROP DEFAULT";
            } else {
                $operations[] = "ALTER COLUMN {$identifier} SET DEFAULT {$this->quoteDefault($driver)}";
            }
        }

        //Nullable option
        if ($initial->nullable != $this->nullable) {
            $operations[] = "ALTER COLUMN {$identifier} " . (!$this->nullable ? 'SET' : 'DROP') . ' NOT NULL';
        }

        if ($this->abstractType() == 'enum') {
            $enumValues = [];
            foreach ($this->enumValues as $value) {
                $enumValues[] = $driver->quote($value);
            }

            $operations[] = "ADD CONSTRAINT {$driver->identifier($this->enumConstraint())} "
                . "CHECK ({$identifier} IN (" . implode(', ', $enumValues) . '))';
        }

        return $operations;
    }

    /**
     * {@inheritdoc}
     */
    protected function quoteEnum(Driver $driver): string
    {
        //Postgres enums are just constrained strings
        return '(' . $this->size . ')';
    }

    /**
     * Get/generate name for enum constraint.
     *
     * @return string
     */
    private function enumConstraint(): string

    {
        if (empty($this->constrainName)) {
            $this->constrainName = $this->table . '_' . $this->getName() . '_enum_' . uniqid();
        }

        return $this->constrainName;
    }

    /**
     * Normalize default value.
     */
    private function normalizeDefault()
    {
        if ($this->hasDefaultValue()) {
            if (preg_match("/^'?(.*?)'?::(.+)/", $this->defaultValue, $matches)) {
                //In database: 'value'::TYPE
                $this->defaultValue = $matches[1];
            } elseif ($this->type == 'bit') {
                $this->defaultValue = bindec(
                    substr($this->defaultValue, 2, strpos($this->defaultValue, '::') - 3)
                );
            } elseif ($this->type == 'boolean') {
                $this->defaultValue = (strtolower($this->defaultValue) == 'true');
            }
        }
    }

    /**
     * @param string $table  Table name.
     * @param array  $schema
     * @param Driver $driver Postgres columns are bit more complex.
     *
     * @return PostgresColumn
     */
    public static function createInstance(string $table, array $schema, Driver $driver): self
    {
        $column = new self($table, $schema['column_name'], $driver->getTimezone());

        $column->type = $schema['data_type'];
        $column->defaultValue = $schema['column_default'];
        $column->nullable = $schema['is_nullable'] == 'YES';

        if (
            in_array($column->type, ['int', 'bigint', 'integer'])
            && preg_match('/nextval(.*)/', $column->defaultValue)
        ) {
            $column->type = ($column->type == 'bigint' ? 'bigserial' : 'serial');
            $column->autoIncrement = true;

            $column->defaultValue = new Fragment($column->defaultValue);

            return $column;
        }

        if (strpos($column->type, 'char') !== false && $schema['character_maximum_length']) {
            $column->size = $schema['character_maximum_length'];
        }

        if ($column->type == 'numeric') {

            $column->precision = $schema['numeric_precision'];
            $column->scale = $schema['numeric_scale'];
        }

        if ($column->type == 'USER-DEFINED' && $schema['typtype'] == 'e') {
            $column->type = $schema['typname'];

            /**
             * Attention, this is not default spiral enum type emulated via CHECK. This is real
             * Postgres enum type.
             */
            self::resolveEnum($driver, $column);
        }

        if (strpos($column->type, 'char') !== false && !empty($column->size)) {
            //Potential enum with manually created constraint (check in)
            self::resolveConstrains($driver, $schema['tableOID'], $column);
        }

        $column->normalizeDefault();

        return $column;
    }

    /**
     * Resolving enum constrain and converting it into proper enum values set.
     *
     * @param Driver         $driver
     * @param string|int     $tableOID
     * @param PostgresColumn $column
     */
    private static function resolveConstrains(Driver $driver, $tableOID, PostgresColumn $column)
    {
        $query = "SELECT conname, consrc FROM pg_constraint WHERE conrelid = ? AND contype = 'c' AND (consrc LIKE ? OR consrc LIKE ?)";

        $constraints = $driver->query($query, [
            $tableOID,
            '(' . $column->name . '%',
            '("' . $column->name . '%'
        ]);

        foreach ($constraints as $constraint) {
            if (preg_match('/ARRAY\[([^\]]+)\]/', $constraint['consrc'], $matches)) {
                $enumValues = explode(',', $matches[1]);
                foreach ($enumValues as &$value) {

                    if (preg_match("/^'?(.*?)'?::(.+)/", trim($value), $matches)) {
                        //In database: 'value'::TYPE
                        $value = $matches[1];
                    }

                    unset($value);
                }

                $column->enumValues = $enumValues;
                $column->constrainName = $constraint['conname'];
                $column->constrained = true;
            }
        }
    }

    /**
     * Resolve native ENUM type if presented.
     *
     * @param Driver         $driver
     * @param PostgresColumn $column
     */
    private static function resolveEnum(Driver $driver, PostgresColumn $column)
    {
        $range = $driver->query('SELECT enum_range(NULL::' . $column->type . ')')->fetchColumn(0);

        $column->enumValues = explode(',', substr($range, 1, -1));

        if (!empty($column->defaultValue)) {
            //In database: 'value'::enumType
            $column->defaultValue = substr(
                $column->defaultValue,
                1,
                strpos($column->defaultValue, $column->type) - 4
            );
        }
    }

    /**
     * {@inheritdoc}
     */
    public function compare(ColumnInterface $initial): bool
    {
        if (parent::compare($initial)) {
            return true;
        }

        if (
            in_array($this->abstractType(), ['primary', 'bigPrimary'])
            && $initial->getDefaultValue() != $this->getDefaultValue()
        ) {
            //PG adds default values to primary keys
            return true;
        }

        return false;
    }
}


1		<?php
2		/**
3		* Spiral Framework, Core Components
4		*
5		* @author Wolfy-J
6		*/
7		namespace Spiral\Database\Drivers\Postgres\Schemas;
8
9		use Spiral\Database\Entities\Driver;
10		use Spiral\Database\Injections\Fragment;
11		use Spiral\Database\Schemas\ColumnInterface;
12		use Spiral\Database\Schemas\Prototypes\AbstractColumn;
13
14		/**
15		* @todo investigate potential issue with entity non handling enum correctly when multiple
16		* @todo column changes happen in one session (who the hell will do that?)
17		*/
18		class PostgresColumn extends AbstractColumn
19		{
20		/**
21		* Default timestamp expression (driver specific).
22		*/
23		const DATETIME_NOW = 'now()';
24
25		/**
26		* Private state related values.
27		*/
28		const EXCLUDE_FROM_COMPARE = [
29		'timezone',
30		'constrained',
31		'constrainName'
32		];
33
34		/**
35		* {@inheritdoc}
36		*/
37		protected $mapping = [
38		//Primary sequences
39		'primary' => ['type' => 'serial', 'autoIncrement' => true, 'nullable' => false],
40		'bigPrimary' => ['type' => 'bigserial', 'autoIncrement' => true, 'nullable' => false],
41
42		//Enum type (mapped via method)
43		'enum' => 'enum',
44
45		//Logical types
46		'boolean' => 'boolean',
47
48		//Integer types (size can always be changed with size method), longInteger has method alias
49		//bigInteger
50		'integer' => 'integer',
51		'tinyInteger' => 'smallint',
52		'bigInteger' => 'bigint',
53
54		//String with specified length (mapped via method)
55		'string' => 'character varying',
56
57		//Generic types
58		'text' => 'text',
59		'tinyText' => 'text',
60		'longText' => 'text',
61
62		//Real types
63		'double' => 'double precision',
64		'float' => 'real',
65
66		//Decimal type (mapped via method)
67		'decimal' => 'numeric',
68
69		//Date and Time types
70		'datetime' => 'timestamp without time zone',
71		'date' => 'date',
72		'time' => 'time without time zone',
73		'timestamp' => 'timestamp without time zone',
74
75		//Binary types
76		'binary' => 'bytea',
77		'tinyBinary' => 'bytea',
78		'longBinary' => 'bytea',
79
80		//Additional types
81		'json' => 'text',
82		];
83
84		/**
85		* {@inheritdoc}
86		*/
87		protected $reverseMapping = [
88		'primary' => ['serial'],
89		'bigPrimary' => ['bigserial'],
90		'enum' => ['enum'],
91		'boolean' => ['boolean'],
92		'integer' => ['int', 'integer', 'int4'],
93		'tinyInteger' => ['smallint'],
94		'bigInteger' => ['bigint', 'int8'],
95		'string' => ['character varying', 'character'],
96		'text' => ['text'],
97		'double' => ['double precision'],
98		'float' => ['real', 'money'],
99		'decimal' => ['numeric'],
100		'date' => ['date'],
101		'time' => ['time', 'time with time zone', 'time without time zone'],
102		'timestamp' => ['timestamp', 'timestamp with time zone', 'timestamp without time zone'],
103		'binary' => ['bytea'],
104		'json' => ['text'],
105		];
106
107		/**
108		* Field is auto incremental.
109		*
110		* @var bool
111		*/
112		protected $autoIncrement = false;
113
114		/**
115		* Indication that column have enum constrain.
116		*
117		* @var bool
118		*/
119		protected $constrained = false;
120
121		/**
122		* Name of enum constraint associated with field.
123		*
124		* @var string
125		*/
126		protected $constrainName = '';
127
128		/**
129		* {@inheritdoc}
130		*/
131		public function getConstraints(): array
132		{
133		$constraints = parent::getConstraints();
134
135		if ($this->constrained) {
136		$constraints[] = $this->constrainName;
137		}
138
139		return $constraints;
140		}
141
142		/**
143		* {@inheritdoc}
144		*/
145		public function abstractType(): string
146		{
147		if (!empty($this->enumValues)) {
148		return 'enum';
149		}
150
151		return parent::abstractType();
152		}
153
154		/**
155		* {@inheritdoc}
156		*/
157		public function primary(): AbstractColumn
158		{
159		if (!empty($this->type) && $this->type != 'serial') {
160		//Change type of already existed column (we can't use "serial" alias here)
161		$this->type = 'integer';
162
163		return $this;
164		}
165
166		return $this->setType('primary');
167		}
168
169		/**
170		* {@inheritdoc}
171		*/
172		public function bigPrimary(): AbstractColumn
173		{
174		if (!empty($this->type) && $this->type != 'bigserial') {
175		//Change type of already existed column (we can't use "serial" alias here)
176		$this->type = 'bigint';
177
178		return $this;
179		}
180
181		return $this->setType('bigPrimary');
182		}
183
184		/**
185		* {@inheritdoc}
186		*/
187	View Code Duplication	public function enum($values): AbstractColumn
		0 ignored issues – show Duplication introduced 2016-12-14 14:22 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
188		{
189		$this->enumValues = array_map('strval', is_array($values) ? $values : func_get_args());
190
191		$this->type = 'character';
192		foreach ($this->enumValues as $value) {
193		$this->size = max((int)$this->size, strlen($value));
194		}
195
196		return $this;
197		}
198
199		/**
200		* {@inheritdoc}
201		*/
202		public function sqlStatement(Driver $driver): string
203		{
204		$statement = parent::sqlStatement($driver);
205
206		if ($this->abstractType() != 'enum') {
207		//Nothing special
208		return $statement;
209		}
210
211		//We have add constraint for enum type
212		$enumValues = [];
213		foreach ($this->enumValues as $value) {
214		$enumValues[] = $driver->quote($value);
215		}
216
217		$constrain = $driver->identifier($this->enumConstraint());
218		$column = $driver->identifier($this->getName());
219		$values = implode(', ', $enumValues);
220
221		return "{$statement} CONSTRAINT {$constrain} CHECK ($column IN ({$values}))";
222		}
223
224		/**
225		* Generate set of operations need to change column.
226		*
227		* @param Driver $driver
228		* @param AbstractColumn $initial
229		*
230		* @return array
231		*/
232		public function alterOperations(Driver $driver, AbstractColumn $initial): array
233		{
234		$operations = [];
235
236		//To simplify comparation
237		$currentType = [$this->type, $this->size, $this->precision, $this->scale];
238		$initialType = [$initial->type, $initial->size, $initial->precision, $initial->scale];
239
240		$identifier = $driver->identifier($this->getName());
241
242		/*
243		* This block defines column type and all variations.
244		*/
245		if ($currentType != $initialType) {
246		if ($this->abstractType() == 'enum') {
247		//Getting longest value
248		$enumSize = $this->size;
249		foreach ($this->enumValues as $value) {
250		$enumSize = max($enumSize, strlen($value));
251		}
252
253		$type = "ALTER COLUMN {$identifier} TYPE character($enumSize)";
254		$operations[] = $type;
255		} else {
256		$type = "ALTER COLUMN {$identifier} TYPE {$this->type}";
257
258		if (!empty($this->size)) {
259		$type .= "($this->size)";
260		} elseif (!empty($this->precision)) {
261		$type .= "($this->precision, $this->scale)";
262		}
263
264		//Required to perform cross conversion
265		$operations[] = "{$type} USING {$identifier}::{$this->type}";
266		}
267		}
268
269		//Dropping enum constrain before any operation
270		if ($initial->abstractType() == 'enum' && $this->constrained) {
271		$operations[] = 'DROP CONSTRAINT ' . $driver->identifier($this->enumConstraint());
272		}
273
274		//Default value set and dropping
275		if ($initial->defaultValue != $this->defaultValue) {
276		if (is_null($this->defaultValue)) {
277		$operations[] = "ALTER COLUMN {$identifier} DROP DEFAULT";
278		} else {
279		$operations[] = "ALTER COLUMN {$identifier} SET DEFAULT {$this->quoteDefault($driver)}";
280		}
281		}
282
283		//Nullable option
284		if ($initial->nullable != $this->nullable) {
285		$operations[] = "ALTER COLUMN {$identifier} " . (!$this->nullable ? 'SET' : 'DROP') . ' NOT NULL';
286		}
287
288		if ($this->abstractType() == 'enum') {
289		$enumValues = [];
290		foreach ($this->enumValues as $value) {
291		$enumValues[] = $driver->quote($value);
292		}
293
294		$operations[] = "ADD CONSTRAINT {$driver->identifier($this->enumConstraint())} "
295		. "CHECK ({$identifier} IN (" . implode(', ', $enumValues) . '))';
296		}
297
298		return $operations;
299		}
300
301		/**
302		* {@inheritdoc}
303		*/
304		protected function quoteEnum(Driver $driver): string
305		{
306		//Postgres enums are just constrained strings
307		return '(' . $this->size . ')';
308		}
309
310		/**
311		* Get/generate name for enum constraint.
312		*
313		* @return string
314		*/
315	View Code Duplication	private function enumConstraint(): string
		0 ignored issues – show Duplication introduced 2016-12-14 14:22 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
316		{
317		if (empty($this->constrainName)) {
318		$this->constrainName = $this->table . '_' . $this->getName() . '_enum_' . uniqid();
319		}
320
321		return $this->constrainName;
322		}
323
324		/**
325		* Normalize default value.
326		*/
327		private function normalizeDefault()
328		{
329		if ($this->hasDefaultValue()) {
330		if (preg_match("/^'?(.*?)'?::(.+)/", $this->defaultValue, $matches)) {
331		//In database: 'value'::TYPE
332		$this->defaultValue = $matches[1];
333		} elseif ($this->type == 'bit') {
334		$this->defaultValue = bindec(
335		substr($this->defaultValue, 2, strpos($this->defaultValue, '::') - 3)
336		);
337		} elseif ($this->type == 'boolean') {
338		$this->defaultValue = (strtolower($this->defaultValue) == 'true');
339		}
340		}
341		}
342
343		/**
344		* @param string $table Table name.
345		* @param array $schema
346		* @param Driver $driver Postgres columns are bit more complex.
347		*
348		* @return PostgresColumn
349		*/
350		public static function createInstance(string $table, array $schema, Driver $driver): self
351		{
352		$column = new self($table, $schema['column_name'], $driver->getTimezone());
353
354		$column->type = $schema['data_type'];
355		$column->defaultValue = $schema['column_default'];
356		$column->nullable = $schema['is_nullable'] == 'YES';
357
358		if (
359		in_array($column->type, ['int', 'bigint', 'integer'])
360		&& preg_match('/nextval(.*)/', $column->defaultValue)
361		) {
362		$column->type = ($column->type == 'bigint' ? 'bigserial' : 'serial');
363		$column->autoIncrement = true;
364
365		$column->defaultValue = new Fragment($column->defaultValue);
366
367		return $column;
368		}
369
370		if (strpos($column->type, 'char') !== false && $schema['character_maximum_length']) {
371		$column->size = $schema['character_maximum_length'];
372		}
373
374	View Code Duplication	if ($column->type == 'numeric') {
		0 ignored issues – show Duplication introduced 2016-12-14 14:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
375		$column->precision = $schema['numeric_precision'];
376		$column->scale = $schema['numeric_scale'];
377		}
378
379		if ($column->type == 'USER-DEFINED' && $schema['typtype'] == 'e') {
380		$column->type = $schema['typname'];
381
382		/**
383		* Attention, this is not default spiral enum type emulated via CHECK. This is real
384		* Postgres enum type.
385		*/
386		self::resolveEnum($driver, $column);
387		}
388
389		if (strpos($column->type, 'char') !== false && !empty($column->size)) {
390		//Potential enum with manually created constraint (check in)
391		self::resolveConstrains($driver, $schema['tableOID'], $column);
392		}
393
394		$column->normalizeDefault();
395
396		return $column;
397		}
398
399		/**
400		* Resolving enum constrain and converting it into proper enum values set.
401		*
402		* @param Driver $driver
403		* @param string\|int $tableOID
404		* @param PostgresColumn $column
405		*/
406		private static function resolveConstrains(Driver $driver, $tableOID, PostgresColumn $column)
407		{
408		$query = "SELECT conname, consrc FROM pg_constraint WHERE conrelid = ? AND contype = 'c' AND (consrc LIKE ? OR consrc LIKE ?)";
409
410		$constraints = $driver->query($query, [
411		$tableOID,
412		'(' . $column->name . '%',
413		'("' . $column->name . '%'
414		]);
415
416		foreach ($constraints as $constraint) {
417		if (preg_match('/ARRAY\[([^\]]+)\]/', $constraint['consrc'], $matches)) {
418		$enumValues = explode(',', $matches[1]);
419	View Code Duplication	foreach ($enumValues as &$value) {
		0 ignored issues – show Duplication introduced 2016-12-13 18:57 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
420		if (preg_match("/^'?(.*?)'?::(.+)/", trim($value), $matches)) {
421		//In database: 'value'::TYPE
422		$value = $matches[1];
423		}
424
425		unset($value);
426		}
427
428		$column->enumValues = $enumValues;
429		$column->constrainName = $constraint['conname'];
430		$column->constrained = true;
431		}
432		}
433		}
434
435		/**
436		* Resolve native ENUM type if presented.
437		*
438		* @param Driver $driver
439		* @param PostgresColumn $column
440		*/
441		private static function resolveEnum(Driver $driver, PostgresColumn $column)
442		{
443		$range = $driver->query('SELECT enum_range(NULL::' . $column->type . ')')->fetchColumn(0);
444
445		$column->enumValues = explode(',', substr($range, 1, -1));
446
447		if (!empty($column->defaultValue)) {
448		//In database: 'value'::enumType
449		$column->defaultValue = substr(
450		$column->defaultValue,
451		1,
452		strpos($column->defaultValue, $column->type) - 4
453		);
454		}
455		}
456
457		/**
458		* {@inheritdoc}
459		*/
460		public function compare(ColumnInterface $initial): bool
461		{
462		if (parent::compare($initial)) {
463		return true;
464		}
465
466		if (
467		in_array($this->abstractType(), ['primary', 'bigPrimary'])
468		&& $initial->getDefaultValue() != $this->getDefaultValue()
469		) {
470		//PG adds default values to primary keys
471		return true;
472		}
473
474		return false;
475		}
476		}
477

spiral / components

Branch — feature/pre-split (42159e)

PostgresColumn::compare() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like