DB::matchArray() - Code Metrics - Inspection of "Class diagram" - hfw/db - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 9b561d...08d227 )

by y
created 2019-03-05 06:42 UTC
DB::matchArray() A

↳ Parent: Project
Complexity

Conditions	1
Paths	1
Size

Total Lines	2
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	2
rs	10
c	0
b	0
f	0
<?php

namespace Helix;

use ArrayAccess;
use Closure;
use Exception;
use Helix\DB\Column;
use Helix\DB\EntityInterface;
use Helix\DB\SQL\ExpressionInterface;
use Helix\DB\Junction;
use Helix\DB\Record;
use Helix\DB\SQL\Predicate;
use Helix\DB\Statement;
use PDO;

/**
 * Extends `PDO` and acts as a central access point for the schema.
 */
class DB extends PDO implements ArrayAccess {

    /**
     * @var string
     */
    private $driver;

    /**
     * @var Junction[]
     */
    protected $junctions = [];

    /**
     * Notified whenever a query is executed or a statement is prepared.
     * Takes only one argument: the SQL being executed or prepared.
     * This is a stub closure by default.
     *
     * @var Closure
     */
    protected $logger;

    /**
     * @var Record[]
     */
    protected $records = [];

    /**
     * Sets various attributes to streamline operations.
     *
     * Registers missing SQLite functions.
     *
     * @param string $dsn
     * @param string $username
     * @param string $passwd
     * @param array $options
     */
    public function __construct ($dsn, $username = null, $passwd = null, $options = null) {
        parent::__construct($dsn, $username, $passwd, $options);
        $this->driver = $this->getAttribute(self::ATTR_DRIVER_NAME);
        $this->setAttribute(self::ATTR_DEFAULT_FETCH_MODE, self::FETCH_ASSOC);
        $this->setAttribute(self::ATTR_EMULATE_PREPARES, false);
        $this->setAttribute(self::ATTR_ERRMODE, self::ERRMODE_EXCEPTION);
        $this->setAttribute(self::ATTR_STATEMENT_CLASS, [Statement::class, [$this]]);
        $this->setAttribute(self::ATTR_STRINGIFY_FETCHES, false);
        $this->logger = function() { };
        if ($this->driver === 'sqlite') {
            $this->sqliteCreateFunction('CEIL', 'ceil');
                   sqliteCreateFunction('CEIL', 'ceil');
            $this->sqliteCreateFunction('FLOOR', 'floor');
        }
    }

    /**
     * Notifies the logger.
     *
     * @param string $sql
     * @return int
     */
    public function exec ($sql): int {
        $this->logger->__invoke($sql);
        return parent::exec($sql);
    }

    /**
     * @return string
     */
    final public function getDriver (): string {
        return $this->driver;
    }

    /**
     * Returns a `Junction` access object based on an annotated interface.
     *
     * @param string $interface
     * @return Junction
     */
    public function getJunction ($interface): Junction {
        if (!isset($this->junctions[$interface])) {
            $this->junctions[$interface] = new Junction($this, $interface);
        }
        return $this->junctions[$interface];
    }

    /**
     * @return Closure
     */
    public function getLogger (): Closure {
        return $this->logger;
    }

    /**
     * Returns a `Record` access object based on an annotated class.
     *
     * @param string|EntityInterface $class
     * @return Record
     */
    public function getRecord ($class): Record {
        if (is_object($class)) {
            $class = get_class($class);
        }
        if (!isset($this->records[$class])) {
            $this->records[$class] = new Record($this, $class);
        }
        return $this->records[$class];
    }

    /**
     * Generates string conditions from mixed arguments.
     *
     * When `$b` is a closure, it's invoked with `(Column $a, DB $this)`.
     * The closure must return a string.
     *
     * If `$a` is an integer, `$b` is returned as a string.
     *
     * For all other types of `$b`, it's quoted and checked for equivalence with `$a`
     *
     * @param int|string $a
     * @param mixed $b
     * @return string
     */
    public function match ($a, $b) {
        if ($b instanceof Closure) {
            if (!$a instanceof Column) {

                $a = new Column($this, $a);
            }
            return (string)$b->__invoke($a, $this);
        }
        if (is_int($a)) {
            return (string)$b;
        }
        return (string)Predicate::compare($a, $this->quoteMixed($b));
    }

