DB::__construct() - Code Metrics - Inspection of "LICENSE.txt" - hfw/db - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6df7c9...74bc2a )

by y
created 2020-11-03 22:51 UTC
DB::__construct() A

↳ Parent: DB
Complexity

Conditions	2
Paths	2
Size

Total Lines	14
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	12
c	1
b	0
f	0
dl	0
loc	14
rs	9.8666
cc	2
nc	2
nop	4
<?php

namespace Helix;

use ArrayAccess;
use Closure;
use Helix\DB\EntityInterface;
use Helix\DB\Junction;
use Helix\DB\Record;
use Helix\DB\Select;
use Helix\DB\SQL\ExpressionInterface;
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 $password
     * @param array $options
     */
    public function __construct ($dsn, $username = null, $password = null, $options = null) {
        parent::__construct($dsn, $username, $password, $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');
            $this->sqliteCreateFunction('FLOOR', 'floor');
            $this->sqliteCreateFunction('POW', 'pow');
        }
    }

    /**
     * Returns the driver.
     *
     * @return string
     */
    final public function __toString () {
        return $this->driver;
    }

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

    /**
     * Generates an equality {@link Predicate} from mixed arguments.
     *
     * If `$b` is a closure, returns from `$b($a, DB $this)`
     *
     * If `$a` is an integer (enumerated item), returns `$b` as a {@link Predicate}
     *
     * If `$b` is an array, returns `$a IN (...quoted $b)`
     *
     * If `$b` is a {@link Select}, returns `$a IN ($b->toSql())`
     *
     * Otherwise predicates `$a = quoted $b`
     *
     * @param mixed $a
     * @param mixed $b
     * @return Predicate
     */
    public function match ($a, $b) {
        if ($b instanceof Closure) {
            return $b->__invoke($a, $this);
        }
        if (is_int($a)) {
            return new Predicate($b);
        }
        if (is_array($b)) {
            return new Predicate("{$a} IN ({$this->quoteList($b)})");
        }
        if ($b instanceof Select) {
            return new Predicate("{$a} IN ({$b->toSql()})");
        }
        return new Predicate("{$a} = {$this->quote($b)}");
    }

    /**
     * @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);
        }
        else {
            $this->setJunction($class, $access);
        }
    }

    /**
     * @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 and executes.
     *
     * @param string $sql
     * @param int $mode
     * @param mixed $arg3 Optional.
     * @param array $ctorargs Optional.
     * @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-is.
     * - Booleans and integers are returned as unquoted integer-string.
     * - Everything else is returned as a quoted string.
     *
     * @param bool|number|string|object $value
     * @param int $type Ignored.
     * @return string|ExpressionInterface
     */
    public function quote ($value, $type = self::PARAM_STR) {
        if ($value instanceof ExpressionInterface) {
            return $value;
        }
        switch (gettype($value)) {
            case 'integer' :
            case 'boolean' :
            case 'resource' :
                return (string)(int)$value;
            default:
                return parent::quote((string)$value);
        }
    }

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

    /**
     * Returns a quoted, comma-separated list.
     *
     * @param array $values
     * @return string
     */
    public function quoteList (array $values): string {
        return implode(',', $this->quoteArray($values));
    }

    /**
     * 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 ( 6df7c9...74bc2a )

DB::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
