conditiontree.php

<?php
namespace Bitrix\Main\ORM\Query\Filter;
 
use Bitrix\Main\ORM\Fields\BooleanField;
use Bitrix\Main\ORM\Fields\ExpressionField;
use Bitrix\Main\ORM\Query\Filter\Expressions\ColumnExpression;
use Bitrix\Main\ORM\Query\Query;
use Bitrix\Main\ORM\Query\Chain;
use Bitrix\Main\ORM\Fields\IReadable;
use Bitrix\Main\DB\SqlExpression;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\SystemException;
use Bitrix\Main\Type\RandomSequence;
 
class ConditionTree
{
    protected $chains;
 
    protected $conditions = array();
 
    protected $logic;
 
    protected static RandomSequence $randomSequence;
 
    const LOGIC_OR = 'or';
 
    const LOGIC_AND = 'and';
 
    protected $isNegative = false;
 
    public function __construct()
    {
        $this->logic = static::LOGIC_AND;
    }
 
    public function logic($logic = null)
    {
        if ($logic === null)
        {
            return $this->logic;
        }
 
        if (!in_array(strtolower($logic), [static::LOGIC_AND, static::LOGIC_OR], true))
        {
            throw new ArgumentException("Unknown logic");
        }
 
        $this->logic = strtolower($logic);
 
        return $this;
    }
 
    public function negative($negative = true)
    {
        $this->isNegative = (bool) $negative;
        return $this;
    }
 
    public function where(...$filter)
    {
        // subfilter
        if (count($filter) == 1 && $filter[0] instanceof ConditionTree)
        {
            $this->conditions[] = $filter[0];
            return $this;
        }
 
        // ready condition
        if (count($filter) == 1 && $filter[0] instanceof Condition)
        {
            $this->conditions[] = $filter[0];
            return $this;
        }
 
        // array of conditions
        if (count($filter) == 1 && is_array($filter[0]))
        {
            foreach ($filter[0] as $condition)
            {
                // call `where` for each condition
                call_user_func_array(array($this, 'where'), $condition);
            }
            return $this;
        }
 
        // regular conditions
        if (count($filter) == 3)
        {
            // everything is clear
            list($column, $operator, $value) = $filter;
        }
        elseif (count($filter) == 2)
        {
            // equal by default
            list($column, $value) = $filter;
            $operator = '=';
        }
        elseif (count($filter) == 1)
        {
            // suppose it is boolean field with true value
            $column = $filter[0];
            $operator = '=';
            $value = true;
        }
        else
        {
            throw new ArgumentException('Wrong arguments');
        }
 
        // validate operator
        $operators = Operator::get();
        if (!isset($operators[$operator]))
        {
            throw new ArgumentException("Unknown operator `{$operator}`");
        }
 
        // add condition
        $this->conditions[] = new Condition($column, $operator, $value);
 
        return $this;
    }
 
    public function whereNot(...$filter)
    {
        $subFilter = new static();
        call_user_func_array(array($subFilter, 'where'), $filter);
 
        $this->conditions[] = $subFilter->negative();
        return $this;
    }
 
    public function whereColumn(...$filter)
    {
        if (count($filter) == 3)
        {
            list($column, $operator, $value) = $filter;
        }
        elseif (count($filter) == 2)
        {
            list($column, $value) = $filter;
            $operator = '=';
        }
        else
        {
            throw new ArgumentException('Wrong arguments');
        }
 
        // convert value to column format
        $value = new Expressions\ColumnExpression($value);
 
        // put through general method
        $this->where($column, $operator, $value);
 
        return $this;
    }
 
    public function whereNull($column)
    {
        $this->conditions[] = new Condition($column, '=', null);
 
        return $this;
    }
 
    public function whereNotNull($column)
    {
        $this->conditions[] = new Condition($column, '<>', null);
 
        return $this;
    }
 
    public function whereIn($column, $values)
    {
        if (!empty($values))
        {
            $this->conditions[] = new Condition($column, 'in', $values);
        }
 
        return $this;
    }
 