    /**
     * Generates an array of string conditions from an input array.
     *
     * - Integer keys with string values are returned as-is
     * - String keys are used for `$a`, and values are used for `$b`
     *
     * Keys are not preserved, an enumerated array of strings is returned.
     *
     * @see match()
     *
     * @param array $match
     * @return string[]
     */
    public function matchArray (array $match) {
        return array_map([$this, 'match'], array_keys($match), $match);
    }

    /**
     * @param string $access Class or interface name.
     * @return bool
     */
    public function offsetExists ($access): bool {
        return (bool)$this->offsetGet($access);
    }

    /**
     * @param string $access Class or interface name.
     * @return null|Record|Junction
     */
    public function offsetGet ($access) {
        if (class_exists($access)) {
            return $this->getRecord($access);
        }
        if (interface_exists($access)) {
            return $this->getJunction($access);
        }
        return null;
    }

    /**
     * Throws.
     *
     * @param void $access
     * @param void $value
     * @throws Exception
     */
    final public function offsetSet ($access, $value): void {
        throw new Exception('The schema is immutable.');
    }

    /**
     * Throws.
     *
     * @param void $access
     * @throws Exception
     */
    final public function offsetUnset ($access): void {
        $this->offsetSet($access, null);
    }

    /**
     * Notifies the logger.
     *
     * @param string $sql
     * @param array $options
     * @return Statement
     */
    public function prepare ($sql, $options = []): Statement {
        $this->logger->__invoke($sql);
        /** @var Statement $statement */
        $statement = parent::prepare($sql, $options);
        return $statement;
    }

    /**
     * Notifies the logger.
     *
     * @param string $sql
     * @param int $mode
     * @param mixed $arg3
     * @param array $ctorargs
     * @return Statement
     */
    public function query ($sql, $mode = PDO::ATTR_DEFAULT_FETCH_MODE, $arg3 = null, array $ctorargs = []): Statement {
        $this->logger->__invoke($sql);
        /** @var Statement $statement */
        $statement = parent::query(...func_get_args());
        $statement = parent::query(/** @scrutinizer ignore-type */ ...func_get_args());
        return $statement;
    }

    /**
     * Quotes a value, with special considerations.
     *
     * - {@link ExpressionInterface} instances are returned back as-is.
     * - Booleans and resources are returned as and unquoted integer string.
     * - Integers are returned as an unquoted string.
     * - Everything else is quoted as a string.
     *
     * @param mixed $value
     * @param int $type Ignored.
     * @return string
     */
    public function quote ($value, $type = null) {
        if ($value instanceof ExpressionInterface) {
            return $value;
        }
        switch (gettype($value)) {
            case 'integer' :
            case 'boolean' :
            case 'resource' :
                return (string)(int)$value;
            default:
                return parent::quote($value);
        }
    }

    /**
     * Quotes an array of values. Keys are preserved.
     *
     * @param array $values
     * @return array
     */
    public function quoteArray (array $values): array {
        return array_map([$this, 'quote'], $values);
    }

    /**
     * Accepts an array or string and returns it quoted.
     *
     * @param mixed $value
     * @return array|string
     */
    public function quoteMixed ($value) {
        if (is_array($value)) {
            return $this->quoteArray($value);
        }
        return $this->quote($value);
    }

    /**
     * Forwards to the entity's {@link Record}
     *
     * @param EntityInterface $entity
     * @return int ID
     */
    public function save (EntityInterface $entity): int {
        return $this->getRecord($entity)->save($entity);
    }

    /**
     * @param Closure $logger
     * @return $this
     */
    public function setLogger (Closure $logger) {
        $this->logger = $logger;
        return $this;
    }
}
hfw / db

Push — master ( 9b561d...08d227 )

DB::matchArray() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
