{@inheritdoc}

@param string $key The key name
@param mixed $operatorOrValue value if $value is null
@param mixed $value (optional)
@return self
430749
public function where($key, $operatorOrValue, $value=null)
    {

        if ($key == 'page_type' && $value === null) {
            return $this->pageType($operatorOrValue);
        }

        if ($this->isPageKey($key)) {
            $this->query->where($key, $operatorOrValue, $value);
            return $this;
        }

        if ($this->isConfigKey($key)) {
            return $this->addConfigWhere($key, $operatorOrValue, $value);
        }

        return $this;

    }
303604
protected function invalidOperatorAndValue($operator, $value)
    {
        return is_null($value) && array_key_exists($operator, $this->operators) &&
        ! array_key_exists($operator, ['=', '<>', '!=']);
    }
524543
public function where($key, $operator, $value)
    {
        if (string_has($operator, 'IN') || string_has($operator, 'in')) {
            return $this->whereIn($key, $value);
        }

        $this->where[] = 'AND '.$key.' '.$operator.' '.'?';
        $this->bindings[] = $value;

        return $this;
    }
554274
public function put($keyOrValue, $value = null, $keySource = null)
    {
        $key = $value === null ? null : $keyOrValue;
        $value = $value === null ? $keyOrValue : $value;

        $keySource = $keySource ?: $value;

        $key = $key ?: $this->key($keySource);
        $tags = $this->categorizer->tags($keySource);
        $lifetime = $this->categorizer->lifetime($keySource);

        $this->callBeforeListeners('put', [$this->storageName, $key, $value, $tags, $lifetime]);
        $this->storage->put($key, $value, $tags, $lifetime);
        $this->callAfterListeners('put', [$this->storageName, $key, $value, $tags, $lifetime]);

        return $this;
    }
485227
public function create($operator, $value)
    {
        $this->operator = $operator;
        $this->value    = $value;

        return $this;
    }
107150
public function where($key, $value = true, $operator = '=')
    {
        if ((isset($this->table) || isset($this->alias)) && is_string($key)
            && strpos($key, '.') === false && strpos($key, '`') === false && strpos($key, ' ') === false &&
            strpos($key, ',') === false && strpos($key, '(') === false
        ) {
            /**
             * Check if repository or extension holds key. :)
             */
            $aliasedTable = $this->alias ? $this->alias : $this->table;
            $hasField = $this->getRepository()->getCache()->tableHasField($this->table, $key);
            if (!$hasField) {
                $aliasedTable = $this->getRepository()->getCache()->getExtendeeTableForField($this->table, $key);
            }

            if ($aliasedTable) {
                $key = '`' . $aliasedTable . '`.`' . $key . '`';
            }
        }

        $this->getQuery()->where($key, $value, $operator);

        return $this;
    }
830785
public function orWhere($column, $operator = null, $value = null)
    {
        [$value, $operator] = $this->prepareValueAndOperator(
            $value, $operator, func_num_args() === 2
        );

        return $this->where($column, $operator, $value, 'or');
    }
553208
protected function applyOperation($value, $operator, $operand)
    {
        $processedValue = $value;

        switch ($operator) {
            case "div":
                if ($operand !== 0) {
                    $processedValue = $processedValue / $operand;
                }
                break;
            case "mul":
                $processedValue = $processedValue * $operand;
                break;
            case "add":
                $processedValue = $processedValue + $operand;
                break;
            case "sub":
                $processedValue = $processedValue - $operand;
                break;
            default:
                throw new UnknownOperatorException();
        }

        return $processedValue;
    }
320531
public function having($key, $operator, $value, $joiner = 'AND')
    {
        $key = $this->addTablePrefix($key);
        $this->statements['havings'][] = compact('key', 'operator', 'value', 'joiner');
        return $this;
    }
1151384
public function condition($field, $value = NULL, $operator = NULL)
    {
        $this->condition->condition($field, $value, $operator);
        return $this;
    }
109343
public function value($field, $operator, $value)
    {
        return $this->middleware($field, $this->get($field), $operator, $value);
    }
950525
public function config($key = null, $value = null, $override = false)
    {
        if (is_array($key) && is_bool($value)) {
            $override = $value;
        }

        return Util::operateArray($this->config, $key, $value, null, null, $override);
    }
1296114
public function every($key, $operator = null, $value = null)
    {
        if (func_num_args() === 1) {
            $callback = $this->valueRetriever($key);

            foreach ($this->items as $k => $v) {
                if (!$callback($v, $k)) {
                    return false;
                }
            }

            return true;
        }

        if (func_num_args() === 2) {
            $value = $operator;

            $operator = '=';
        }

        return $this->every($this->operatorForWhere($key, $operator, $value));
    }
718286
protected function operatorForWhere($key, $operator, $value)
    {
        return function ($obj) use ($key, $operator, $value) {
            $retrieved = $obj[$key];

            switch ($operator) {
                default:
                case '=':
                case '==':
                    return $retrieved == $value;
                case '!=':
                case '<>':
                    return $retrieved != $value;
                case '<':
                    return $retrieved < $value;
                case '>':
                    return $retrieved > $value;
                case '<=':
                    return $retrieved <= $value;
                case '>=':
                    return $retrieved >= $value;
                case '===':
                    return $retrieved === $value;
                case '!==':
                    return $retrieved !== $value;
            }
        };
    }
183554
public function where($column, $value, $operator = '=', $table = null)
    {
        $table = $table? $table : $this->table;
        $this->db()->where($column, $value, $operator, $table);
        return $this;
    }
853795
public function where($key, $operator = null, $value = null): IQueryBuilderHandler
    {
        // If two params are given then assume operator is =
        if (\func_num_args() === 2) {
            $value = $operator;
            $operator = '=';
        }

        if (\is_bool($value) === true) {
            $value = (int)$value;
        }

        return $this->whereHandler($key, $operator, $value);
    }
534068
public function where($field, $operator, $value = null)
    {
        if (func_num_args() === 2)
            $new = [$field, '=', $operator];
        else
            $new = func_get_args();

        $this->condition[0][] = $new;

        return $this;
    }