Will modify or create a having predicate using the XOR conjunction.

@param string $field
@param string $op
@param mixed $value
@return $this
493537
public function xorHaving($field, $op = null, $value = null) {
        return $this->_modifyPredicate($this->_having, Predicate::MAYBE, $field, $op, $value);
    }
786082
public function orWhereInfix($field, $operator = '=', $condition = false)
    {
        $numArgs = func_num_args();
        if ($numArgs > 2) {
            $this->where->addOrCondition($field, $condition, $operator);
        } elseif ($numArgs == 2) {
            $this->where->addOrCondition($field, $operator, '=');
        } else {
            $this->where->addOrCondition($field);
        }

        return $this;
    }
82180
public function whereInset($field, $value)
    {
        $key = strtr($field, '.', '_');
        $this->_conditions[] = 'FIND_IN_SET(:' . $key . ', ' . '[' . str_replace('.', '].[', $field) . '])>0';
        $this->_bind[$key] = $value;

        return $this;
    }
778298
public function where($field, $op, $value)
    {
        $this->pending['where'][] = array(
            'type'  => 'and',
            'field' => $field,
            'op'    => $op,
            'value' => $value,
        );

        return $this;
    }
902478
public function or_where($column, $op = null, $value = null)
	{
		if($column instanceof \Closure)
		{
			$this->or_where_open();
			$column($this);
			$this->or_where_close();
			return $this;
		}

		if (is_array($column))
		{
			foreach ($column as $key => $val)
			{
				if (is_array($val))
				{
					$this->or_where($val[0], $val[1], $val[2]);
				}
				else
				{
					$this->or_where($key, '=', $val);
				}
			}
		}
		else
		{
			if(func_num_args() === 2)
			{
				$value = $op;
				$op = '=';
			}
			$this->_where[] = array('OR' => array($column, $op, $value));
		}
		return $this;
	}
1237472
public function where($field, $op = null, $condition = null) {
        $this->addWhere("AND", $field, $op, $condition);
        return $this;
    }
600311
public function having($field, $cond = UNDEFINED, $value = UNDEFINED)
    {
        return $this->where($field, $cond, $value, 'having');
    }
695682
protected function _modifyPredicate(&$predicate, $type, $field, $op, $value) {
        if (!$predicate) {
            $predicate = new Predicate($type);

        } else if ($predicate->getType() !== $type) {
            throw new ExistingPredicateException(sprintf('Predicate clause already created using "%s" conjunction', $predicate->getType()));
        }

        if ($field instanceof Closure) {
            $predicate->bindCallback($field, $this);

        } else if ($value !== null || in_array($op, [Expr::NULL, Expr::NOT_NULL], true)) {
            $predicate->add($field, $op, $value);

        } else if ($op === '!=') {
            $predicate->notEq($field, $value);

        } else {
            $predicate->eq($field, $op);
        }

        return $this;
    }
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;
    }
465092
private function addOperator($operator, $field, $value) {
		$this->is($field, array('$' . $operator => $value));
		
		return $this;
	}
253128
public function whereId(string $field, $id, string $op = ''): self
    {
        return $this->where('?? = ?', [$field, $id], $op);
    }
831869
public function add($key, $value = null, $opr = null, $before = 'and')
    {
        $sValue = $value;
        if ($value) {
            if (is_array($value)) {
                $criteria = $this->buildCriteria($value, $this->qmMode);
                $sValue = '('.array_shift($criteria).')';
                $this->criteria = array_merge($this->criteria, $criteria);
                $opr = $opr ?: 'in';
            } else {
                $opr = $opr ?: '=';
                if ($this->qmMode) {
                    $sValue = '?';
                    $this->criteria[] = $value;
                } else {
                    $sKey = ":$key";
                    $sValue = $sKey;
                    $this->criteria[$sKey] = $value;
                }
            }
        }

        $this->criteria[0] .= ($this->criteria[0] ? " $before " : '') . $key .
            ($opr ? " $opr " : '') . $sValue;

        return $this;
    }
1307799
public function having($column, $op, $value = null)
    {
        return $this->andHaving($column, $op, $value);
    }
1264178
public function add($field, $op, $value) {
        $param = new Expr($field, $op, $value);

        $this->_params[] = $param;

        if ($param->useValue()) {
            $this->addBinding($field, $value);
        }

        return $this;
    }
120124
public function with($lValue, $op, $rValue)
    {
        $this->conditions[] = [
            'field' => $lValue,
            'op'    => $op,
            'value' => $rValue,
        ];

        return $this;
    }
1266896
public function setCondition($field_name, $value, $operation = '=')
    {
        $this->condition[$field_name] = [
            'value' => $value,
            'operation' => $operation
        ];

        return $this;
    }
658991
public function OrLike($Field, $Match = '', $Side = 'both', $Op = 'like') {
      if (!is_array($Field))
         $Field = array($Field => $Match);
      
      foreach ($Field as $f => $v) {
         $this->OrOp()->Like($f, $v, $Side, $Op);
      }
      return $this;

//       return $this->OrOp()->Like($Field, $Match, $Side, $Op);
   }