Merge pull request #22 from moufmouf/1.1

moufmouf · moufmouf · commit edfb5763cb4c · 2016-02-29T13:19:20.000+01:00
Adding support for CASE WHEN... constructs
diff --git a/src/SQLParser/Node/CaseOperation.php b/src/SQLParser/Node/CaseOperation.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace SQLParser\Node;
+
+use Mouf\Utils\Common\ConditionInterface\ConditionTrait;
+use Doctrine\DBAL\Connection;
+use Mouf\MoufManager;
+use Mouf\MoufInstanceDescriptor;
+use SQLParser\Node\Traverser\NodeTraverser;
+use SQLParser\Node\Traverser\VisitorInterface;
+
+/**
+ * This class represents a CASE ... END statement.
+ *
+ * @author David Négrier <d.negrier@thecodingmachine.com>
+ */
+class CaseOperation implements NodeInterface
+{
+    private $operation;
+
+    public function getOperation()
+    {
+        return $this->operation;
+    }
+
+    /**
+     * Sets the operation.
+     *
+     * @Important
+     *
+     * @param NodeInterface|NodeInterface[]|string $operation
+     */
+    public function setOperation($operation)
+    {
+        $this->operation = $operation;
+    }
+
+    /**
+     * Returns a Mouf instance descriptor describing this object.
+     *
+     * @param MoufManager $moufManager
+     *
+     * @return MoufInstanceDescriptor
+     */
+    public function toInstanceDescriptor(MoufManager $moufManager)
+    {
+        $instanceDescriptor = $moufManager->createInstance(get_called_class());
+        $instanceDescriptor->getProperty('operation')->setValue(NodeFactory::nodeToInstanceDescriptor($this->operation, $moufManager));
+
+        return $instanceDescriptor;
+    }
+
+    /**
+     * Renders the object as a SQL string.
+     *
+     * @param Connection $dbConnection
+     * @param array      $parameters
+     * @param number     $indent
+     * @param int        $conditionsMode
+     *
+     * @return string
+     */
+    public function toSql(array $parameters = array(), Connection $dbConnection = null, $indent = 0, $conditionsMode = self::CONDITION_APPLY)
+    {
+
+        $sql = 'CASE '.NodeFactory::toSql($this->operation, $dbConnection, $parameters, ' ', false, $indent, $conditionsMode).' END';
+
+        return $sql;
+    }
+
+    /**
+     * Walks the tree of nodes, calling the visitor passed in parameter.
+     *
+     * @param VisitorInterface $visitor
+     */
+    public function walk(VisitorInterface $visitor) {
+        $node = $this;
+        $result = $visitor->enterNode($node);
+        if ($result instanceof NodeInterface) {
+            $node = $result;
+        }
+        if ($result !== NodeTraverser::DONT_TRAVERSE_CHILDREN) {
+            $result2 = $this->operation->walk($visitor);
+            if ($result2 === NodeTraverser::REMOVE_NODE) {
+                return NodeTraverser::REMOVE_NODE;
+            } elseif ($result2 instanceof NodeInterface) {
+                $this->operation = $result2;
+            }
+        }
+        return $visitor->leaveNode($node);
+    }
+}
diff --git a/src/SQLParser/Node/ElseOperation.php b/src/SQLParser/Node/ElseOperation.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace SQLParser\Node;
+
+/**
+ * This class represents a ELSE (in a CASE WHEN ... THEN ... ELSE ... END construct)
+ *
+ * @author David Négrier <d.negrier@thecodingmachine.com>
+ */
+class ElseOperation extends AbstractTwoOperandsOperator
+{
+    /**
+     * Returns the symbol for this operator.
+     *
+     * @return string
+     */
+    protected function getOperatorSymbol()
+    {
+        return 'ELSE';
+    }
+}
diff --git a/src/SQLParser/Node/NodeFactory.php b/src/SQLParser/Node/NodeFactory.php
@@ -293,24 +293,42 @@ public static function toObject(array $desc)
 
                 return $expr;
             case ExpressionType::RESERVED:
-                $res = new Reserved();
-                $res->setBaseExpression($desc['base_expr']);
+                if (in_array(strtoupper($desc['base_expr']), ['CASE', 'WHEN', 'THEN', 'ELSE', 'END'])) {
+                    $operator = new Operator();
+                    $operator->setValue($desc['base_expr']);
+                    // Debug:
+                    unset($desc['base_expr']);
+                    unset($desc['expr_type']);
+                    if (!empty($desc['sub_tree'])) {
+                        throw new \InvalidArgumentException('Unexpected operator with subtree: '.var_export($desc['sub_tree'], true));
+                    }
+                    unset($desc['sub_tree']);
+                    if (!empty($desc)) {
+                        throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true));
+                    }
 
