Added support for addition in compiled plans

community/cypher/cypher-compiler-2.3/src/main/java/org/neo4j/cypher/internal/compiler/v2_3/birk/CompiledMathHelper.java

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2002-2015 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.cypher.internal.compiler.v2_3.birk;
+
+import org.neo4j.cypher.internal.compiler.v2_3.CypherTypeException;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+/**
+ * This is a helper class used by compiled plans for doing basic math operations
+ */
+public final class CompiledMathHelper
+{
+    /**
+     * Do not instantiate this class
+     */
+    private CompiledMathHelper()
+    {
+    }
+
+    /**
+     * Utility function for doing addition
+     */
+    public static Object add( Object op1, Object op2 )
+    {
+        if ( op1 == null || op2 == null )
+        {
+            return null;
+        }
+
+        if ( op1 instanceof String || op2 instanceof String )
+        {
+            return String.valueOf( op1 ) + String.valueOf( op2 );
+        }
+
+        //array multiplication
+        Class<?> op1Class = op1.getClass();
+        Class<?> op2Class = op2.getClass();
+        if ( op1Class.isArray() && op2Class.isArray())
+        {
+            return addArrays( op1, op2 );
+        }
+        else if ( op1Class.isArray() )
+        {
+            return addArrayWithObject( op1, op2 );
+        }
+        else if ( op2Class.isArray() )
+        {
+            return addObjectWithArray( op1, op2 );
+        }
+
+
+        //From here down we assume we are dealing with numbers
+        if( !(op1 instanceof Number) || !(op2 instanceof Number) ){
+            throw new CypherTypeException( "Cannot add " + op1.getClass().getSimpleName() + " and " + op2.getClass()
+                    .getSimpleName(), null );
+        }
+
+        if ( op1 instanceof Long || op2 instanceof Long )
+        {
+            return ((Number) op1).longValue() + ((Number) op2).longValue();
+        }
+
+        if ( op1 instanceof Double || op2 instanceof Double )
+        {
+            return ((Number) op1).doubleValue() + ((Number) op2).doubleValue();
+        }
+
+        if ( op1 instanceof Float || op2 instanceof Float )
+        {
+            return ((Number) op1).floatValue() + ((Number) op2).floatValue();
+        }
+
+        if ( op1 instanceof Integer || op2 instanceof Integer )
+        {
+            return ((Number) op1).intValue() + ((Number) op2).intValue();
+        }
+
+
+        throw new CypherTypeException( "Cannot add " + op1.getClass().getSimpleName() + " and " + op2.getClass()
+            .getSimpleName(), null );
+    }
+
+    /**
+     * Both a1 and a2 must be arrays
+     */
+    private static Object addArrays( Object a1, Object a2 )
+    {
+        int l1 = Array.getLength( a1 );
+        int l2 = Array.getLength( a2 );
+        Object[] ret = new Object[l1 + l2];
+        for ( int i = 0; i < l1; i++ )
+        {
+            ret[i] = Array.get( a1, i );
+        }
+        for ( int i = 0; i < l2; i++ )
+        {
+            ret[l1 + i] = Array.get( a2, i );
+        }
+        return ret;
+    }
+
+    /**
+     * array must be an array
+     */
+    private static Object addArrayWithObject( Object array, Object object )
+    {
+        int l = Array.getLength( array );
+        Object[] ret = new Object[l + 1];
+        int i = 0;
+        for (; i < l; i++ )
+        {
+            ret[i] = Array.get( array, i );
+        }
+        ret[i] = object;
+
+        return ret;
+    }
+
+    /**
+     * array must be an array
+     */
+    private static Object addObjectWithArray( Object object, Object array )
+    {
+        int l = Array.getLength( array );
+        Object[] ret = new Object[l + 1];
+        ret[0] = object;
+        for (int i = 1; i < ret.length; i++ )
+        {
+            ret[i] = Array.get( array, i );
+        }
+
+        return ret;
+    }
+}

community/cypher/cypher-compiler-2.3/src/main/java/org/neo4j/cypher/internal/compiler/v2_3/birk/Javac.java