    public function whereNotIn($column, $values)
    {
        $subFilter = new static();
        $this->conditions[] = $subFilter->whereIn($column, $values)->negative();
 
        return $this;
    }
 
    public function whereBetween($column, $valueMin, $valueMax)
    {
        $this->conditions[] = new Condition($column, 'between', array($valueMin, $valueMax));
 
        return $this;
    }
 
    public function whereNotBetween($column, $valueMin, $valueMax)
    {
        $subFilter = new static();
        $this->conditions[] = $subFilter->whereBetween($column, $valueMin, $valueMax)->negative();
 
        return $this;
    }
 
    public function whereLike($column, $value)
    {
        $this->conditions[] = new Condition($column, 'like', $value);
 
        return $this;
    }
 
    public function whereNotLike($column, $value)
    {
        $subFilter = new static();
        $this->conditions[] = $subFilter->whereLike($column, $value)->negative();
 
        return $this;
    }
 
    public function whereExists($query)
    {
        $this->conditions[] = new Condition(null, 'exists', $query);
 
        return $this;
    }
 
    public function whereNotExists($query)
    {
        if ($query instanceof Query || $query instanceof SqlExpression)
        {
            $subFilter = new static();
            $this->conditions[] = $subFilter->whereExists($query)->negative();
 
            return $this;
        }
 
        throw new ArgumentException('Unknown type of query '.gettype($query));
    }
 
    public function whereMatch($column, $value)
    {
        $this->conditions[] = new Condition($column, 'match', $value);
 
        return $this;
    }
 
    public function whereNotMatch($column, $value)
    {
        $subFilter = new static();
        $this->conditions[] = $subFilter->whereMatch($column, $value)->negative();
 
        return $this;
    }
 
    public function whereExpr($expr, $arguments)
    {
        // get random field name
        $randomSequence = static::getRandomSequence();
        $tmpName = 'TMP_'.$randomSequence->randString(10);
 
        // set boolean expression
        $tmpField = (new ExpressionField($tmpName, $expr, $arguments))
            ->configureValueType(BooleanField::class);
 
        // add condition
        $this->where($tmpField, 'expr', true);
 
        return $this;
    }
 
    public function getSql($chains)
    {
        // save chains
        $this->chains = $chains;
 
        $finalSql = array();
 
        // build sql
        foreach ($this->conditions as $condition)
        {
            if ($condition instanceof ConditionTree)
            {
                // subfilter
                $subFilter = $condition;
                $sql = $subFilter->getSql($chains);
 
                if (count($subFilter->getConditions()) > 1)
                {
                    $sql = "({$sql})";
                }
            }
            else
            {
                // regular condition
                $columnSqlDefinition = null;
                $columnField = null;
 
                // define column field
                if ($condition->getColumn() !== null)
                {
                    $chain = $chains[$condition->getDefinition()];
                    $columnSqlDefinition = $chain->getSqlDefinition();
 
                    $columnField = $chain->getLastElement()->getValue();
                }
 
                // final value's sql
                if (in_array($condition->getOperator(), array('in', 'between'), true) && is_array($condition->getValue()))
                {
                    // value is in array of atomic values
                    $finalValue = $this->convertValues($condition->getValue(), $columnField);
                }
                else
                {
                    $finalValue = $this->convertValue($condition->getValue(), $columnField);
                }
 
                // operation method
                $operators = Operator::get();
                $operator = $operators[$condition->getOperator()];
 
                // final sql
                $sql = call_user_func(
                    array('Bitrix\Main\ORM\Query\Filter\Operator', $operator),
                    $columnSqlDefinition, $finalValue
                );
            }
 
            if ($sql != '')
            {
                $finalSql[] = $sql;
            }
        }
 
        $sql = null;
 
        if (!empty($finalSql))
        {
            // concat with $this->logic
            $sql = join(" ".strtoupper($this->logic)." ", $finalSql);
 
            // and put NOT if negative
            if ($this->isNegative)
            {
                $sql = count($finalSql) > 1 ? "NOT ({$sql})" : "NOT {$sql}";
            }
        }
 
        return $sql;
    }
 
