Final cleanup

cypher/src/main/scala/org/neo4j/cypher/internal/ReattachAliasedExpressions.scala

@@ -20,7 +20,7 @@
 package org.neo4j.cypher.internal
 
 import commands._
-import expressions.{Entity, Expression}
+import expressions.{Identifier, Expression}
 
 
 /*
@@ -39,7 +39,7 @@ object ReattachAliasedExpressions {
   }
 
   private def expressionRewriter(returnColumns: Seq[ReturnColumn])(expression: Expression): Expression = expression match {
-    case e@Entity(entityName) =>
+    case e@Identifier(entityName) =>
       val returnItems = keepReturnItems(returnColumns)
       val found = returnItems.find(_.name == e.entityName)
 

cypher/src/main/scala/org/neo4j/cypher/internal/commands/ComparablePredicate.scala

@@ -45,7 +45,7 @@ abstract sealed class ComparablePredicate(left: Expression, right: Expression) e
   def containsIsNull = false
   def filter(f: (Expression) => Boolean): Seq[Expression] = left.filter(f) ++ right.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     left.assertTypes(symbols)
     right.assertTypes(symbols)
   }
@@ -62,7 +62,7 @@ case class Equals(a: Expression, b: Expression) extends Predicate with Comparer
   def rewrite(f: (Expression) => Expression) = Equals(a.rewrite(f), b.rewrite(f))
   def filter(f: (Expression) => Boolean): Seq[Expression] = a.filter(f) ++ b.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     a.assertTypes(symbols)
     b.assertTypes(symbols)
   }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/InIterable.scala

@@ -54,7 +54,7 @@ abstract class InIterable(collection: Expression, id: String, predicate: Predica
 
   def filter(f: (Expression) => Boolean): Seq[Expression] = collection.filter(f) ++ predicate.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     val innerType = collection.evaluateType(AnyIterableType(), symbols).iteratedType
     predicate.assertTypes(symbols.add(id, innerType))
   }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/MathFunction.scala

@@ -33,7 +33,7 @@ abstract class MathFunction(arg: Expression) extends Expression with NumericHelp
   else
     arg.filter(f)
 
-  def calculateType(symbols: SymbolTable2) = arg.evaluateType(NumberType(), symbols)
+  def calculateType(symbols: SymbolTable) = arg.evaluateType(NumberType(), symbols)
 
   def symbolTableDependencies = arg.symbolTableDependencies
 }
@@ -76,7 +76,7 @@ case class RangeFunction(start: Expression, end: Expression, step: Expression) e
 
   def rewrite(f: (Expression) => Expression) = f(RangeFunction(start.rewrite(f), end.rewrite(f), step.rewrite(f)))
 
-  def calculateType(symbols: SymbolTable2): CypherType = {
+  def calculateType(symbols: SymbolTable): CypherType = {
     start.evaluateType(NumberType(), symbols)
     end.evaluateType(NumberType(), symbols)
     step.evaluateType(NumberType(), symbols)

cypher/src/main/scala/org/neo4j/cypher/internal/commands/PathExpression.scala

@@ -33,7 +33,7 @@ case class PathExpression(pathPattern: Seq[Pattern])
   with PatternGraphBuilder {
   val identifiers: Seq[(String, CypherType)] = pathPattern.flatMap(pattern => pattern.possibleStartPoints.filterNot(p => p._1.startsWith("  UNNAMED")))
 
-  val symbols2 = new SymbolTable2(identifiers.toMap)
+  val symbols2 = new SymbolTable(identifiers.toMap)
   val matchingContext = new MatchingContext(symbols2, Seq(), buildPatternGraph(symbols2, pathPattern))
   val interestingPoints: Seq[String] = pathPattern.
     flatMap(_.possibleStartPoints.map(_._1)).
@@ -63,7 +63,7 @@ case class PathExpression(pathPattern: Seq[Pattern])
 
   def rewrite(f: (Expression) => Expression): Expression = f(PathExpression(pathPattern.map(_.rewrite(f))))
 
-  def calculateType(symbols: SymbolTable2): CypherType = {
+  def calculateType(symbols: SymbolTable): CypherType = {
     pathPattern.foreach(_.assertTypes(symbols))
     new IterableType( PathType() )
   }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/Pattern.scala

@@ -84,7 +84,7 @@ case class RelatedTo(left: String,
 
   def rels = Seq(relName)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     predicate.assertTypes(symbols)
   }
 
@@ -163,7 +163,7 @@ case class VarLengthRelatedTo(pathName: String,
 
   def rels = Seq()
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     predicate.assertTypes(symbols)
   }
 }
@@ -204,7 +204,7 @@ case class ShortestPath(pathName: String,
 
   def nodes = Seq(start,end)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     possibleStartPoints.foreach(p => symbols.evaluateType(p._1, p._2))
     predicate.assertTypes(symbols)
   }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/Predicate.scala

@@ -65,7 +65,7 @@ case class NullablePredicate(inner: Predicate, exp: Seq[(Expression, Boolean)])
 
   def filter(f: (Expression) => Boolean) = exp.flatMap { case (e,_) => e.filter(f)  }
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     inner.assertTypes(symbols)
   }
 
@@ -82,7 +82,7 @@ case class And(a: Predicate, b: Predicate) extends Predicate {
   def rewrite(f: (Expression) => Expression) = And(a.rewrite(f), b.rewrite(f))
   def filter(f: (Expression) => Boolean) = a.filter(f) ++ b.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     a.assertTypes(symbols)
     b.assertTypes(symbols)
   }
@@ -99,7 +99,7 @@ case class Or(a: Predicate, b: Predicate) extends Predicate {
   def rewrite(f: (Expression) => Expression) = Or(a.rewrite(f), b.rewrite(f))
   def filter(f: (Expression) => Boolean) = a.filter(f) ++ b.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     a.assertTypes(symbols)
     b.assertTypes(symbols)
   }
@@ -115,7 +115,7 @@ case class Not(a: Predicate) extends Predicate {
   def containsIsNull = a.containsIsNull
   def rewrite(f: (Expression) => Expression) = Not(a.rewrite(f))
   def filter(f: (Expression) => Boolean) = a.filter(f)
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     a.assertTypes(symbols)
   }
 
@@ -146,7 +146,7 @@ case class HasRelationshipTo(from: Expression, to: Expression, dir: Direction, r
   def rewrite(f: (Expression) => Expression) = HasRelationshipTo(from.rewrite(f), to.rewrite(f), dir, relType)
   def filter(f: (Expression) => Boolean) = from.filter(f) ++ to.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     from.assertTypes(symbols)
     to.assertTypes(symbols)
   }
@@ -173,7 +173,7 @@ case class HasRelationship(from: Expression, dir: Direction, relType: Seq[String
   def containsIsNull = false
   def filter(f: (Expression) => Boolean) = from.filter(f)
   def rewrite(f: (Expression) => Expression) = HasRelationship(from.rewrite(f), dir, relType)
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     from.assertTypes(symbols)
   }
 
@@ -188,7 +188,7 @@ case class IsNull(expression: Expression) extends Predicate {
   def containsIsNull = true
   def rewrite(f: (Expression) => Expression) = IsNull(expression.rewrite(f))
   def filter(f: (Expression) => Boolean) = expression.filter(f)
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     expression.assertTypes(symbols)
   }
   def symbolTableDependencies = expression.symbolTableDependencies
@@ -202,7 +202,7 @@ case class True() extends Predicate {
   def containsIsNull = false
   def rewrite(f: (Expression) => Expression) = True()
   def filter(f: (Expression) => Boolean) = Seq()
-  def assertTypes(symbols: SymbolTable2) {}
+  def assertTypes(symbols: SymbolTable) {}
   def symbolTableDependencies = Set()
 }
 
@@ -223,7 +223,7 @@ case class Has(property: Property) extends Predicate {
     case _ => throw new ThisShouldNotHappenError("Andres", "Something went wrong rewriting a Has(Property)")
   }
   def filter(f: (Expression) => Boolean) = property.filter(f)
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     property.assertTypes(symbols)
   }
 
@@ -243,7 +243,7 @@ case class LiteralRegularExpression(a: Expression, regex: Literal) extends Predi
   }
   def filter(f: (Expression) => Boolean) = a.filter(f) ++ regex.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     a.evaluateType(StringType(), symbols)
     regex.evaluateType(StringType(), symbols)
   }
@@ -269,7 +269,7 @@ case class RegularExpression(a: Expression, regex: Expression) extends Predicate
   }
   def filter(f: (Expression) => Boolean) = a.filter(f) ++ regex.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     a.evaluateType(StringType(), symbols)
     regex.evaluateType(StringType(), symbols)
   }
@@ -292,7 +292,7 @@ case class NonEmpty(collection:Expression) extends Predicate with IterableSuppor
   def rewrite(f: (Expression) => Expression) = NonEmpty(collection.rewrite(f))
   def filter(f: (Expression) => Boolean) = collection.filter(f)
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     collection.evaluateType(AnyIterableType(), symbols)
   }
 

cypher/src/main/scala/org/neo4j/cypher/internal/commands/ReturnItem.scala

@@ -19,27 +19,27 @@
  */
 package org.neo4j.cypher.internal.commands
 
