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

Complexity

Conditions	21
Paths	52

Size

Total Lines	155
Code Lines	68

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	45
CRAP Score	21.034

Importance

Changes	4
Bugs	0	Features	0

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

        /** @var mixed */
        $tableName = $this->db->getQuoter()->quoteValue($tableName);

        if ($schemaName !== null) {
            /** @var mixed */
            $schemaName = $this->db->getQuoter()->quoteValue($schemaName);
        }

        if (version_compare($this->db->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;

        $columns = $this->db->createCommand($sql)->queryAll();

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

        /** @var array $column */
        foreach ($columns as $column) {
            $column = $this->normalizeRowKeyCase($column, false);

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

            /** @var mixed */
            $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;
    }