    public function getConditions()
    {
        return $this->conditions;
    }
 
    public function addCondition($condition)
    {
        if ($condition instanceof Condition || $condition instanceof ConditionTree)
        {
            $this->conditions[] = $condition;
            return $this;
        }
 
        throw new ArgumentException('Unknown type of condition '.gettype($condition));
    }
 
    public function hasConditions()
    {
        return !empty($this->conditions);
    }
 
    public function replaceCondition($currentCondition, $newCondition)
    {
        foreach ($this->conditions as $k => $condition)
        {
            if ($condition === $currentCondition)
            {
                $this->conditions[$k] = $newCondition;
                return true;
            }
        }
 
        return false;
    }
 
    public function removeCondition($condition)
    {
        foreach ($this->conditions as $k => $_condition)
        {
            if ($condition == $_condition)
            {
                unset($this->conditions[$k]);
                return true;
            }
        }
 
        return false;
    }
 
    public function removeAllConditions()
    {
        $this->conditions = [];
    }
 
    protected function convertValue($value, IReadable $field = null)
    {
        // any sql expression
        if ($value instanceof SqlExpression)
        {
            return $value->compile();
        }
 
        // subquery
        if ($value instanceof Query)
        {
            return $value->getQuery();
        }
 
        // subfilter
        if ($value instanceof ConditionTree)
        {
            return $value->getSql($this->chains);
        }
 
        // nulls
        if ($value === null)
        {
            return new Expressions\NullExpression;
        }
 
        if ($value instanceof Expressions\ColumnExpression)
        {
            $valueChain = $this->chains[$value->getDefinition()];
            return $valueChain->getSqlDefinition();
        }
 
        return $field->convertValueToDb($value); // give them current sql helper
    }
 
    protected function convertValues($values, IReadable $field = null)
    {
        foreach ($values as $k => $value)
        {
            $values[$k] = $this->convertValue($value, $field);
        }
 
        return $values;
    }
 
    public function __clone()
    {
        $newConditions = array();
 
        foreach ($this->conditions as $condition)
        {
            $newConditions[] = clone $condition;
        }
 
        $this->conditions = $newConditions;
    }
 
    protected static function getRandomSequence(): RandomSequence
    {
        if (!isset(static::$randomSequence))
        {
            static::$randomSequence = new RandomSequence('orm.filter.expr');
        }
 
        return static::$randomSequence;
    }
 
    public static function createFromArray($filter)
    {
        $conditionTree = Query::filter();
 
        if (isset($filter['logic']))
        {
            $conditionTree->logic($filter['logic']);
            unset($filter['logic']);
        }
 
        if (isset($filter['negative']))
        {
            $conditionTree->negative($filter['negative']);
            unset($filter['negative']);
        }
 
        foreach ($filter as $condition)
        {
            if (isset($condition[0]) && is_array($condition[0]))
            {
                $conditionTree->where(static::createFromArray($condition));
            }
            else
            {
                // parse regular filter condition
                $valueKey = key(array_reverse($condition, true));
                $valueElement = $condition[$valueKey];
 
                if (is_array($valueElement))
                {
                    if (isset($valueElement['value']))
                    {
                        $value = $valueElement['value'];
                    }
                    elseif (isset($valueElement['column']))
                    {
                        $value = new ColumnExpression($valueElement['column']);
                    }
                    else
                    {
                        // could be an array of columns
                        foreach ($valueElement as $k => $singleValue)
                        {
                            if (is_array($singleValue))
                            {
                                if (isset($singleValue['value']))
                                {
                                    $valueElement[$k] = $singleValue['value'];
                                }
                                elseif (isset($singleValue['column']))
                                {
                                    $valueElement[$k] = new ColumnExpression($singleValue['column']);
                                }
                            }
                        }
 
                        $value = $valueElement;
                    }
 
                    $condition[$valueKey] = $value;
                }
 
                $conditionTree->where(...$condition);
            }
        }
 
        return $conditionTree;
    }
}