alkemann\h2l\data\PDO

Complexity

Total Complexity

50

Size/Duplication

Total Lines	322
Duplicated Lines	0 %

Importance

Changes	9
Bugs	2	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	23	4
A	one()	0	15	4
A	query()	0	5	2
B	find()	0	32	6
A	update()	0	22	6
A	bindPaginationToStatement()	0	5	2
A	where()	0	21	4
A	boundDebugString()	0	16	5
A	limit()	0	3	2
A	order()	0	7	2
A	handler()	0	35	5
A	insert()	0	14	3
A	data()	0	9	1
A	delete()	0	18	4

<?php

namespace alkemann\h2l\data;

use alkemann\h2l\exceptions\ConnectionError;
use alkemann\h2l\interfaces\Source;
use alkemann\h2l\Log;
use PDO as _PDO;

/**
 * Class PDO
 *
 * @package alkemann\h2l\data
 */
class PDO implements Source
{
    /**
     * @var array
     */
    protected array $config = [];

    /**
     * @var null|_PDO
     */
    protected $db = null;

    /** @var string */
    private string $pdo_class = _PDO::class;

    /**
     * @param array $config
     * @param string $pdo_class
     */
    public function __construct(array $config = [], string $pdo_class = _PDO::class)
    {
        $this->pdo_class = $pdo_class;

        if (count($config) === 1 && array_key_exists('url', $config)) {
            $config = parse_url($config['url']);
            if (is_array($config)) {

The condition is_array($config) is always true.

                $config['db'] = ltrim($config['path'] ?? '', '/');
            } else {
                // @codeCoverageIgnoreStart
                // parse_url always returns an array
                $config = [];
                // @codeCoverageIgnoreEnd
            }
        }

        $defaults = [
            'host' => 'localhost',
            'db' => 'test',
            'user' => null,
            'pass' => null
        ];
        $this->config = $config + $defaults;
    }

    /**
     * @psalm-suppress MoreSpecificReturnType
     * @psalm-suppress PropertyTypeCoercion
     * @psalm-suppress LessSpecificReturnStatement
     * @return _PDO
     */
    private function handler(): object
    {
        if ($this->db) {
            return $this->db;
        }

        $scheme = $this->config['scheme'] ?? 'mysql';
        $host = $this->config['host'];
        $db = $this->config['db'];
        $user = $this->config['user'];
        $pass = $this->config['pass'] ?? '';
        $port = ($this->config['port'] ?? false) ? ";port={$this->config['port']}" : '';
        if (empty($this->config['query'])) {
            $modifiers = '';
        } else {
            $modifiers = ';' . str_replace('&', ';', $this->config['query']);
        }
        $opts = [
            _PDO::ATTR_EMULATE_PREPARES => false,
            _PDO::ATTR_ERRMODE => _PDO::ERRMODE_EXCEPTION,

            'useUnicode' => true,
            'characterEncoding' => 'UTF-8',
        ];
        $dsn = "{$scheme}:host={$host}{$port}{$modifiers};dbname={$db}";
        $class = $this->pdo_class;
        try {
            $this->db = new $class($dsn, $user, $pass, $opts);

            // @TODO use this?
            // $this->db->setAttribute( _PDO::ATTR_EMULATE_PREPARES, false);
        } catch (\PDOException $e) {
            throw new ConnectionError("Unable to connect to $host : $db with user $user");
        }
        return $this->db;
    }

    /**
     * @param mixed $query
     * @param array $params
     * @return array|false false on error
     */
    public function query($query, array $params = [])
    {
        Log::debug("PDO:QUERY [$query]");
        $result = $this->handler()->query($query);
        return $result ? $result->fetchAll(_PDO::FETCH_ASSOC) : false;
    }

    /**
     * @param string $table
     * @param array $conditions
     * @param array $options
     * @return null|array
     * @throws \Error on finding more than 1 match
     */
    public function one(string $table, array $conditions, array $options = []): ?array
    {
        $result = $this->find($table, $conditions, $options);
        if ($result instanceof \Traversable) {
            $result = iterator_to_array($result);
        }
        $hits = sizeof($result);
        if ($hits === 0) {
            return null;
        }
        if ($hits > 1) {
            throw new \Error("One request found more than 1 match!");
        }

        return $result[0];
    }

    /**
     * @param string $table
     * @param array $conditions
     * @param array $options
     * @return iterable
     */
    public function find(string $table, array $conditions, array $options = []): iterable
    {
        $where = $this->where($conditions);
        $limit = $this->limit($options);
        $order = $this->order($options);
        $query = "SELECT * FROM {$table} {$where}{$order}{$limit};";
        $params = $this->boundDebugString($conditions, $options);
        Log::debug("PDO:QUERY [$query][$params]");
        $dbh = $this->handler();
        $stmt = $dbh->prepare($query);
        foreach ($conditions as $key => $value) {
            if (is_array($value)) {
                $index = 0;
                foreach ($value as $v) {
                    $i = 1 + $index++;
                    $stmt->bindValue(":c_{$key}_{$i}", $v);
                }
            } else {
                $stmt->bindValue(":c_{$key}", $value);
            }
        }
        $this->bindPaginationToStatement($options, $stmt);
        $result = $stmt->execute();
        if ($result === false) {
            return new \EmptyIterator();
        }
        // @codeCoverageIgnoreStart
        if ($stmt instanceof \PDOStatement) {
            $stmt->setFetchMode(_PDO::FETCH_ASSOC);
        }
        // @codeCoverageIgnoreEnd
        return $stmt;
    }

