JAQB\Statement\WhereStatement

Complexity

Total Complexity

18

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	3
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	isHaving()	0	4	1
C	addCondition()	0	27	7
A	getConditions()	0	4	1
A	buildClause()	0	9	4
A	build()	0	18	4

<?php

/**
 * @author Jared King <j@jaredtking.com>
 *
 * @link http://jaredtking.com
 *
 * @copyright 2015 Jared King
 * @license MIT
 */
namespace JAQB\Statement;

class WhereStatement extends Statement
{
    /**
     * @var bool
     */
    protected $having;

    /**
     * @var array
     */
    protected $conditions = [];

    /**
     * @param bool $having when true, statement becomes a having statement
     */
    public function __construct($having = false)
    {
        $this->having = $having;
    }

    /**
     * Tells whether this statement is a HAVING statement.
     *
     * @return bool true: is HAVING, false: is WHERE
     */
    public function isHaving()
    {
        return $this->having;
    }

    /**
     * Adds a condition to the statement.
     *
     * Accepts the following forms:
     * 1. Equality comparison:
     *      addCondition('username', 'john')
     * 2. Comparison with custom operator:
     *      addCondition('balance', 100, '>')
     * 3. SQL fragment:
     *      addCondition('name LIKE "%john%"')
     * 4. List of conditions to add:
     *      addCondition([['balance', 100, '>'], ['user_id', 5]])
     * 5. Map of equality comparisons:
     *      addCondition(['username' => 'john', 'user_id' => 5])
     * 6. List of SQL fragments:
     *      addCondition(['first_name LIKE "%john%"', 'last_name LIKE "%doe%"'])
     *
     * @param array|string $field
     * @param string|bool  $value    condition value (optional)
     * @param string       $operator operator (optional)
     *
     * @return self
     */
    public function addCondition($field, $value = false, $operator = '=')
    {
        if (is_array($field) && !$value) {
            foreach ($field as $key => $value) {
                if (is_array($value)) { // handles #4
                    call_user_func_array([$this, 'addCondition'], $value);
                } elseif (!is_numeric($key)) { // handles #5
                    $this->addCondition($key, $value);
                } else { // handles #6
                    $this->addCondition($value);
                }
            }
        } else {
            // handles #3
            $condition = [$field];

            // handles #1 and #2
            if (func_num_args() >= 2) {
                $condition[] = $operator;
                $condition[] = $value;
            }

            $this->conditions[] = $condition;
        }

        return $this;
    }

    /**
     * Gets the conditions for this statement.
     *
     * @return array
     */
    public function getConditions()
    {
        return $this->conditions;
    }

    protected function buildClause(array $clause)
    {
        // handle NULL values
        if (count($clause) === 3 && $clause[1] === '=' && $clause[2] === null) {
            return $this->escapeIdentifier($clause[0]).' IS NULL';
        }

        return parent::buildClause($clause);
    }

    /**
     * Generates the raw SQL string for the statement.
     *
     * @return string
     */
    public function build()
    {
        $sql = (!$this->having) ? 'WHERE ' : 'HAVING ';

        $clauses = [];
        foreach ($this->conditions as $clause) {
            $clauses[] = $this->buildClause($clause);
        }

        // remove empty values
        $clauses = array_filter($clauses);

        if (count($clauses) == 0) {
            return '';
        }

        return $sql.implode(' AND ', $clauses);
    }
}