/**
* Convert a comparison expression into the target query language output
*
* @param \Doctrine\Common\Collections\Expr\Comparison $comparison
*
* @return mixed
*/
public function walkComparison(Comparison $comparison)
{
$field = $comparison->getField();
$value = $comparison->getValue()->getValue();
// shortcut for walkValue()
return $this->persister->getSelectConditionStatementSQL($field, $value, null, $comparison->getOperator());
}
/**
* {@inheritDoc}
*/
public function walkComparison(Comparison $comparison, AbstractNode $parentNode)
{
$field = $comparison->getField();
$value = $comparison->getValue()->getValue();
// shortcut for walkValue()
switch ($comparison->getOperator()) {
case Comparison::EQ:
return $parentNode->eq()->field($this->getField($field))->literal($value)->end();
case Comparison::NEQ:
return $parentNode->neq()->field($this->getField($field))->literal($value)->end();
case Comparison::LT:
return $parentNode->lt()->field($this->getField($field))->literal($value)->end();
case Comparison::LTE:
return $parentNode->lte()->field($this->getField($field))->literal($value)->end();
case Comparison::GT:
return $parentNode->gt()->field($this->getField($field))->literal($value)->end();
case Comparison::GTE:
return $parentNode->gte()->field($this->getField($field))->literal($value)->end();
case Comparison::IN:
return $this->getInConstraint($parentNode, $field, $value);
case Comparison::NIN:
$node = $parentNode->not();
$this->getInConstraint($node, $field, $value);
return $node->end();
case Comparison::CONTAINS:
return $parentNode->like()->field($this->getField($field))->literal($value)->end();
case ExtraComparison::NOT_CONTAINS:
return $parentNode->not()->like()->field($this->getField($field))->literal($value)->end()->end();
case ExtraComparison::IS_NULL:
return $parentNode->not()->fieldIsset($this->getField($field))->end();
case ExtraComparison::IS_NOT_NULL:
return $parentNode->fieldIsset($this->getField($field));
}
throw new \RuntimeException('Unknown comparison operator: ' . $comparison->getOperator());
}
/**
* {@inheritdoc}
*/
public function walkComparison(Comparison $comparison)
{
$field = $comparison->getField();
if (!isset($this->fields[$field])) {
$this->fields[$field] = true;
}
}
/**
* Convert a comparison expression into the target query language output
*
* @param \Doctrine\Common\Collections\Expr\Comparison $comparison
*
* @return mixed
*/
public function walkComparison(Comparison $comparison)
{
$value = $comparison->getValue()->getValue();
$field = $comparison->getField();
$this->values[] = $value;
$this->types[] = array($field, $value);
}
/**
* Converts a comparison expression into the target query language output.
*
* @param \Doctrine\Common\Collections\Expr\Comparison $comparison
*
* @return mixed
*/
public function walkComparison(Comparison $comparison)
{
$field = $comparison->getField();
$value = $comparison->getValue()->getValue();
// shortcut for walkValue()
if (isset($this->classMetadata->associationMappings[$field]) && $value !== null && !is_object($value) && !in_array($comparison->getOperator(), array(Comparison::IN, Comparison::NIN))) {
throw PersisterException::matchingAssocationFieldRequiresObject($this->classMetadata->name, $field);
}
return $this->persister->getSelectConditionStatementSQL($field, $value, null, $comparison->getOperator());
}
/**
* {@inheritdoc}
*/
public function walkComparison(Comparison $comparison)
{
list($type, $field) = Criteria::explodeFieldTypeName($comparison->getField());
$value = $comparison->getValue()->getValue();
if (is_array($value)) {
$value = sprintf('(%s)', implode(', ', $value));
}
if ($type === Query::TYPE_TEXT) {
$value = sprintf('"%s"', $value);
}
return sprintf('%s %s %s %s', $type, $field, Criteria::getSearchOperatorByComparisonOperator($comparison->getOperator()), $value);
}
function it_should_restrict_with_or_condition(Comparison $comparison, Value $value, QueryBuilder $queryBuilder, ConstraintOrx $constraint, ConstraintComparison $comparisonConstraint)
{
$queryBuilder->orWhere()->willReturn($constraint);
$value->getValue()->willReturn('value');
$comparison->getValue()->willReturn($value);
$comparison->getField()->willReturn('foo');
$comparison->getOperator()->willReturn('=');
$constraint->eq()->willReturn($comparisonConstraint);
$comparisonConstraint->field('o.foo')->willReturn($comparisonConstraint);
$comparisonConstraint->literal('value')->shouldBeCalled()->willReturn($comparisonConstraint);
$comparisonConstraint->end()->shouldBeCalled();
$this->restrict($comparison, DataSourceInterface::CONDITION_OR);
}
/**
* Convert a comparison expression into the target query language output
*
* @param \Doctrine\Common\Collections\Expr\Comparison $comparison
*
* @return mixed
*/
public function walkComparison(Comparison $comparison)
{
$value = $comparison->getValue()->getValue();
$field = $comparison->getField();
$operator = $comparison->getOperator();
if (($operator === Comparison::EQ || $operator === Comparison::IS) && $value === null) {
return;
} else {
if ($operator === Comparison::NEQ && $value === null) {
return;
}
}
$this->values[] = $value;
$this->types[] = array($field, $value);
}
/**
* {@inheritdoc}
*/
public function walkComparison(Comparison $comparison)
{
$field = $comparison->getField();
$value = $this->walkValue($comparison->getValue());
switch ($comparison->getOperator()) {
case Comparison::EQ:
return function ($object) use($field, $value) {
return static::getObjectFieldValue($object, $field) === $value;
};
case Comparison::NEQ:
return function ($object) use($field, $value) {
return static::getObjectFieldValue($object, $field) !== $value;
};
case Comparison::LT:
return function ($object) use($field, $value) {
return static::getObjectFieldValue($object, $field) < $value;
};
case Comparison::LTE:
return function ($object) use($field, $value) {
return static::getObjectFieldValue($object, $field) <= $value;
};
case Comparison::GT:
return function ($object) use($field, $value) {
return static::getObjectFieldValue($object, $field) > $value;
};
case Comparison::GTE:
return function ($object) use($field, $value) {
return static::getObjectFieldValue($object, $field) >= $value;
};
case Comparison::IN:
return function ($object) use($field, $value) {
return in_array(static::getObjectFieldValue($object, $field), $value);
};
case Comparison::NIN:
return function ($object) use($field, $value) {
return !in_array(static::getObjectFieldValue($object, $field), $value);
};
case Comparison::CONTAINS:
return function ($object) use($field, $value) {
return false !== strpos(static::getObjectFieldValue($object, $field), $value);
};
default:
throw new \RuntimeException("Unknown comparison operator: " . $comparison->getOperator());
}
}
/**
* {@inheritDoc}
*/
public function walkComparison(Comparison $comparison)
{
$parameterName = str_replace('.', '_', $comparison->getField());
$value = $this->walkValue($comparison->getValue());
if ($comparison->getOperator() === Comparison::CONTAINS) {
$value = "%{$value}%";
}
$placeholder = null;
if ($this->walkValue($comparison->getValue()) !== null) {
$this->parameters[$parameterName] = $value;
$placeholder = ':' . $parameterName;
}
return $this->doWalkComparison($this->getFieldName($comparison->getField()), $comparison->getOperator(), $placeholder);
}
/**
* Converts a comparison expression into the target query language output.
*
* @see ExpressionVisitor::walkComparison()
* @param Comparison $comparison
* @return \Doctrine\ODM\MongoDB\Query\Expr
*/
public function walkComparison(Comparison $comparison)
{
switch ($comparison->getOperator()) {
case Comparison::EQ:
case Comparison::GT:
case Comparison::GTE:
case Comparison::IN:
case Comparison::IS:
case Comparison::LT:
case Comparison::LTE:
case Comparison::NEQ:
case Comparison::NIN:
$method = self::$operatorMethods[$comparison->getOperator()];
return $this->builder->expr()->field($comparison->getField())->{$method}($this->walkValue($comparison->getValue()));
case Comparison::CONTAINS:
$value = $this->walkValue($comparison->getValue());
return $this->builder->expr()->field($comparison->getField())->equals(new \MongoRegex('/' . preg_quote($value, '/') . '/'));
default:
throw new \RuntimeException('Unknown comparison operator: ' . $comparison->getOperator());
}
}
/**
* Converts a comparison expression into the target query language output.
*
* @see ExpressionVisitor::walkComparison()
* @param Comparison $comparison
* @return array
*
* @throws \RuntimeException
*/
public function walkComparison(Comparison $comparison)
{
switch ($comparison->getOperator()) {
case Comparison::EQ:
case Comparison::GT:
case Comparison::GTE:
case Comparison::IN:
case Comparison::IS:
case Comparison::LT:
case Comparison::LTE:
case Comparison::NEQ:
case Comparison::NIN:
$operator = self::$OPERATOR_MAPPING[$comparison->getOperator()];
$value = $this->walkValue($comparison->getValue());
return [$comparison->getField() => [$operator => $value]];
default:
throw new \RuntimeException('Unknown comparison operator: ' . $comparison->getOperator());
}
}
/**
* Returns the value from a Comparison. In case of a CONTAINS comparison,
* the value is wrapped in %-signs, because it will be used in a LIKE clause.
*
* @param \Doctrine\Common\Collections\Expr\Comparison $comparison
* @return mixed
*/
protected function getValueFromComparison(Comparison $comparison)
{
$value = $comparison->getValue()->getValue();
return $comparison->getOperator() == Comparison::CONTAINS ? "%{$value}%" : $value;
}
/**
* {@inheritDoc}
*/
public function walkComparison(Comparison $comparison)
{
$parameterName = str_replace('.', '_', $comparison->getField());
$parameter = new Parameter($parameterName, $this->walkValue($comparison->getValue()));
$placeholder = ':' . $parameterName;
switch ($comparison->getOperator()) {
case Comparison::IN:
$this->parameters[] = $parameter;
return $this->expr->in($this->rootAlias . '.' . $comparison->getField(), $placeholder);
case Comparison::NIN:
$this->parameters[] = $parameter;
return $this->expr->notIn($this->rootAlias . '.' . $comparison->getField(), $placeholder);
case Comparison::EQ:
case Comparison::IS:
if ($this->walkValue($comparison->getValue()) === null) {
return $this->expr->isNull($this->rootAlias . '.' . $comparison->getField());
}
$this->parameters[] = $parameter;
return $this->expr->eq($this->rootAlias . '.' . $comparison->getField(), $placeholder);
case Comparison::NEQ:
if ($this->walkValue($comparison->getValue()) === null) {
return $this->expr->isNotNull($this->rootAlias . '.' . $comparison->getField());
}
$this->parameters[] = $parameter;
return $this->expr->neq($this->rootAlias . '.' . $comparison->getField(), $placeholder);
default:
$operator = self::convertComparisonOperator($comparison->getOperator());
if ($operator) {
$this->parameters[] = $parameter;
return new Expr\Comparison($this->rootAlias . '.' . $comparison->getField(), $operator, $placeholder);
}
throw new \RuntimeException("Unknown comparison operator: " . $comparison->getOperator());
}
}
/**
* Converts a comparison expression into the target query language output.
*
* @param Comparison $comparison
*
* @return mixed
*/
public function walkComparison(Comparison $comparison)
{
$tokenName = uniqid(':');
$token = [$tokenName => ['name' => $tokenName, 'field' => $comparison->getField(), 'value' => $comparison->getValue()->getValue()]];
return ['expression' => $comparison->getField() . ' ' . $comparison->getOperator() . ' ' . $tokenName . '', 'tokens' => $token];
}
/**
* {@inheritDoc}
*/
public function walkComparison(Comparison $comparison)
{
if (!isset($this->queryAliases[0])) {
throw new QueryException('No aliases are set before invoking walkComparison().');
}
$field = $this->queryAliases[0] . '.' . $comparison->getField();
foreach ($this->queryAliases as $alias) {
if (strpos($comparison->getField() . '.', $alias . '.') === 0) {
$field = $comparison->getField();
break;
}
}
$parameterName = str_replace('.', '_', $comparison->getField());
foreach ($this->parameters as $parameter) {
if ($parameter->getName() === $parameterName) {
$parameterName .= '_' . count($this->parameters);
break;
}
}
$parameter = new Parameter($parameterName, $this->walkValue($comparison->getValue()));
$placeholder = ':' . $parameterName;
switch ($comparison->getOperator()) {
case Comparison::IN:
$this->parameters[] = $parameter;
return $this->expr->in($field, $placeholder);
case Comparison::NIN:
$this->parameters[] = $parameter;
return $this->expr->notIn($field, $placeholder);
case Comparison::EQ:
case Comparison::IS:
if ($this->walkValue($comparison->getValue()) === null) {
return $this->expr->isNull($field);
}
$this->parameters[] = $parameter;
return $this->expr->eq($field, $placeholder);
case Comparison::NEQ:
if ($this->walkValue($comparison->getValue()) === null) {
return $this->expr->isNotNull($field);
}
$this->parameters[] = $parameter;
return $this->expr->neq($field, $placeholder);
case Comparison::CONTAINS:
$parameter->setValue('%' . $parameter->getValue() . '%', $parameter->getType());
$this->parameters[] = $parameter;
return $this->expr->like($field, $placeholder);
default:
$operator = self::convertComparisonOperator($comparison->getOperator());
if ($operator) {
$this->parameters[] = $parameter;
return new Expr\Comparison($field, $operator, $placeholder);
}
throw new \RuntimeException("Unknown comparison operator: " . $comparison->getOperator());
}
}
/**
* {@inheritdoc}
*/
public function walkCompositeExpression(CompositeExpression $expr)
{
$expressionList = [];
$expressionObjectList = [];
$expressions = $expr->getExpressionList();
$lineExpression = true;
foreach ($expressions as $child) {
if ($child instanceof CompositeExpression) {
$lineExpression = false;
$expressionObjectList = $expressions;
break;
}
}
// optimize search query.
if ($lineExpression) {
/** @var Comparison $child */
foreach ($expressions as $child) {
$fieldName = $child->getField();
$operator = $child->getOperator();
$value = $child->getValue()->getValue();
$fieldType = Criteria::explodeFieldTypeName($fieldName)[0];
$key = $this->getExpressionKey($fieldType, $operator, $value);
$combinedExpression = $child;
if ($fieldType !== Query::TYPE_TEXT && in_array($key, array_keys($expressionObjectList))) {
$combinedExpression = $expressionObjectList[$key];
$combinedExpression = new Comparison($this->combineFieldNames($combinedExpression->getField(), $fieldName), $operator, $value);
}
$expressionObjectList[$key] = $combinedExpression;
}
}
foreach ($expressionObjectList as $child) {
$expressionList[] = $this->dispatch($child);
}
switch ($expr->getType()) {
case CompositeExpression::TYPE_AND:
return '(' . implode(' AND ', $expressionList) . ')';
case CompositeExpression::TYPE_OR:
return '(' . implode(' OR ', $expressionList) . ')';
default:
throw new \RuntimeException('Unknown composite ' . $expr->getType());
}
}
/**
* @inheritDoc
*/
public function walkComparison(Comparison $comparison)
{
$value = $this->dispatch($comparison->getValue());
return array('field' => $comparison->getField(), 'value' => $value, 'operator' => $comparison->getOperator());
}
