Yiisoft\Db\Pgsql\ColumnSchema

Complexity

Total Complexity

35

Size/Duplication

Total Lines	250
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	phpTypecastValue()	0	17	4
A	getDimension()	0	3	1
A	getArrayParser()	0	3	1
A	getCompositeParser()	0	3	1
A	phpTypecast()	0	20	4
A	getColumns()	0	3	1
A	sequenceName()	0	3	1
A	columns()	0	3	1
A	dbTypecast()	0	15	5
A	dimension()	0	3	1
A	getSequenceName()	0	3	1
A	dbTypecastValue()	0	20	5
A	dbTypecastArray()	0	19	4
A	phpTypecastComposite()	0	31	5

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Pgsql;

use JsonException;
use PDO;
use Yiisoft\Db\Command\Param;
use Yiisoft\Db\Expression\ArrayExpression;
use Yiisoft\Db\Expression\ExpressionInterface;
use Yiisoft\Db\Expression\JsonExpression;
use Yiisoft\Db\Pgsql\Composite\CompositeExpression;
use Yiisoft\Db\Pgsql\Composite\CompositeParser;
use Yiisoft\Db\Schema\AbstractColumnSchema;
use Yiisoft\Db\Schema\ColumnSchemaInterface;
use Yiisoft\Db\Schema\SchemaInterface;

use function array_walk_recursive;
use function bindec;
use function decbin;
use function is_array;
use function is_int;
use function is_string;
use function json_decode;
use function str_pad;

/**
 * Represents the metadata of a column in a database table for PostgreSQL Server.
 *
 * It provides information about the column's name, type, size, precision, and other details.
 *
 * It's used to store and retrieve metadata about a column in a database table and is typically used in conjunction with
 * the {@see TableSchema}, which represents the metadata of a database table as a whole.
 *
 * The following code shows how to use:
 *
 * ```php
 * use Yiisoft\Db\Pgsql\ColumnSchema;
 *
 * $column = new ColumnSchema();
 * $column->name('id');
 * $column->allowNull(false);
 * $column->dbType('integer');
 * $column->phpType('integer');
 * $column->type('integer');
 * $column->defaultValue(0);
 * $column->autoIncrement(true);
 * $column->primaryKey(true);
 * ```
 */
final class ColumnSchema extends AbstractColumnSchema
{
    /**
     * @var int The dimension of array. Defaults to 0, means this column isn't an array.
     */
    private int $dimension = 0;

    /**
     * @var string|null Name of an associated sequence if column is auto incremental.
     */
    private string|null $sequenceName = null;

    /**
     * @var ColumnSchemaInterface[]|null Columns metadata of the composite type.
     * @psalm-var array<string, ColumnSchemaInterface>|null
     */
    private array|null $columns = null;

    /**
     * Converts the input value according to {@see type} and {@see dbType} for use in a db query.
     *
     * If the value is null or an {@see Expression}, it won't be converted.
     *
     * @param mixed $value input value
     *
     * @return mixed Converted value. This may also be an array containing the value as the first element and the PDO
     * type as the second element.
     */
    public function dbTypecast(mixed $value): mixed
    {
        if ($this->dimension > 0) {
            if ($value === null || $value instanceof ExpressionInterface) {
                return $value;
            }

            if ($this->getType() === Schema::TYPE_COMPOSITE) {
                $value = $this->dbTypecastArray($value, $this->dimension);
            }

            return new ArrayExpression($value, $this->getDbType(), $this->dimension);
        }

        return $this->dbTypecastValue($value);
    }

    /**
     * @param int $dimension Should be more than 0
     */
    private function dbTypecastArray(mixed $value, int $dimension): array
    {
        $items = [];

        if (!is_iterable($value)) {
            return $items;
        }

        /** @psalm-var mixed $val */
        foreach ($value as $val) {
            if ($dimension > 1) {
                $items[] = $this->dbTypecastArray($val, $dimension - 1);
            } else {
                /** @psalm-suppress MixedAssignment */
                $items[] = $this->dbTypecastValue($val);
            }
        }

        return $items;
    }

