Yiisoft\Db\Pgsql\Schema::findColumns()

Complexity

Conditions	23
Paths	96

Size

Total Lines	155
Code Lines	69

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	52
CRAP Score	23.0267

Importance

Changes	4
Bugs	0	Features	0

<?php
    protected function findColumns(TableSchema $table): bool
    {
        $tableName = $this->quoteValue($table->getName());
        $schemaName = $table->getSchemaName();
        $orIdentity = '';

        if ($schemaName !== null) {
            $schemaName = $this->quoteValue($schemaName);
        }

        if (version_compare($this->getDb()->getServerVersion(), '12.0', '>=')) {
            $orIdentity = 'OR a.attidentity != \'\'';
        }

        $sql = <<<SQL
            SELECT
                d.nspname AS table_schema,
                c.relname AS table_name,
                a.attname AS column_name,
                COALESCE(td.typname, tb.typname, t.typname) AS data_type,
                COALESCE(td.typtype, tb.typtype, t.typtype) AS type_type,
                a.attlen AS character_maximum_length,
                pg_catalog.col_description(c.oid, a.attnum) AS column_comment,
                a.atttypmod AS modifier,
                a.attnotnull = false AS is_nullable,
                CAST(pg_get_expr(ad.adbin, ad.adrelid) AS varchar) AS column_default,
                coalesce(pg_get_expr(ad.adbin, ad.adrelid) ~ 'nextval',false) {$orIdentity} AS is_autoinc,
                pg_get_serial_sequence(quote_ident(d.nspname) || '.' || quote_ident(c.relname), a.attname)
                    AS sequence_name,
                CASE WHEN COALESCE(td.typtype, tb.typtype, t.typtype) = 'e'::char
                    THEN array_to_string(
                        (
                            SELECT array_agg(enumlabel)
                            FROM pg_enum
                            WHERE enumtypid = COALESCE(td.oid, tb.oid, a.atttypid)
                            )::varchar[],
                        ',')
                    ELSE NULL
                END AS enum_values,
                CASE atttypid
                     WHEN 21 /*int2*/ THEN 16
                     WHEN 23 /*int4*/ THEN 32
                     WHEN 20 /*int8*/ THEN 64
                     WHEN 1700 /*numeric*/ THEN
                          CASE WHEN atttypmod = -1
                           THEN null
                           ELSE ((atttypmod - 4) >> 16) & 65535
                           END
                     WHEN 700 /*float4*/ THEN 24 /*FLT_MANT_DIG*/
                     WHEN 701 /*float8*/ THEN 53 /*DBL_MANT_DIG*/
                     ELSE null
                  END   AS numeric_precision,
                  CASE
                    WHEN atttypid IN (21, 23, 20) THEN 0
                    WHEN atttypid IN (1700) THEN
                    CASE
                        WHEN atttypmod = -1 THEN null
                        ELSE (atttypmod - 4) & 65535
                    END
                       ELSE null
                  END AS numeric_scale,
                CAST(
                         information_schema._pg_char_max_length(
                             information_schema._pg_truetypid(a, t),
                             information_schema._pg_truetypmod(a, t)
                             ) AS numeric
                ) AS size,
                a.attnum = any (ct.conkey) as is_pkey,
                COALESCE(NULLIF(a.attndims, 0), NULLIF(t.typndims, 0), (t.typcategory='A')::int) AS dimension
            FROM
                pg_class c
                LEFT JOIN pg_attribute a ON a.attrelid = c.oid
                LEFT JOIN pg_attrdef ad ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
                LEFT JOIN pg_type t ON a.atttypid = t.oid
                LEFT JOIN pg_type tb ON (a.attndims > 0 OR t.typcategory='A') AND t.typelem > 0 AND t.typelem = tb.oid
                                            OR t.typbasetype > 0 AND t.typbasetype = tb.oid
                LEFT JOIN pg_type td ON t.typndims > 0 AND t.typbasetype > 0 AND tb.typelem = td.oid
                LEFT JOIN pg_namespace d ON d.oid = c.relnamespace
                LEFT JOIN pg_constraint ct ON ct.conrelid = c.oid AND ct.contype = 'p'
            WHERE
                a.attnum > 0 AND t.typname != '' AND NOT a.attisdropped
                AND c.relname = {$tableName}
                AND d.nspname = {$schemaName}
            ORDER BY
                a.attnum;
            SQL;

        /** @var array columns */
        $columns = $this->getDb()->createCommand($sql)->queryAll();
        $slavePdo = $this->getDb()->getSlavePdo();

        if (empty($columns)) {
            return false;
        }

        /** @var array<array-key, mixed> $column */
        foreach ($columns as $column) {
            if ($slavePdo !== null && $slavePdo->getAttribute(PDO::ATTR_CASE) === PDO::CASE_UPPER) {
                $column = array_change_key_case($column, CASE_LOWER);
            }

            /** @psalm-var ColumnArray $column */
            $loadColumnSchema = $this->loadColumnSchema($column);
            $table->columns($loadColumnSchema->getName(), $loadColumnSchema);

            /** @var mixed $defaultValue */
            $defaultValue = $loadColumnSchema->getDefaultValue();

            if ($loadColumnSchema->isPrimaryKey()) {
                $table->primaryKey($loadColumnSchema->getName());

                if ($table->getSequenceName() === null) {
                    $table->sequenceName($loadColumnSchema->getSequenceName());
                }

                $loadColumnSchema->defaultValue(null);
            } elseif ($defaultValue) {
                if (
                    is_string($defaultValue) &&
                    in_array(
                        $loadColumnSchema->getType(),
                        [self::TYPE_TIMESTAMP, self::TYPE_DATE, self::TYPE_TIME],
                        true
                    ) &&
                    in_array(
                        strtoupper($defaultValue),
                        ['NOW()', 'CURRENT_TIMESTAMP', 'CURRENT_DATE', 'CURRENT_TIME'],
                        true
                    )
                ) {
                    $loadColumnSchema->defaultValue(new Expression($defaultValue));
                } elseif ($loadColumnSchema->getType() === 'boolean') {
                    $loadColumnSchema->defaultValue(($defaultValue  === 'true'));
                } elseif (is_string($defaultValue) && preg_match("/^B'(.*?)'::/", $defaultValue, $matches)) {
                    $loadColumnSchema->defaultValue(bindec($matches[1]));
                } elseif (is_string($defaultValue) && preg_match("/^'(\d+)'::\"bit\"$/", $defaultValue, $matches)) {
                    $loadColumnSchema->defaultValue(bindec($matches[1]));
                } elseif (is_string($defaultValue) && preg_match("/^'(.*?)'::/", $defaultValue, $matches)) {
                    $loadColumnSchema->defaultValue($loadColumnSchema->phpTypecast($matches[1]));
                } elseif (
                    is_string($defaultValue) &&
                    preg_match('/^(\()?(.*?)(?(1)\))(?:::.+)?$/', $defaultValue, $matches)
                ) {
                    if ($matches[2] === 'NULL') {
                        $loadColumnSchema->defaultValue(null);
                    } else {
                        $loadColumnSchema->defaultValue($loadColumnSchema->phpTypecast($matches[2]));
                    }
                } else {
                    $loadColumnSchema->defaultValue($loadColumnSchema->phpTypecast($defaultValue));
                }
            }
        }

        return true;
    }