@@ -92,11 +92,11 @@ public static Class<InternalExecutionResult> compile( String className, String c
     }
 
     public static InternalExecutionResult newInstance( Class<InternalExecutionResult> clazz, Statement statement,
-                                                       GraphDatabaseService db, ExecutionMode executionMode, InternalPlanDescription description, HashMap<String, Object> params)
+                                                       GraphDatabaseService db, ExecutionMode executionMode, InternalPlanDescription description, Map<String, Object> params)
             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException
     {
         Constructor<InternalExecutionResult> constructor =
-                clazz.getDeclaredConstructor( Statement.class, GraphDatabaseService.class, ExecutionMode.class, InternalPlanDescription.class , HashMap.class);
+                clazz.getDeclaredConstructor( Statement.class, GraphDatabaseService.class, ExecutionMode.class, InternalPlanDescription.class , Map.class);
         return constructor.newInstance( statement, db, executionMode, description, params );
     }
 

community/cypher/cypher-compiler-2.3/src/main/scala/org/neo4j/cypher/internal/compiler/v2_3/birk/CodeGenerator.scala

@@ -25,8 +25,8 @@ import java.util.concurrent.atomic.AtomicInteger
 import org.neo4j.cypher.internal.ExecutionMode
 import org.neo4j.cypher.internal.compiler.v2_3.helpers.Eagerly
 import org.neo4j.cypher.internal.compiler.v2_3.{PropertyKeyId, CostPlannerName}
-import org.neo4j.cypher.internal.compiler.v2_3.ast.{Literal, Parameter, Identifier, Property}
-import org.neo4j.cypher.internal.compiler.v2_3.birk.CodeGenerator.JavaTypes.{INT, LONG, OBJECT}
+import org.neo4j.cypher.internal.compiler.v2_3.ast._
+import org.neo4j.cypher.internal.compiler.v2_3.birk.CodeGenerator.JavaTypes.{INT, LONG, OBJECT, DOUBLE, STRING}
 import org.neo4j.cypher.internal.compiler.v2_3.birk.il._
 import org.neo4j.cypher.internal.compiler.v2_3.executionplan.{PlanFingerprint, CompiledPlan}
 import org.neo4j.cypher.internal.compiler.v2_3.planDescription.InternalPlanDescription
@@ -80,6 +80,10 @@ object CodeGenerator {
     val LONG = "long"
     val INT = "int"
     val OBJECT = "Object"
+    val OBJECTARRAY = "Object[]"
+    val DOUBLE = "double"
+    val STRING = "String"
+    val NUMBER = "Number"
   }
 }
 