-import expressions.{Entity, Expression}
+import expressions.{Identifier, Expression}
 import org.neo4j.cypher.internal.symbols._
 import collection.Map
 
 abstract class ReturnColumn {
-  def expressions(symbols: SymbolTable2): Map[String,Expression]
+  def expressions(symbols: SymbolTable): Map[String,Expression]
 
   def name: String
 }
 
 case class AllIdentifiers() extends ReturnColumn {
-  def expressions(symbols: SymbolTable2): Map[String, Expression] = symbols.identifiers.keys.
+  def expressions(symbols: SymbolTable): Map[String, Expression] = symbols.identifiers.keys.
     filterNot(_.startsWith("  UNNAMED")).
-    map(n => n -> Entity(n)).toMap
+    map(n => n -> Identifier(n)).toMap
 
   def name = "*"
 }
 
 case class ReturnItem(expression: Expression, name: String, renamed: Boolean = false)
   extends ReturnColumn {
-  def expressions(symbols: SymbolTable2) = Map(name -> expression)
+  def expressions(symbols: SymbolTable) = Map(name -> expression)
 
   override def toString = name
 

cypher/src/main/scala/org/neo4j/cypher/internal/commands/SortItem.scala

@@ -19,13 +19,13 @@
  */
 package org.neo4j.cypher.internal.commands
 
-import expressions.{CachedExpression, Entity, Expression}
+import expressions.{CachedExpression, Identifier, Expression}
 import java.lang.String
 import org.neo4j.helpers.ThisShouldNotHappenError
 
 case class SortItem(expression: Expression, ascending: Boolean) {
   def columnName : String = expression match {
-    case Entity(x) => x
+    case Identifier(x) => x
     case CachedExpression(x, _) => x
     case x => throw new ThisShouldNotHappenError("Andres", "ORDER BY should only work already computed values " + x.getClass)
   }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/StartItem.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.commands
 
-import expressions.{Entity, Literal, Expression}
+import expressions.{Identifier, Literal, Expression}
 import org.neo4j.cypher.internal.pipes.{QueryState, ExecutionContext}
 import org.neo4j.cypher.internal.mutation.{GraphElementPropertyFunctions, UpdateAction}
 import scala.Long
@@ -85,7 +85,7 @@ case class CreateNodeStartItem(key: String, props: Map[String, Expression])
 
   def rewrite(f: (Expression) => Expression): UpdateAction = CreateNodeStartItem(key, rewrite(props, f))
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     checkTypes(props, symbols)
   }
 
@@ -115,7 +115,7 @@ case class CreateRelationshipStartItem(key: String, from: (Expression, Map[Strin
 
   def identifier2 = Seq(key-> RelationshipType())
 
-  def assertTypes(symbols: SymbolTable2) {
+  def assertTypes(symbols: SymbolTable) {
     checkTypes(from._2, symbols)
     checkTypes(to._2, symbols)
     checkTypes(props, symbols)

cypher/src/main/scala/org/neo4j/cypher/internal/commands/expressions/Add.scala

@@ -46,7 +46,7 @@ case class Add(a: Expression, b: Expression) extends Expression {
   else
     a.filter(f) ++ b.filter(f)
 
-  def calculateType(symbols: SymbolTable2): CypherType = {
+  def calculateType(symbols: SymbolTable): CypherType = {
     val aT = a.getType(symbols)
     val bT = a.getType(symbols)
 

cypher/src/main/scala/org/neo4j/cypher/internal/commands/expressions/Avg.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.commands.expressions
 
-import org.neo4j.cypher.internal.symbols.{CypherType, SymbolTable2, NumberType}
+import org.neo4j.cypher.internal.symbols.{CypherType, SymbolTable, NumberType}
 import org.neo4j.cypher.internal.pipes.aggregation.AvgFunction
 
 case class Avg(anInner: Expression) extends AggregationWithInnerExpression(anInner) {
@@ -29,5 +29,5 @@ case class Avg(anInner: Expression) extends AggregationWithInnerExpression(anInn
 
   def rewrite(f: (Expression) => Expression) = f(Avg(anInner.rewrite(f)))
 
-  def calculateType(symbols: SymbolTable2): CypherType = NumberType()
+  def calculateType(symbols: SymbolTable): CypherType = NumberType()
 }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/expressions/CoalesceFunction.scala

@@ -41,7 +41,7 @@ case class CoalesceFunction(expressions: Expression*) extends Expression {
   else
     expressions.flatMap(_.filter(f))
 
-  def calculateType(symbols: SymbolTable2) = {
+  def calculateType(symbols: SymbolTable) = {
     expressions.map(_.getType(symbols)) match {
       case Seq() => ScalarType()
       case types => types.foldLeft(AnyType().asInstanceOf[CypherType])(_ mergeWith _)

cypher/src/main/scala/org/neo4j/cypher/internal/commands/expressions/Collect.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.commands.expressions
 
-import org.neo4j.cypher.internal.symbols.{SymbolTable2, AnyType, IterableType}
+import org.neo4j.cypher.internal.symbols.{SymbolTable, AnyType, IterableType}
 import org.neo4j.cypher.internal.pipes.aggregation.CollectFunction
 
 case class Collect(anInner: Expression) extends AggregationWithInnerExpression(anInner) {
@@ -29,5 +29,5 @@ case class Collect(anInner: Expression) extends AggregationWithInnerExpression(a
 
   def rewrite(f: (Expression) => Expression) = f(Collect(anInner.rewrite(f)))
 
-  def calculateType(symbols: SymbolTable2) = new IterableType(anInner.getType(symbols))
+  def calculateType(symbols: SymbolTable) = new IterableType(anInner.getType(symbols))
 }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/expressions/Collection.scala

@@ -32,7 +32,7 @@ case class Collection(expressions: Expression*) extends Expression {
   else
     expressions.flatMap(_.filter(f))
 
-  def calculateType(symbols: SymbolTable2): CypherType = {
+  def calculateType(symbols: SymbolTable): CypherType = {
     expressions.map(_.getType(symbols)) match {
 
       case Seq() => AnyIterableType()

cypher/src/main/scala/org/neo4j/cypher/internal/commands/expressions/Count.scala

@@ -29,5 +29,5 @@ case class Count(anInner: Expression) extends AggregationWithInnerExpression(anI
 
   def rewrite(f: (Expression) => Expression) = f(Count(anInner.rewrite(f)))
 
-  def calculateType(symbols: SymbolTable2): CypherType = LongType()
+  def calculateType(symbols: SymbolTable): CypherType = LongType()
 }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/expressions/CountStar.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.commands.expressions
 
-import org.neo4j.cypher.internal.symbols.{SymbolTable2, CypherType, LongType}
+import org.neo4j.cypher.internal.symbols.{SymbolTable, CypherType, LongType}
 import org.neo4j.cypher.internal.pipes.aggregation.CountStarFunction
 
 case class CountStar() extends AggregationExpression {
@@ -32,7 +32,7 @@ case class CountStar() extends AggregationExpression {
   else
     Seq()
 
-  def calculateType(symbols: SymbolTable2): CypherType = LongType()
+  def calculateType(symbols: SymbolTable): CypherType = LongType()
 
   def symbolTableDependencies = Set()
 }

cypher/src/main/scala/org/neo4j/cypher/internal/commands/expressions/Distinct.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.commands.expressions
 
-import org.neo4j.cypher.internal.symbols.{SymbolTable2, CypherType, AnyType}
+import org.neo4j.cypher.internal.symbols.{SymbolTable, CypherType, AnyType}
 import org.neo4j.cypher.internal.pipes.aggregation.DistinctFunction
 
 case class Distinct(innerAggregator: AggregationExpression, expression: Expression) extends AggregationWithInnerExpression(expression) {
@@ -32,7 +32,7 @@ case class Distinct(innerAggregator: AggregationExpression, expression: Expressi
     case _                            => f(Distinct(innerAggregator, expression.rewrite(f)))
   }
 
-  def calculateType(symbols: SymbolTable2): CypherType = innerAggregator.getType(symbols)
+  def calculateType(symbols: SymbolTable): CypherType = innerAggregator.getType(symbols)
 
   override def symbolTableDependencies = innerAggregator.symbolTableDependencies ++ expression.symbolTableDependencies
 }