Server : Apache System : Linux server2.corals.io 4.18.0-348.2.1.el8_5.x86_64 #1 SMP Mon Nov 15 09:17:08 EST 2021 x86_64 User : corals ( 1002) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system Directory : /home/corals/old/vendor/laminas/laminas-db/src/Sql/Predicate/ |
<?php
namespace Laminas\Db\Sql\Predicate;
use Laminas\Db\Sql\Exception\RuntimeException;
use Laminas\Db\Sql\Select;
use function func_get_arg;
use function func_num_args;
use function strtolower;
/**
* @property Predicate $and
* @property Predicate $or
* @property Predicate $AND
* @property Predicate $OR
* @property Predicate $NEST
* @property Predicate $UNNEST
*/
class Predicate extends PredicateSet
{
/** @var null|Predicate */
protected $unnest;
/** @var null|string */
protected $nextPredicateCombineOperator;
/**
* Begin nesting predicates
*
* @return Predicate
*/
public function nest()
{
$predicateSet = new Predicate();
$predicateSet->setUnnest($this);
$this->addPredicate($predicateSet, $this->nextPredicateCombineOperator ?: $this->defaultCombination);
$this->nextPredicateCombineOperator = null;
return $predicateSet;
}
/**
* Indicate what predicate will be unnested
*
* @return void
*/
public function setUnnest(Predicate $predicate)
{
$this->unnest = $predicate;
}
/**
* Indicate end of nested predicate
*
* @return Predicate
* @throws RuntimeException
*/
public function unnest()
{
if ($this->unnest === null) {
throw new RuntimeException('Not nested');
}
$unnest = $this->unnest;
$this->unnest = null;
return $unnest;
}
/**
* Create "Equal To" predicate
*
* Utilizes Operator predicate
*
* @param int|float|bool|string|Expression $left
* @param int|float|bool|string|Expression $right
* @param string $leftType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_IDENTIFIER {@see allowedTypes}
* @param string $rightType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_VALUE {@see allowedTypes}
* @return $this Provides a fluent interface
*/
public function equalTo($left, $right, $leftType = self::TYPE_IDENTIFIER, $rightType = self::TYPE_VALUE)
{
$this->addPredicate(
new Operator($left, Operator::OPERATOR_EQUAL_TO, $right, $leftType, $rightType),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "Not Equal To" predicate
*
* Utilizes Operator predicate
*
* @param int|float|bool|string|Expression $left
* @param int|float|bool|string|Expression $right
* @param string $leftType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_IDENTIFIER {@see allowedTypes}
* @param string $rightType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_VALUE {@see allowedTypes}
* @return $this Provides a fluent interface
*/
public function notEqualTo($left, $right, $leftType = self::TYPE_IDENTIFIER, $rightType = self::TYPE_VALUE)
{
$this->addPredicate(
new Operator($left, Operator::OPERATOR_NOT_EQUAL_TO, $right, $leftType, $rightType),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "Less Than" predicate
*
* Utilizes Operator predicate
*
* @param int|float|bool|string|Expression $left
* @param int|float|bool|string|Expression $right
* @param string $leftType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_IDENTIFIER {@see allowedTypes}
* @param string $rightType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_VALUE {@see allowedTypes}
* @return $this Provides a fluent interface
*/
public function lessThan($left, $right, $leftType = self::TYPE_IDENTIFIER, $rightType = self::TYPE_VALUE)
{
$this->addPredicate(
new Operator($left, Operator::OPERATOR_LESS_THAN, $right, $leftType, $rightType),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "Greater Than" predicate
*
* Utilizes Operator predicate
*
* @param int|float|bool|string|Expression $left
* @param int|float|bool|string|Expression $right
* @param string $leftType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_IDENTIFIER {@see allowedTypes}
* @param string $rightType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_VALUE {@see allowedTypes}
* @return $this Provides a fluent interface
*/
public function greaterThan($left, $right, $leftType = self::TYPE_IDENTIFIER, $rightType = self::TYPE_VALUE)
{
$this->addPredicate(
new Operator($left, Operator::OPERATOR_GREATER_THAN, $right, $leftType, $rightType),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "Less Than Or Equal To" predicate
*
* Utilizes Operator predicate
*
* @param int|float|bool|string|Expression $left
* @param int|float|bool|string|Expression $right
* @param string $leftType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_IDENTIFIER {@see allowedTypes}
* @param string $rightType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_VALUE {@see allowedTypes}
* @return $this Provides a fluent interface
*/
public function lessThanOrEqualTo($left, $right, $leftType = self::TYPE_IDENTIFIER, $rightType = self::TYPE_VALUE)
{
$this->addPredicate(
new Operator($left, Operator::OPERATOR_LESS_THAN_OR_EQUAL_TO, $right, $leftType, $rightType),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "Greater Than Or Equal To" predicate
*
* Utilizes Operator predicate
*
* @param int|float|bool|string|Expression $left
* @param int|float|bool|string|Expression $right
* @param string $leftType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_IDENTIFIER {@see allowedTypes}
* @param string $rightType TYPE_IDENTIFIER or TYPE_VALUE by default TYPE_VALUE {@see allowedTypes}
* @return $this Provides a fluent interface
*/
public function greaterThanOrEqualTo(
$left,
$right,
$leftType = self::TYPE_IDENTIFIER,
$rightType = self::TYPE_VALUE
) {
$this->addPredicate(
new Operator($left, Operator::OPERATOR_GREATER_THAN_OR_EQUAL_TO, $right, $leftType, $rightType),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "Like" predicate
*
* Utilizes Like predicate
*
* @param string|Expression $identifier
* @param string $like
* @return $this Provides a fluent interface
*/
public function like($identifier, $like)
{
$this->addPredicate(
new Like($identifier, $like),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "notLike" predicate
*
* Utilizes In predicate
*
* @param string|Expression $identifier
* @param string $notLike
* @return $this Provides a fluent interface
*/
public function notLike($identifier, $notLike)
{
$this->addPredicate(
new NotLike($identifier, $notLike),
$this->nextPredicateCombineOperator ? : $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create an expression, with parameter placeholders
*
* @param string $expression
* @param null|array $parameters
* @return $this Provides a fluent interface
*/
public function expression($expression, $parameters = null)
{
$this->addPredicate(
new Expression($expression, func_num_args() > 1 ? $parameters : []),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "Literal" predicate
*
* Literal predicate, for parameters, use expression()
*
* @param string $literal
* @return $this Provides a fluent interface
*/
public function literal($literal)
{
// process deprecated parameters from previous literal($literal, $parameters = null) signature
if (func_num_args() >= 2) {
$parameters = func_get_arg(1);
$predicate = new Expression($literal, $parameters);
}
// normal workflow for "Literals" here
if (! isset($predicate)) {
$predicate = new Literal($literal);
}
$this->addPredicate(
$predicate,
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "IS NULL" predicate
*
* Utilizes IsNull predicate
*
* @param string|Expression $identifier
* @return $this Provides a fluent interface
*/
public function isNull($identifier)
{
$this->addPredicate(
new IsNull($identifier),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "IS NOT NULL" predicate
*
* Utilizes IsNotNull predicate
*
* @param string|Expression $identifier
* @return $this Provides a fluent interface
*/
public function isNotNull($identifier)
{
$this->addPredicate(
new IsNotNull($identifier),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "IN" predicate
*
* Utilizes In predicate
*
* @param string|Expression $identifier
* @param array|Select $valueSet
* @return $this Provides a fluent interface
*/
public function in($identifier, $valueSet = null)
{
$this->addPredicate(
new In($identifier, $valueSet),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "NOT IN" predicate
*
* Utilizes NotIn predicate
*
* @param string|Expression $identifier
* @param array|Select $valueSet
* @return $this Provides a fluent interface
*/
public function notIn($identifier, $valueSet = null)
{
$this->addPredicate(
new NotIn($identifier, $valueSet),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "between" predicate
*
* Utilizes Between predicate
*
* @param string|Expression $identifier
* @param int|float|string $minValue
* @param int|float|string $maxValue
* @return $this Provides a fluent interface
*/
public function between($identifier, $minValue, $maxValue)
{
$this->addPredicate(
new Between($identifier, $minValue, $maxValue),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Create "NOT BETWEEN" predicate
*
* Utilizes NotBetween predicate
*
* @param string|Expression $identifier
* @param int|float|string $minValue
* @param int|float|string $maxValue
* @return $this Provides a fluent interface
*/
public function notBetween($identifier, $minValue, $maxValue)
{
$this->addPredicate(
new NotBetween($identifier, $minValue, $maxValue),
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Use given predicate directly
*
* Contrary to {@link addPredicate()} this method respects formerly set
* AND / OR combination operator, thus allowing generic predicates to be
* used fluently within where chains as any other concrete predicate.
*
* @return $this Provides a fluent interface
*/
// phpcs:ignore Generic.NamingConventions.ConstructorName.OldStyle
public function predicate(PredicateInterface $predicate)
{
$this->addPredicate(
$predicate,
$this->nextPredicateCombineOperator ?: $this->defaultCombination
);
$this->nextPredicateCombineOperator = null;
return $this;
}
/**
* Overloading
*
* Overloads "or", "and", "nest", and "unnest"
*
* @param string $name
* @return $this Provides a fluent interface
*/
public function __get($name)
{
switch (strtolower($name)) {
case 'or':
$this->nextPredicateCombineOperator = self::OP_OR;
break;
case 'and':
$this->nextPredicateCombineOperator = self::OP_AND;
break;
case 'nest':
return $this->nest();
case 'unnest':
return $this->unnest();
}
return $this;
}
}