DB::setRecord() - Code Metrics - Inspection of "Added functionality in DB to rewire the runtime sc..." - hfw/db - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ff844e...3fca7d )

by y
created 2019-03-12 06:53 UTC
DB::setRecord() A

↳ Parent: Project
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

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

namespace Helix;

use ArrayAccess;
use Closure;
use Helix\DB\Column;
use Helix\DB\EntityInterface;
use Helix\DB\Junction;
use Helix\DB\Record;
use Helix\DB\SQL\ExpressionInterface;
use Helix\DB\SQL\Predicate;
use Helix\DB\Statement;
use InvalidArgumentException;
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');
            $this->sqliteCreateFunction('POW', 'pow');
        }
    }

    /**
     * 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) {
        if (!isset($this->junctions[$interface])) {
            $this->junctions[$interface] = Junction::fromInterface($this, $interface);
        }
        return $this->junctions[$interface];
    }

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

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

    /**
     * Generates string conditions from mixed arguments.
     *
     * When `$b` is a closure, this returns from that.
     * It's invoked with `(Column $a, DB $this)`
     *
     * 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 mixed $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 $class Class or interface name.
     * @return bool
     */
    public function offsetExists ($class): bool {
        return (bool)$this->offsetGet($class);
    }

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

    /**
     * @param string $class Class or interface name.
     * @param Record|Junction $access
     */
    public function offsetSet ($class, $access) {
        if ($access instanceof Record) {
            $this->setRecord($class, $access);
        }
        elseif ($access instanceof Junction) {

            $this->setJunction($class, $access);
        }
        throw new InvalidArgumentException('Expected a Record or Junction.');
    }

    /**
     * @param string $class Class or interface name.
     */
    public function offsetUnset ($class) {
        unset($this->records[$class]);
        unset($this->junctions[$class]);
    }

    /**
     * Notifies the logger.
     *
     * @param string $sql
     * @param array $options
     * @return Statement
     */
    public function prepare ($sql, $options = []) {
        $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 = []) {
        $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 as unquoted string.
     * - Booleans and resources are returned as unquoted integer string.
     * - Integers are returned as unquoted string.
     * - Everything else is returned as a quoted string.
     *
     * @param mixed $value
     * @param int $type Ignored.
     * @return string
     */
    public function quote ($value, $type = null) {
        if ($value instanceof ExpressionInterface) {
            return (string)$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 string[]
     */
    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 string|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 string $interface
     * @param Junction $junction
     * @return $this
     */
    public function setJunction (string $interface, Junction $junction) {
        $this->junctions[$interface] = $junction;
        return $this;
    }

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

    /**
     * @param string $class
     * @param Record $record
     * @return $this
     */
    public function setRecord (string $class, Record $record) {
        $this->records[$class] = $record;
        return $this;
    }
}
hfw / db

Push — master ( ff844e...3fca7d )

DB::setRecord() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