@@ -174,7 +178,7 @@ class CodeGenerator(semanticTable: SemanticTable) {
        |import org.neo4j.graphdb.Result;
        |import org.neo4j.cypher.internal.compiler.v2_3.planDescription.InternalPlanDescription;
        |import org.neo4j.cypher.internal.ExecutionMode;
-       |import java.util.HashMap;
+       |import java.util.Map;
        |
        |$imports
        |
@@ -184,9 +188,9 @@ class CodeGenerator(semanticTable: SemanticTable) {
        |private final GraphDatabaseService db;
        |private final InternalPlanDescription description;
        |private final ExecutionMode executionMode;
-       |private final HashMap<String, Object> params;
+       |private final Map<String, Object> params;
        |
-       |public $className( Statement statement, GraphDatabaseService db, ExecutionMode executionMode, InternalPlanDescription description, HashMap<String, Object> params )
+       |public $className( Statement statement, GraphDatabaseService db, ExecutionMode executionMode, InternalPlanDescription description, Map<String, Object> params )
        |{
        |  this.ro = statement.readOperations( );
        |  this.db = db;
@@ -300,43 +304,54 @@ class CodeGenerator(semanticTable: SemanticTable) {
           val (x, action) = consume(stack.top, plan, stack.pop)
           (x, WhileLoop(relVar, ExpandC(variables(fromNode).name, relVar.name, dir, relTypes.map(t => variableName.next -> t.name).toMap,nodeVar.name, action), Instruction.empty))
 
-        case Projection(left, expressions)  =>
-          val projectionInstructions =
-            expressions.map {
-            case (identifier, nodeOrRel@Identifier(name)) if semanticTable.isNode(nodeOrRel) || semanticTable.isRelationship(nodeOrRel) =>
-              //just project the new names
-              variables += identifier -> variables(name)
-              None
-
-            case (identifier, Property(node@Identifier(name), propKey)) if semanticTable.isNode(node) =>
-              val token = propKey.id(semanticTable).map(_.id)
-              val projection = ProjectNodeProperty(token, propKey.name, variables(name).name, variableName)
-              variables += identifier -> projection.projectedVariable
-              Some(projection)
-
-            case (identifier, Property(rel@Identifier(name), propKey)) if semanticTable.isRelationship(rel) =>
-              val token = propKey.id(semanticTable).map(_.id)
-              val projection = ProjectRelProperty(token, propKey.name, variables(name).name, variableName)
-              variables += identifier -> projection.projectedVariable
-              Some(projection)
-
-            case (identifier, Parameter(name)) =>
-              val projection = ProjectParameter(name)
-              variables += identifier -> projection.projectedVariable
-              Some(projection)
-            //TODO be smarter about boxing
-            case (identifier, lit: Literal) =>
-              val projection = ProjectLiteral(lit.value)
-              variables += identifier -> projection.projectedVariable
-              Some(projection)
-
-            case other => throw new CantCompileQueryException(s"Projections of $other not yet supported")
-
-          }.flatten.toSeq
+        case Projection(_, expressions)  =>
+          def findProjectionInstruction(expression: Expression): ProjectionInstruction = expression match {
+                case nodeOrRel@Identifier(name) if semanticTable.isNode(nodeOrRel) || semanticTable.isRelationship(nodeOrRel) =>
+                  ProjectNodeOrRelationship(variables(name))
+
+                case Property(node@Identifier(name), propKey) if semanticTable.isNode(node) =>
+                  val token = propKey.id(semanticTable).map(_.id)
+                  ProjectNodeProperty(token, propKey.name, variables(name).name, variableName)
+
+                case Property(rel@Identifier(name), propKey) if semanticTable.isRelationship(rel) =>
+                  val token = propKey.id(semanticTable).map(_.id)
+                  ProjectRelProperty(token, propKey.name, variables(name).name, variableName)
+
+                case Parameter(name) => ProjectParameter(name)
+
+                case lit: IntegerLiteral =>
+                  ProjectLiteral(JavaSymbol(s"${lit.value.toString}L", LONG))
+
+                case lit: DoubleLiteral =>
+                  ProjectLiteral(JavaSymbol(lit.value.toString, DOUBLE))
+
+                case lit: StringLiteral =>
+                  ProjectLiteral(JavaSymbol(s""""${lit.value}"""", STRING))
+
+                case lit: Literal =>
+                  ProjectLiteral(JavaSymbol(lit.value.toString, OBJECT))
+
+                case Collection(exprs) =>
+                  ProjectCollection(exprs.map(findProjectionInstruction))
+
+                case Add(lhs, rhs) =>
+                  val leftOp = findProjectionInstruction(lhs)
+                  val rightOp = findProjectionInstruction(rhs)
+                  ProjectAddition(leftOp, rightOp)
+
+                case other => throw new CantCompileQueryException(s"Projections of $other not yet supported")
+              }
+
+          val projectionInstructions = expressions.map {
+              case (identifier, expression) =>
+                val instruction = findProjectionInstruction(expression)
+                variables += identifier -> instruction.projectedVariable
+                instruction
+            }.toSeq
 
           val (x, action) = consume(stack.top, plan, stack.pop)
 
-          (x, ProjectNodeProperties(projectionInstructions, action))
+          (x, ProjectProperties(projectionInstructions, action))
 
         case _ => throw new CantCompileQueryException(s"$plan is not yet supported")
       }