Carno\Database\SQL\Builders\Where

Complexity

Total Complexity

30

Size/Duplication

Total Lines	205
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	genWSQL()	0	15	3
A	jWStack()	0	19	1
A	addWSta()	0	6	2
A	and()	0	3	1
A	jWStmt()	0	24	6
A	or()	0	3	1
B	where()	0	30	7
A	gWheres()	0	3	2
B	gWStmt()	0	24	7

<?php
/**
 * Where statements
 * User: moyo
 * Date: 22/12/2017
 * Time: 4:22 PM
 */

namespace Carno\Database\SQL\Builders;

use Carno\Database\SQL\Builder;
use Carno\Database\SQL\Exception\InvalidWhereStatementException;
use Closure;

trait Where
{
    /**
     * @var array
     */
    private $bWheres = [];

    /**
     * @var string
     */
    private $bWGrouped = null;

    /**
     * @var array
     */
    private $bWGroupSTA = [];

    /**
     * @var int
     */
    private $bWGDepth = 0;

    /**
     * @return string
     */
    protected function gWheres() : string
    {
        return ($sql = $this->gWStmt()) ? sprintf(' WHERE %s', $sql) : '';
    }

    /**
     * @return string
     */
    private function gWStmt() : string
    {
        $stmt = '';

        $stash = $this->bWGrouped[$this->bWGDepth] ?? null
            ? $this->bWGroupSTA[$this->bWGDepth]
            : $this->bWheres
        ;

        $pack = $cond = false;

        foreach ($stash as $part) {
            if (substr($part, 0, 1) === '#') {
                $pack = true;
                $stmt .= substr($part, 1);
            } else {
                $cond = true;
                $stmt .= $stmt ? sprintf(' AND %s', $part) : $part;
            }
        }

        ($pack && !$cond) && $stmt = sprintf('1%s', $stmt);

        return $stmt;
    }

    /**
     * @param array ...$conditions
     * @return Builder
     */
    public function where(...$conditions) : Builder
    {
        $expr = false;

        foreach ($conditions as $condition) {
            if (is_array($condition)) {
                // expr sta
                $expr = true;

                // where([expr], [expr])
                if (isset($condition[0])) {
                    $this->where(...$condition);
                    continue;
                }

                // where([k1 => v1, k2 => v2], [k3 => v3])
                foreach ($condition as $k => $v) {
                    $this->jWStmt($k, $v);
                }
            } elseif ($expr) {
                // -> where([expr])
                $this->jWStmt(...(is_array($condition) ? $condition : [$condition]));
            } else {
                // where(expr)
                $this->jWStmt(...$conditions);
                break;
            }
        }

        return $this;

The expression return $this returns the type Carno\Database\SQL\Builders\Where which includes types incompatible with the type-hinted return Carno\Database\SQL\Builder.

    }

    /**
     * @param mixed $current
     * @param mixed ...$extras
     */
    private function jWStmt($current, ...$extras) : void
    {
        if (is_string($current)) {
            switch (count($extras)) {
                case 0:
                    // where('sql')
                    $this->addWSta($current);
                    break;
                case 1:
                    // where('key', 'val')
                    $this->addWSta($this->genWSQL($current, '=', $extras[0]));
                    break;
                case 2:
                    // where('key', 'exp', 'val')
                    $this->addWSta($this->genWSQL($current, ...$extras));
                    break;
                default:
                    throw new InvalidWhereStatementException;
            }
        } elseif (is_integer($current)) {
            // where(123) primary key
            $this->addWSta($this->genWSQL('id', '=', $current));
        } else {
            throw new InvalidWhereStatementException;
        }
    }

    /**
     * Grouping "AND"
     * @param Closure $builder
     * @return Builder
     */
    public function and(Closure $builder) : Builder
    {
        return $this->jWStack($builder, 'AND');
    }

    /**
     * Grouping "OR"
     * @param Closure $builder
     * @return Builder
     */
    public function or(Closure $builder) : Builder
    {
        return $this->jWStack($builder, 'OR');
    }

    /**
     * @param Closure $builder
     * @param string $group
     * @return Builder
     */
    private function jWStack(Closure $builder, string $group) : Builder
    {
        $this->bWGDepth ++;

        $this->bWGrouped[$this->bWGDepth] = $group;
        $this->bWGroupSTA[$this->bWGDepth] = [];

        $builder($this);

        $stage = $this->gWStmt();

        unset($this->bWGrouped[$this->bWGDepth]);
        unset($this->bWGroupSTA[$this->bWGDepth]);

        $this->bWGDepth --;

        $this->addWSta(sprintf('# %s (%s)', $group, $stage));

        return $this;

The expression return $this returns the type Carno\Database\SQL\Builders\Where which includes types incompatible with the type-hinted return Carno\Database\SQL\Builder.

    }

    /**
     * @param string $sql
     */
    private function addWSta(string $sql) : void
    {
        if ($this->bWGrouped[$this->bWGDepth] ?? null) {
            $this->bWGroupSTA[$this->bWGDepth][] = $sql;
        } else {
            $this->bWheres[] = $sql;
        }
    }

    /**
     * @param string $key
     * @param string $expr
     * @param mixed $val
     * @return string
     */
    private function genWSQL(string $key, string $expr, $val) : string
    {
        $expr = strtoupper($expr);

        switch ($expr) {
            case 'IN':
                is_array($val) && $val = sprintf('(%s)', implode(',', array_map(function ($id) {
                    return (int) $id;
                }, $val)));
                break;
            default:
                $val = sprintf('?%d', $this->stash($val));

It seems like stash() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        return sprintf('`%s` %s %s', $key, $expr, $val);
    }
}