public function assemblePredicateSet(PredicateSet $predicate)
{
if (!$predicate->hasPredicates()) {
return '';
}
return '(' . implode($predicate->getGlue(), $this->assembleSegments($predicate->getPredicates())) . ')';
}
public function predicateData()
{
$nameEq = (new EqualPredicate())->setField('name')->setExpression(ValueExpression::create('test'));
$set = new PredicateSet();
$set->addPredicate($nameEq);
return [[['name' => 'test'], [$nameEq]], [[$nameEq], [$nameEq]], [['AND' => ['name' => 'test']], [$set]]];
}
/**
* @expectedException \Exception
* @expectedExceptionMessage Cannot have multiple predicate sets in CQL
*/
public function testMultiplePredicatesFail()
{
$where = WhereClause::create();
$set = new PredicateSet();
$set->addPredicate(new PredicateSet());
$where->addPredicate($set);
CqlAssembler::stringify($where);
}
private function _getNewSet(...$expressions)
{
$newPredicates = WhereClause::buildPredicates($expressions);
if (count($newPredicates) === 1) {
$newSet = Arrays::first($newPredicates);
} else {
$newSet = new PredicateSet();
$newSet->setPredicates($newPredicates);
}
return $newSet;
}
public static function buildPredicates(array $input, $table = null, $inverse = false)
{
$predicates = [];
foreach ($input as $key => $value) {
if ($value === null || is_scalar($value) || $value instanceof ValueExpression) {
$pred = $inverse ? new NotEqualPredicate() : new EqualPredicate();
$pred->setField(FieldExpression::createWithTable($key, $table));
if (!$value instanceof ValueExpression) {
$value = ValueExpression::create($value);
}
$pred->setExpression($value);
$predicates[] = $pred;
} else {
if ($value instanceof IPredicate) {
$predicates[] = $value;
} else {
if (is_array($value)) {
if (is_int($key)) {
$predicates = array_merge($predicates, static::buildPredicates($value, $table, $inverse));
} else {
if (static::_isControlKeyword($key)) {
switch ($key) {
case 'NOT':
$predicates = array_merge($predicates, static::buildPredicates($value, $table, true));
break;
case 'OR':
$pred = new OrPredicateSet();
$pred->setPredicates(static::buildPredicates($value, $table, $inverse));
$predicates[] = $pred;
break;
case 'AND':
$pred = new PredicateSet();
$pred->setPredicates(static::buildPredicates($value, $table, $inverse));
$predicates[] = $pred;
break;
}
} else {
$pred = $inverse ? new NotInPredicate() : new InPredicate();
$pred->setField(FieldExpression::createWithTable($key, $table));
$pred->setExpression(ArrayExpression::create($value));
$predicates[] = $pred;
}
}
}
}
}
}
return $predicates;
}
public function testAssemble()
{
$this->assertEquals('', QueryAssembler::stringify(PredicateSet::create()));
$eq = new EqualPredicate();
$eq->setField("first")->setExpression(ValueExpression::create('val1'));
$neq = new NotEqualPredicate();
$neq->setField("second")->setExpression(ValueExpression::create('val1'));
$set = PredicateSet::create($eq, $neq);
$this->assertEquals('(first = "val1" AND second <> "val1")', QueryAssembler::stringify($set));
}
public function assembleBetween(BetweenPredicate $betweenPredicate)
{
$gte = new GreaterThanOrEqualPredicate();
$gte->setField($betweenPredicate->getField());
$lte = new LessThanOrEqualPredicate();
$lte->setField($betweenPredicate->getField());
$set = new PredicateSet();
if ($betweenPredicate instanceof NotBetweenPredicate) {
$gte->setExpression($betweenPredicate->getRangeEnd());
$lte->setExpression($betweenPredicate->getRangeStart());
$set->addPredicate($lte);
$set->addPredicate($gte);
} else {
$gte->setExpression($betweenPredicate->getRangeStart());
$lte->setExpression($betweenPredicate->getRangeEnd());
$set->addPredicate($gte);
$set->addPredicate($lte);
}
return $this->assembleSegment($set);
}
