Column::max() - Code Metrics - Inspection of "Introduced ExpressionInterface to allow objects to..." - hfw/db - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 9d3685...1f10fe )

by y
created 2019-02-26 03:45 UTC
Column::max() 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\DB;

use Helix\DB;

/**
 * Immutable column access.
 *
 * Unlike {@link SQL}, the SQL generation functions here will quote arguments.
 *
 * @immutable
 * @see DB::quote()
 */
class Column extends AbstractAccess implements ExpressionInterface {

    /**
     * @var string
     */
    protected $name;

    /**
     * @var string
     */
    protected $qualifier;

    /**
     * @param DB $db
     * @param string $name
     * @param string $qualifier
     */
    public function __construct (DB $db, string $name, string $qualifier = '') {
        parent::__construct($db);
        $this->name = $name;
        $this->qualifier = $qualifier;
    }

    /**
     * Returns the qualified name.
     *
     * @return string
     */
    public function __toString (): string {
        if (strlen($this->qualifier)) {
            return "{$this->qualifier}.{$this->name}";
        }
        return $this->name;
    }

    /**
     * `AVG($this)`
     *
     * @return ExpressionInterface
     */
    public function avg (): ExpressionInterface {
        return SQL::avg($this);
    }

    /**
     * `COUNT($this)`
     *
     * @return ExpressionInterface
     */
    public function count (): ExpressionInterface {
        return SQL::count($this);
    }

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

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

    /**
     * Null-safe equality.
     *
     * - Mysql: `$this <=> $arg`, or `$this <=> ANY ($arg)`
     * - Sqlite: `$this IS $arg`, or `$this IS ANY ($arg)`
     *
     * @param null|bool|string|Select $arg
     * @return string
     */
    public function is ($arg): string {
        if ($arg === null or is_bool($arg)) {
            $arg = ['' => 'NULL', 1 => 'TRUE', 0 => 'FALSE'][$arg];
        }
        else {
            $arg = $this->db->quote($arg);
        }
        $operator = ['mysql' => '<=>', 'sqlite' => 'IS'][$this->db->getDriver()];
        return SQL::compare($this, $operator, $arg, 'ANY');
    }

    /**
     * `$this = $arg`, or `$this IN (...$arg)`, or `$this = ANY ($arg)`
     *
     * @param string|array|Select $arg
     * @return string
     */
    public function isEqual ($arg): string {
        return SQL::isEqual($this, $this->db->quote($arg));
    }

    /**
     * `$this > $arg`, or `$this > ALL ($arg)`
     *
     * @param string|Select $arg
     * @return string
     */
    public function isGreater ($arg): string {
        return SQL::isGreater($this, $this->db->quote($arg));
        return SQL::isGreater($this, /** @scrutinizer ignore-type */ $this->db->quote($arg));
    }

    /**
     * `$this >= $arg`, or `$this >= ALL ($arg)`
     *
     * @param string|Select $arg
     * @return string
     */
    public function isGreaterOrEqual ($arg): string {
        return SQL::isGreaterOrEqual($this, $this->db->quote($arg));
        return SQL::isGreaterOrEqual($this, /** @scrutinizer ignore-type */ $this->db->quote($arg));
    }

    /**
     * `$this < $arg`, or `$this < ALL ($arg)`
     *
     * @param string|Select $arg
     * @return string
     */
    public function isLess ($arg): string {
        return SQL::isLess($this, $this->db->quote($arg));
        return SQL::isLess($this, /** @scrutinizer ignore-type */ $this->db->quote($arg));
    }

    /**
     * `$this <= $arg`, or `$this <= ALL ($arg)`
     *
     * @param string|Select $arg
     * @return string
     */
    public function isLessOrEqual ($arg): string {
        return SQL::isLessOrEqual($this, $this->db->quote($arg));
        return SQL::isLessOrEqual($this, /** @scrutinizer ignore-type */ $this->db->quote($arg));
    }

    /**
     * `$this LIKE $pattern`
     *
     * @param string $pattern
     * @return string
     */
    public function isLike (string $pattern): string {
        return SQL::isLike($this, $this->db->quote($pattern));
        return SQL::isLike($this, /** @scrutinizer ignore-type */ $this->db->quote($pattern));
    }

    /**
     * Null-safe inequality.
     *
     * @see is()
     *
     * @param null|bool|string|Select $arg
     * @return string
     */
    public function isNot ($arg): string {
        return SQL::not($this->is($arg));
    }

    /**
     * `$this <> $arg`, or `$this NOT IN (...$arg)`, or `$this <> ALL ($arg)`
     *
     * @param string|array|Select $arg
     * @return string
     */
    public function isNotEqual ($arg): string {
        return SQL::isNotEqual($this, $this->db->quote($arg));
    }

    /**
     * `$this NOT LIKE $pattern`
     *
     * @param string $pattern
     * @return string
     */
    public function isNotLike (string $pattern): string {
        return SQL::isNotLike($this, $this->db->quote($pattern));
        return SQL::isNotLike($this, /** @scrutinizer ignore-type */ $this->db->quote($pattern));
    }

    /**
     * `$this IS NOT NULL`
     *
     * @return string
     */
    public function isNotNull (): string {
        return SQL::isNotNull($this);
    }

    /**
     * `$this NOT REGEXP $pattern`
     *
     * @param string $pattern
     * @return string
     */
    public function isNotRegExp (string $pattern): string {
        return SQL::isNotRegExp($this, $this->db->quote($pattern));
        return SQL::isNotRegExp($this, /** @scrutinizer ignore-type */ $this->db->quote($pattern));
    }

    /**
     * `$this REGEXP $pattern`
     *
     * @param string $pattern
     * @return string
     */
    public function isRegExp (string $pattern): string {
        return SQL::isRegExp($this, $this->db->quote($pattern));
        return SQL::isRegExp($this, /** @scrutinizer ignore-type */ $this->db->quote($pattern));
    }

    /**
     * `MAX($this)`
     *
     * @return ExpressionInterface
     */
    public function max (): ExpressionInterface {
        return SQL::max($this);
    }

    /**
     * `MIN($this)`
     *
     * @return ExpressionInterface
     */
    public function min (): ExpressionInterface {
        return SQL::min($this);
    }

    /**
     * @param string $name
     * @return $this
     */
    public function setName (string $name) {
        $clone = clone $this;
        $clone->name = $name;
        return $clone;
    }

    /**
     * @param string $qualifier
     * @return $this
     */
    public function setQualifier (string $qualifier) {
        $clone = clone $this;
        $clone->qualifier = $qualifier;
        return $clone;
    }
}
hfw / db

Push — master ( 9d3685...1f10fe )

Column::max() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
