Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Doctrine\DBAL\Driver\PgSQL;

use Doctrine\DBAL\Driver\FetchUtils;
use Doctrine\DBAL\Driver\PgSQL\Exception\UnexpectedValue;
use Doctrine\DBAL\Driver\Result as ResultInterface;
use PgSql\Result as PgSqlResult;
use TypeError;

use function array_keys;
use function array_map;
use function assert;
use function get_class;
use function gettype;
use function hex2bin;
use function is_object;
use function is_resource;
use function pg_affected_rows;
use function pg_fetch_all;
use function pg_fetch_all_columns;
use function pg_fetch_assoc;
use function pg_fetch_row;
use function pg_field_name;
use function pg_field_type;
use function pg_free_result;
use function pg_num_fields;
use function sprintf;
use function substr;

use const PGSQL_ASSOC;
use const PGSQL_NUM;
use const PHP_INT_SIZE;

final class Result implements ResultInterface
{
    /** @var PgSqlResult|resource|null */
    private $result;

    /** @param PgSqlResult|resource $result */
    public function __construct($result)
    {
        if (! is_resource($result) && ! $result instanceof PgSqlResult) {
            throw new TypeError(sprintf(
                'Expected result to be a resource or an instance of %s, got %s.',
                PgSqlResult::class,
                is_object($result) ? get_class($result) : gettype($result),
            ));
        }

        $this->result = $result;
    }

    public function __destruct()
    {
        if (! isset($this->result)) {
            return;
        }

        $this->free();
    }

    /** {@inheritdoc} */
    public function fetchNumeric()
    {
        if ($this->result === null) {
            return false;
        }

        $row = pg_fetch_row($this->result);
        if ($row === false) {
            return false;
        }

        return $this->mapNumericRow($row, $this->fetchNumericColumnTypes());
    }

    /** {@inheritdoc} */
    public function fetchAssociative()
    {
        if ($this->result === null) {
            return false;
        }

        $row = pg_fetch_assoc($this->result);
        if ($row === false) {
            return false;
        }

        return $this->mapAssociativeRow($row, $this->fetchAssociativeColumnTypes());
    }

    /** {@inheritdoc} */
    public function fetchOne()
    {
        return FetchUtils::fetchOne($this);
    }

    /** {@inheritdoc} */
    public function fetchAllNumeric(): array
    {
        if ($this->result === null) {
            return [];
        }

        $resultSet = pg_fetch_all($this->result, PGSQL_NUM);
        // On PHP 7.4, pg_fetch_all() might return false for empty result sets.
        if ($resultSet === false) {
            return [];
        }

        $types = $this->fetchNumericColumnTypes();

        return array_map(
            fn (array $row) => $this->mapNumericRow($row, $types),
            $resultSet,
        );
    }

    /** {@inheritdoc} */
    public function fetchAllAssociative(): array
    {
        if ($this->result === null) {
            return [];
        }

        $resultSet = pg_fetch_all($this->result, PGSQL_ASSOC);
        // On PHP 7.4, pg_fetch_all() might return false for empty result sets.
        if ($resultSet === false) {
            return [];
        }

        $types = $this->fetchAssociativeColumnTypes();

        return array_map(
            fn (array $row) => $this->mapAssociativeRow($row, $types),
            $resultSet,
        );
    }

    /** {@inheritdoc} */
    public function fetchFirstColumn(): array
    {
        if ($this->result === null) {
            return [];
        }

        $postgresType = pg_field_type($this->result, 0);

        return array_map(
            fn ($value) => $this->mapType($postgresType, $value),
            pg_fetch_all_columns($this->result),
        );
    }

    public function rowCount(): int
    {
        if ($this->result === null) {
            return 0;
        }

        return pg_affected_rows($this->result);
    }

    public function columnCount(): int
    {
        if ($this->result === null) {
            return 0;
        }

        return pg_num_fields($this->result);
    }

    public function free(): void
    {
        if ($this->result === null) {
            return;
        }

        pg_free_result($this->result);
        $this->result = null;
    }

    /** @return array<int, string> */
    private function fetchNumericColumnTypes(): array
    {
        assert($this->result !== null);

        $types     = [];
        $numFields = pg_num_fields($this->result);
        for ($i = 0; $i < $numFields; ++$i) {
            $types[$i] = pg_field_type($this->result, $i);
        }

        return $types;
    }

    /** @return array<string, string> */
    private function fetchAssociativeColumnTypes(): array
    {
        assert($this->result !== null);

        $types     = [];
        $numFields = pg_num_fields($this->result);
        for ($i = 0; $i < $numFields; ++$i) {
            $types[pg_field_name($this->result, $i)] = pg_field_type($this->result, $i);
        }

        return $types;
    }

    /**
     * @param list<string|null>  $row
     * @param array<int, string> $types
     *
     * @return list<mixed>
     */
    private function mapNumericRow(array $row, array $types): array
    {
        assert($this->result !== null);

        return array_map(
            fn ($value, $field) => $this->mapType($types[$field], $value),
            $row,
            array_keys($row),
        );
    }

    /**
     * @param array<string, string|null> $row
     * @param array<string, string>      $types
     *
     * @return array<string, mixed>
     */
    private function mapAssociativeRow(array $row, array $types): array
    {
        assert($this->result !== null);

        $mappedRow = [];
        foreach ($row as $field => $value) {
            $mappedRow[$field] = $this->mapType($types[$field], $value);
        }

        return $mappedRow;
    }

    /** @return string|int|float|bool|null */
    private function mapType(string $postgresType, ?string $value)
    {
        if ($value === null) {
            return null;
        }

        switch ($postgresType) {
            case 'bool':
                switch ($value) {
                    case 't':
                        return true;
                    case 'f':
                        return false;
                }

                throw UnexpectedValue::new($value, $postgresType);

            case 'bytea':
                return hex2bin(substr($value, 2));

            case 'float4':
            case 'float8':
                return (float) $value;

            case 'int2':
            case 'int4':
                return (int) $value;

            case 'int8':
                return PHP_INT_SIZE >= 8 ? (int) $value : $value;
        }

        return $value;
    }
}