/**
* {@inheritDoc}
*/
public function walkCompositeExpression(CompositeExpression $expr, AbstractNode $parentNode)
{
switch ($expr->getType()) {
case CompositeExpression::TYPE_AND:
$node = $parentNode->andX();
break;
case CompositeExpression::TYPE_OR:
$node = $parentNode->orX();
break;
default:
throw new \RuntimeException('Unknown composite: ' . $expr->getType());
}
$expressions = $expr->getExpressionList();
$leftExpression = array_shift($expressions);
$this->dispatch($leftExpression, $node);
$parentNode = $node;
foreach ($expressions as $index => $expression) {
if (count($expressions) === $index + 1) {
$this->dispatch($expression, $parentNode);
break;
}
switch ($expr->getType()) {
case CompositeExpression::TYPE_AND:
$parentNode = $parentNode->andX();
break;
case CompositeExpression::TYPE_OR:
$parentNode = $parentNode->orX();
break;
}
$this->dispatch($expression, $parentNode);
}
return $node;
}
/**
* {@inheritDoc}
*/
public function walkCompositeExpression(CompositeExpression $expr)
{
$expressionList = array();
foreach ($expr->getExpressionList() as $child) {
$expressionList[] = $this->dispatch($child);
}
return $this->doWalkCompositeExpression($expr->getType(), $expressionList);
}
/**
* {@inheritdoc}
*/
public function walkCompositeExpression(CompositeExpression $expr)
{
$expressionList = [];
foreach ($expr->getExpressionList() as $child) {
$expressionList[] = $this->dispatch($child);
}
return '(' . implode(' ' . strtolower($expr->getType()) . ' ', $expressionList) . ')';
}
/**
* Converts a composite expression into the target query language output.
*
* @see ExpressionVisitor::walkCompositeExpression()
* @param CompositeExpression $compositeExpr
* @return array
*/
public function walkCompositeExpression(CompositeExpression $compositeExpr)
{
$expressions = $compositeExpr->getExpressionList();
$result = [];
/** @var Expression $expression */
foreach ($expressions as $expression) {
$result += $expression->visit($this);
}
if ($compositeExpr->getType() === CompositeExpression::TYPE_OR) {
return ['$or' => $result];
}
return $result;
}
/**
* Converts a composite expression into the target query language output.
*
* @param \Doctrine\Common\Collections\Expr\CompositeExpression $expr
*
* @return mixed
*
* @throws \RuntimeException
*/
public function walkCompositeExpression(CompositeExpression $expr)
{
$expressionList = array();
foreach ($expr->getExpressionList() 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());
}
}
/**
* Converts a composite expression into the target query language output.
*
* @param CompositeExpression $expr
*
* @return mixed
*/
public function walkCompositeExpression(CompositeExpression $expr)
{
$result = [];
$tokens = [];
foreach ($expr->getExpressionList() as $exp) {
if ($exp instanceof CompositeExpression) {
$w = $this->walkCompositeExpression($exp);
} else {
$w = $this->walkComparison($exp);
}
$result[] = $w['expression'];
$tokens = array_merge($tokens, $w['tokens']);
}
return ['expression' => '( ' . implode(' ' . $expr->getType() . ' ', $result) . ' )', 'tokens' => $tokens];
}
/**
* {@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());
}
}
/**
* Converts a composite expression into the target query language output.
*
* @see ExpressionVisitor::walkCompositeExpression()
* @param CompositeExpression $expr
* @return \Doctrine\ODM\MongoDB\Query\Expr
*/
public function walkCompositeExpression(CompositeExpression $compositeExpr)
{
if (!isset(self::$compositeMethods[$compositeExpr->getType()])) {
throw new \RuntimeException('Unknown composite ' . $compositeExpr->getType());
}
$method = self::$compositeMethods[$compositeExpr->getType()];
$expr = $this->builder->expr();
foreach ($compositeExpr->getExpressionList() as $child) {
$expr->{$method}($this->dispatch($child));
}
return $expr;
}
/**
* Converts a composite expression into the target query language output.
*
* @param \Doctrine\Common\Collections\Expr\CompositeExpression $expr
*
* @return mixed
*/
public function walkCompositeExpression(CompositeExpression $expr)
{
foreach ($expr->getExpressionList() as $child) {
$this->dispatch($child);
}
}
/**
* {@inheritDoc}
*/
public function walkCompositeExpression(CompositeExpression $expr)
{
$expressionList = [];
foreach ($expr->getExpressionList() as $child) {
$expressionList[] = $this->dispatch($child);
}
switch ($expr->getType()) {
case CompositeExpression::TYPE_AND:
return new Expr\Andx($expressionList);
case CompositeExpression::TYPE_OR:
return new Expr\Orx($expressionList);
default:
throw new \RuntimeException("Unknown composite " . $expr->getType());
}
}