-                if ($desc['expr_type'] == ExpressionType::BRACKET_EXPRESSION) {
-                    $res->setBrackets(true);
-                }
+                    return $operator;
+                } else {
 
-                // Debug:
-                unset($desc['base_expr']);
-                unset($desc['expr_type']);
-                unset($desc['sub_tree']);
-                unset($desc['alias']);
-                unset($desc['direction']);
-                if (!empty($desc)) {
-                    throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true));
-                }
+                    $res = new Reserved();
+                    $res->setBaseExpression($desc['base_expr']);
+
+                    if ($desc['expr_type'] == ExpressionType::BRACKET_EXPRESSION) {
+                        $res->setBrackets(true);
+                    }
 
-                return $res;
+                    // Debug:
+                    unset($desc['base_expr']);
+                    unset($desc['expr_type']);
+                    unset($desc['sub_tree']);
+                    unset($desc['alias']);
+                    unset($desc['direction']);
+                    if (!empty($desc)) {
+                        throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true));
+                    }
+
+                    return $res;
+                }
             case ExpressionType::USER_VARIABLE:
             case ExpressionType::SESSION_VARIABLE:
             case ExpressionType::GLOBAL_VARIABLE:
@@ -402,7 +420,10 @@ private static function buildFromSubtree($subTree)
             array('|'),
             array('=' /*(comparison)*/, '<=>', '>=', '>', '<=', '<', '<>', '!=', 'IS', 'LIKE', 'REGEXP', 'IN', 'IS NOT', 'NOT IN'),
             array('AND_FROM_BETWEEN'),
-            array('BETWEEN', 'CASE', 'WHEN', 'THEN', 'ELSE'),
+            array('THEN'),
+            array('WHEN'),
+            array('ELSE'),
+            array('BETWEEN', 'CASE', 'END'),
             array('NOT'),
             array('&&', 'AND'),
             array('XOR'),
@@ -441,6 +462,8 @@ private static function buildFromSubtree($subTree)
             '||' => 'SQLParser\Node\OrOp',
             'OR' => 'SQLParser\Node\OrOp',
             'XOR' => 'SQLParser\Node\XorOp',
+            'THEN' => 'SQLParser\Node\Then',
+            'ELSE' => 'SQLParser\Node\ElseOperation'
     );
 
     /**
@@ -543,8 +566,13 @@ public static function simplify($nodes)
         $tmpOperators = $selectedOperators;
         $nextOperator = array_shift($tmpOperators);
 
+        $isSelectedOperatorFirst = null;
+
         foreach ($nodes as $node) {
             if ($node === $nextOperator) {
+                if ($isSelectedOperatorFirst === null) {
+                    $isSelectedOperatorFirst = true;
+                }
                 // Let's apply the "simplify" method on the operand before storing it.
                 //$operands[] = self::simplify($operand);
                 $simple = self::simplify($operand);
@@ -557,6 +585,9 @@ public static function simplify($nodes)
                 $operand = array();
                 $nextOperator = array_shift($tmpOperators);
             } else {
+                if ($isSelectedOperatorFirst === null) {
+                    $isSelectedOperatorFirst = false;
+                }
                 $operand[] = $node;
             }
         }
@@ -587,7 +618,6 @@ public static function simplify($nodes)
         array('INTERVAL'),
         array('BINARY', 'COLLATE'),
         array('!'),
-        array('BETWEEN', 'CASE', 'WHEN', 'THEN', 'ELSE'),
         array('NOT'),
         */
 
@@ -625,6 +655,31 @@ public static function simplify($nodes)
             $instance->setMaxValueOperand($maxOperand);
 
             return $instance;