    private function dbTypecastValue(mixed $value): mixed
    {
        if ($value === null || $value instanceof ExpressionInterface) {
            return $value;
        }

        return match ($this->getType()) {
            SchemaInterface::TYPE_JSON => new JsonExpression($value, $this->getDbType()),

            SchemaInterface::TYPE_BINARY => is_string($value)
                ? new Param($value, PDO::PARAM_LOB) // explicitly setup PDO param type for binary column
                : $this->typecast($value),

            Schema::TYPE_BIT => is_int($value)
                ? str_pad(decbin($value), (int) $this->getSize(), '0', STR_PAD_LEFT)
                : $this->typecast($value),

            Schema::TYPE_COMPOSITE => new CompositeExpression($value, $this->getDbType(), $this->columns),

            default => $this->typecast($value),
        };
    }

    /**
     * Converts the input value according to {@see phpType} after retrieval from the database.
     *
     * If the value is null or an {@see Expression}, it won't be converted.
     *
     * @param mixed $value The input value
     *
     * @throws JsonException
     *
     * @return mixed The converted value
     */
    public function phpTypecast(mixed $value): mixed
    {
        if ($this->dimension > 0) {
            if (is_string($value)) {
                $value = $this->getArrayParser()->parse($value);
            }

            if (is_array($value)) {
                array_walk_recursive($value, function (string|null &$val) {
                    /** @psalm-var mixed $val */
                    $val = $this->phpTypecastValue($val);
                });
            } else {
                return null;
            }

            return $value;
        }

        return $this->phpTypecastValue($value);
    }

    /**
     * Casts $value after retrieving from the DBMS to PHP representation.
     *
     * @throws JsonException
     */
    protected function phpTypecastValue(mixed $value): mixed
    {
        if ($value === null) {
            return null;
        }

        return match ($this->getType()) {
            Schema::TYPE_BIT => is_string($value) ? bindec($value) : $value,

            SchemaInterface::TYPE_BOOLEAN => $value && $value !== 'f',

            SchemaInterface::TYPE_JSON
                => json_decode((string) $value, true, 512, JSON_THROW_ON_ERROR),

            Schema::TYPE_COMPOSITE => $this->phpTypecastComposite($value),

            default => parent::phpTypecast($value),
        };
    }

    private function phpTypecastComposite(mixed $value): array|null
    {
        if (is_string($value)) {
            $value = $this->getCompositeParser()->parse($value);
        }

        if (!is_iterable($value)) {
            return null;
        }

        $fields = [];
        $columns = (array) $this->columns;
        $columnNames = array_keys($columns);

        /**
         * @psalm-var int|string $columnName
         * @psalm-var mixed $item
         */
        foreach ($value as $columnName => $item) {
            $columnName = $columnNames[$columnName] ?? $columnName;

            if (isset($columns[$columnName])) {
                /** @psalm-var mixed $item */
                $item = $columns[$columnName]->phpTypecast($item);
            }

            /** @psalm-suppress MixedAssignment */
            $fields[$columnName] = $item;
        }

        return $fields;
    }

    /**
     * Creates instance of ArrayParser.
     */
    protected function getArrayParser(): ArrayParser
    {
        return new ArrayParser();
    }

    /**
     * @return int Get the dimension of the array.
     *
     * Defaults to 0, means this column isn't an array.
     */
    public function getDimension(): int
    {
        return $this->dimension;
    }

    /**
     * @return string|null name of an associated sequence if column is auto incremental.
     */
    public function getSequenceName(): string|null
    {
        return $this->sequenceName;
    }

    /**
     * Set dimension of an array.
     *
     * Defaults to 0, means this column isn't an array.
     */
    public function dimension(int $dimension): void
    {
        $this->dimension = $dimension;
    }

    /**
     * Set the name of an associated sequence if a column is auto incremental.
     */
    public function sequenceName(string|null $sequenceName): void
    {
        $this->sequenceName = $sequenceName;
    }

    /**
     * @param ColumnSchemaInterface[]|null $columns The columns metadata of the composite type.
     * @psalm-param array<string, ColumnSchemaInterface>|null $columns
     */
    public function columns(array|null $columns): void
    {
        $this->columns = $columns;
    }

    /**
     * @return ColumnSchemaInterface[]|null Columns metadata of the composite type.
     */
    public function getColumns(): array|null
    {
        return $this->columns;
    }

    /**
     * Creates instance of CompositeParser.
     */
    private function getCompositeParser(): CompositeParser
    {
        return new CompositeParser();
    }
}