DB::getLogger() - Code Metrics - Inspection of "Added Statement->__toString()" - hfw/db - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 331e8c...9d3685 )

by y
created 2019-02-21 08:27 UTC
DB::getLogger() 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	0
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\Junction;
use Helix\DB\Record;
use Helix\DB\Select;
use Helix\DB\SQL;
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 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.
     *
     * @param string $dsn
     * @param string $username
     * @param string $passwd
     * @param array $options
     */
    public function __construct ($dsn, $username = null, $passwd = null, $options = null) {
        parent::__construct(...func_get_args());
        parent::__construct(/** @scrutinizer ignore-type */ ...func_get_args());
        $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() { };
    }

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

    /**
     * `ATTR_DRIVER_NAME`
     *
     * @return string
     */
    final public function getDriver (): string {
        return $this->getAttribute(self::ATTR_DRIVER_NAME);
    }

    /**
     * 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 conditions from mixed arguments.
     *
     * When `$a` is an array:
     *
     * - Integer keys with string values are used as-is.
     * - String keys are used for `$a`, and values are used for `$b`
     *
     * In both cases, an enumerated array of strings is returned.
     *
     * When `$b` is a closure, it's invoked with `$a` and the `DB` instance.
     * The closure must return a string.
     *
     * Otherwise {@link SQL::isEqual()} is used, and `$b` is quoted.
     *
     * @see quote()
     * @see SQL::isEqual()
     *
     * @param string|array $a
     * @param string|array|Select|Closure $b
     * @return string|string[] Same type as `$a`, keys are not preserved.
     */
    public function match ($a, $b = null) {
        if (is_array($a)) {
            return array_map([$this, __FUNCTION__], array_keys($a), $a);
        }
        if (is_int($a) and is_string($b)) {

            return $b;
        }
        if ($b instanceof Closure) {
            return $b->__invoke($a, $this);
        }
        return SQL::isEqual($a, $this->quote($b));
    }

    /**
     * @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 Record|Junction|null
     */
    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 = null): Statement {
        $this->logger->__invoke($sql);
        /** @var Statement $statement */
        $statement = parent::prepare(...func_get_args());
        $statement = parent::prepare(/** @scrutinizer ignore-type */ ...func_get_args());
        return $statement;
    }

    /**
     * Notifies the logger.
     *
     * @param string $sql
     * @param int $mode
     * @param null $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 or an array of values recursively.
     * Array keys are preserved.
     *
     * - Booleans and resources are cast to integer.
     * - Integers are returned as-is.
     * - Everything else is quoted as a string.
     *
     * There are two cases where values are not quoted in order to allow
     * safe pass-through to the SQL helper functions:
     *
     * - {@link Column} is returned as its string representation (the qualified name).
     * - {@link Select} is returned back so it may be used as an anonymous subquery.
     *
     * @param mixed $value
     * @param int $type Ignored.
     * @return mixed
     */
    public function quote ($value, $type = null) {
        if ($value instanceof Column) {
            return (string)$value;
        }
        if ($value instanceof Select) {
            return $value;
        }
        switch (gettype($value)) {
            case 'array' :
                return array_map([$this, __FUNCTION__], $value);
            case 'integer' :
            case 'boolean' :
            case 'resource' :
                return (int)$value;
            default:
                return parent::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 ( 331e8c...9d3685 )

DB::getLogger() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