+        } elseif ($operation === 'WHEN') {
+
+            $instance = new WhenConditions();
+
+            if (!$isSelectedOperatorFirst) {
+                $value = array_shift($operands);
+                $instance->setValue($value);
+            }
+            $instance->setOperands($operands);
+
+            return $instance;
+        } elseif ($operation === 'CASE') {
+            $innerOperation = array_shift($operands);
+
+            if (!empty($operands)) {
+                throw new MagicQueryException('A CASE statement should contain only a ThenConditions or a ElseOperand object.');
+            }
+
+            $instance = new CaseOperation();
+            $instance->setOperation($innerOperation);
+            return $instance;
+        } elseif ($operation === 'END') {
+            // Simply bypass the END operation. We already have a CASE matching node:
+            $caseOperation = array_shift($operands);
+            return $caseOperation;
         } else {
             $instance = new Operation();
             $instance->setOperatorSymbol($operation);
diff --git a/src/SQLParser/Node/Then.php b/src/SQLParser/Node/Then.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace SQLParser\Node;
+
+/**
+ * This class represents a THEN (in a CASE WHEN ... THEN ... END construct)
+ *
+ * @author David Négrier <d.negrier@thecodingmachine.com>
+ */
+class Then extends AbstractTwoOperandsOperator
+{
+    /**
+     * Returns the symbol for this operator.
+     *
+     * @return string
+     */
+    protected function getOperatorSymbol()
+    {
+        return 'THEN';
+    }
+}
diff --git a/src/SQLParser/Node/WhenConditions.php b/src/SQLParser/Node/WhenConditions.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace SQLParser\Node;
+
+use Mouf\Utils\Common\ConditionInterface\ConditionTrait;
+use Doctrine\DBAL\Connection;
+use Mouf\MoufManager;
+use Mouf\MoufInstanceDescriptor;
+use SQLParser\Node\Traverser\NodeTraverser;
+use SQLParser\Node\Traverser\VisitorInterface;
+
+/**
+ * This class represents a set of ... WHEN ... THEN ... construct (inside a CASE).
+ *
+ * @author David Négrier <d.negrier@thecodingmachine.com>
+ */
+class WhenConditions extends AbstractManyInstancesOperator
+{
+
+    private $value;
+
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Sets the value.
+     *
+     * @Important
+     *
+     * @param NodeInterface|NodeInterface[]|string $value
+     */
+    public function setValue($value)
+    {
+        $this->value = $value;
+    }
+
+    /**
+     * Renders the object as a SQL string.
+     *
+     * @param Connection $dbConnection
+     * @param array      $parameters
+     * @param number     $indent
+     * @param int        $conditionsMode
+     *
+     * @return string
+     */
+    public function toSql(array $parameters = array(), Connection $dbConnection = null, $indent = 0, $conditionsMode = self::CONDITION_APPLY)
+    {
+        $fullSql = '';
+
+        if ($this->value) {
+            $fullSql = NodeFactory::toSql($this->value, $dbConnection, $parameters, ' ', false, $indent, $conditionsMode);
+        }
+
+        foreach ($this->getOperands() as $operand) {
+            $sql = NodeFactory::toSql($operand, $dbConnection, $parameters, ' ', false, $indent, $conditionsMode);
+            if ($sql != null) {
+                $fullSql .= "\n".str_repeat(' ', $indent).'WHEN '.$sql;
+            }
+        }
+
+        return $fullSql;
+    }
+
+    /**
+     * Returns the symbol for this operator.
+     *
+     * @return string
+     */
+    protected function getOperatorSymbol()
+    {
+        return 'WHEN';
+    }
+}
diff --git a/tests/Mouf/Database/MagicQueryTest.php b/tests/Mouf/Database/MagicQueryTest.php
@@ -88,6 +88,15 @@ public function testStandardSelect()
         // Tests parameters with a ! (to force NULL values)
         $sql = 'SELECT * FROM users WHERE status = :status!';
         $this->assertEquals("SELECT * FROM users WHERE status = null", self::simplifySql($magicQuery->build($sql, ['status' => null])));
+
+        // Test CASE WHERE
+        $sql = "SELECT CASE WHEN status = 'on' THEN '1' WHEN status = 'off' THEN '0' ELSE '-1' END AS my_case FROM users";
+        $this->assertEquals("SELECT CASE WHEN status = 'on' THEN '1' WHEN status = 'off' THEN '0' ELSE '-1' END AS my_case FROM users", self::simplifySql($magicQuery->build($sql)));
+
+        // Test CASE WHERE like SWITCH CASE
+        $sql = "SELECT CASE status WHEN 'on' THEN '1' WHEN 'off' THEN '0' ELSE '-1' END AS my_case FROM users";
+        $this->assertEquals("SELECT CASE status WHEN 'on' THEN '1' WHEN 'off' THEN '0' ELSE '-1' END AS my_case FROM users", self::simplifySql($magicQuery->build($sql)));
+
     }
 
     public function testWithCache() {