    /**
     * @param array $conditions
     * @return string
     */
    private function where(array $conditions): string
    {
        if (empty($conditions)) {
            return "";
        }
        $fun = function($o, $v) use ($conditions) : string {
            if (is_array($conditions[$v])) {
                $qa = [];
                $index = 0;
                foreach ($conditions[$v] as $value) {
                    $i = 1 + $index++;
                    $qa[] = ":c_{$v}_{$i}";
                }
                $qs = join(', ', $qa);
                return "{$o} AND {$v} IN ( $qs )";
            } else {
                return "{$o} AND {$v} = :c_{$v}";
            }
        };
        $where = trim(array_reduce(array_keys($conditions), $fun, ""), ' AND ');
        return "WHERE {$where} ";
    }

    private function limit(array $options): string
    {
        return array_key_exists('limit', $options) ? "LIMIT :o_limit OFFSET :o_offset " : '';
    }

    private function order(array $options): string
    {
        if (array_key_exists('order', $options)) {
            // @TODO Add more protection?
            return "ORDER BY {$options['order']} ";
        }
        return '';
    }

    private function boundDebugString(array $conditions, array $options, array $data = []): string
    {
        $out = [];
        foreach ($conditions as $k => $v) {
            if (is_array($v)) {
                $v = join(',', $v);
            }
            $out[] = "c_{$k}:'{$v}'";
        }
        foreach ($data as $k => $v) {
            $out[] = "d_{$k}:{$v}";
        }
        foreach ($options as $k => $v) {
            $out[] = "o_{$k}:{$v}";
        }
        return join(", ", $out);
    }

    /**
     * @param array $options
     * @param \PDOStatement $stmt
     */
    private function bindPaginationToStatement(array $options, $stmt): void
    {
        if (array_key_exists('limit', $options)) {
            $stmt->bindValue(":o_offset", (int) ($options['offset'] ?? 0), _PDO::PARAM_INT);
            $stmt->bindValue(":o_limit", (int) $options['limit'], _PDO::PARAM_INT);
        }
    }

    /**
     * @param string $table
     * @param array $conditions
     * @param array $data
     * @param array $options
     * @return int
     */
    public function update(string $table, array $conditions, array $data, array $options = []): int
    {
        if (empty($conditions) || empty($data)) {
            return 0;
        }

        $datasql = $this->data($data);
        $where = $this->where($conditions);
        $query = "UPDATE {$table} SET {$datasql} {$where};";

        $params = $this->boundDebugString($conditions, $options, $data);
        Log::debug("PDO:QUERY [$query][$params]");
        $dbh = $this->handler();
        $stmt = $dbh->prepare($query);
        foreach ($data as $key => $value) {
            $stmt->bindValue(":d_{$key}", $value);
        }
        foreach ($conditions as $key => $value) {
            $stmt->bindValue(":c_{$key}", $value);
        }
        $result = $stmt->execute();
        return ($result === true) ? $stmt->rowCount() : 0;
    }

    private function data(array $data): string
    {
        /**
         * @param string $o
         * @param mixed $v
         * @return string
         */
        $f = static fn(string $o, $v): string => "{$o}, {$v} = :d_{$v}";
        return trim((string) array_reduce(array_keys($data), $f, ""), ", ");
    }

    /**
     * @param string $table
     * @param array $data
     * @param array $options
     * @return null|string
     */
    public function insert(string $table, array $data, array $options = []): ?string
    {
        $keys = implode(', ', array_keys($data));
        $data_phs = ':d_' . implode(', :d_', array_keys($data));
        $query = "INSERT INTO {$table} ({$keys}) VALUES ({$data_phs});";
        $params = $this->boundDebugString([], [], $data);
        Log::debug("PDO:QUERY [$query][$params]");
        $dbh = $this->handler();
        $stmt = $dbh->prepare($query);
        foreach ($data as $key => $value) {
            $stmt->bindValue(':d_' . $key, $value);
        }
        $result = $stmt->execute();
        return ($result === true) ? $dbh->lastInsertId() : null;
    }

    /**
     * @param string $table
     * @param array $conditions
     * @param array $options
     * @return int
     */
    public function delete(string $table, array $conditions, array $options = []): int
    {
        $where = $this->where($conditions);
        if (empty($where)) {
            return 0;
        }
        $limit = $this->limit($options);
        $query = "DELETE FROM {$table} {$where}{$limit};";
        $params = $this->boundDebugString($conditions, $options);
        Log::debug("PDO:QUERY [$query][$params]");
        $dbh = $this->handler();
        $stmt = $dbh->prepare($query);
        foreach ($conditions as $key => $value) {
            $stmt->bindValue(":c_{$key}", $value);
        }
        $this->bindPaginationToStatement($options, $stmt);
        $result = $stmt->execute();
        return ($result === true) ? $stmt->rowCount() : 0;
    }
}