Extract useful info from cypher delete construct and add as fields of lynxDelete

lynx/src/main/scala/org/grapheco/lynx/ExecutionPlanCreator.scala

@@ -175,8 +175,8 @@ class ExecutionPlanCreator {
         DeleteOperator(
           translate(delete.in, plannerContext, executionContext),
           plannerContext.runnerContext.graphModel,
-          delete.delete.expressions,
-          delete.delete.forced,
+          delete.deleteExpr,
+          delete.forceToDelete,
           plannerContext.runnerContext.expressionEvaluator,
           executionContext.expressionContext
         )

lynx/src/main/scala/org/grapheco/lynx/logical/LogicalDelete.scala

@@ -11,11 +11,12 @@
 
 package org.grapheco.lynx.logical
 
-import org.opencypher.v9_0.ast.Delete
+import org.opencypher.v9_0.expressions.Expression
 
 /**
   *@description:
   */
-case class LogicalDelete(delete: Delete)(val in: LogicalNode) extends LogicalNode {
+case class LogicalDelete(deleteExpr: Seq[Expression], forceToDelete: Boolean)(val in: LogicalNode)
+  extends LogicalNode {
   override val children: Seq[LogicalNode] = Seq(in)
 }

lynx/src/main/scala/org/grapheco/lynx/logical/translator/LogicalDeleteTranslator.scala

@@ -11,6 +11,7 @@
 
 package org.grapheco.lynx.logical.translator
 
+import org.grapheco.lynx.expression.utils.ConvertExpressionToLynxExpression
 import org.grapheco.lynx.logical.plan.LogicalPlannerContext
 import org.grapheco.lynx.logical.{LogicalDelete, LogicalNode}
 import org.opencypher.v9_0.ast.Delete
@@ -23,5 +24,8 @@ case class LogicalDeleteTranslator(delete: Delete) extends LogicalNodeTranslator
       in: Option[LogicalNode]
     )(implicit plannerContext: LogicalPlannerContext
     ): LogicalNode =
-    LogicalDelete(delete)(in.get)
+    LogicalDelete(
+      delete.expressions.map(expr => ConvertExpressionToLynxExpression.convert(expr)),
+      delete.forced
+    )(in.get)
 }

lynx/src/main/scala/org/grapheco/lynx/physical/PhysicalDelete.scala

@@ -16,7 +16,7 @@ import org.grapheco.lynx.{DataFrame, ExecutionContext, LynxType, SyntaxErrorExce
 import org.grapheco.lynx.types.LynxValue
 import org.grapheco.lynx.types.property.LynxNull
 import org.grapheco.lynx.types.structural.{LynxNode, LynxRelationship}
-import org.opencypher.v9_0.ast.Delete
+import org.opencypher.v9_0.expressions.Expression
 import org.opencypher.v9_0.util.symbols.{CTNode, CTPath, CTRelationship}
 
 /** The DELETE clause is used to delete graph elements — nodes, relationships or paths.
@@ -25,27 +25,28 @@ import org.opencypher.v9_0.util.symbols.{CTNode, CTPath, CTRelationship}
   * @param plannerContext
   */
 case class PhysicalDelete(
-    delete: Delete
+    deleteExpr: Seq[Expression],
+    forceToDelete: Boolean
   )(implicit val in: PhysicalNode,
     val plannerContext: PhysicalPlannerContext)
   extends AbstractPhysicalNode {
   override val children: Seq[PhysicalNode] = Seq(in)
 
   override def withChildren(children0: Seq[PhysicalNode]): PhysicalDelete =
-    PhysicalDelete(delete)(children0.head, plannerContext)
+    PhysicalDelete(deleteExpr, forceToDelete)(children0.head, plannerContext)
 
   override val schema: Seq[(String, LynxType)] = Seq.empty
 
   override def execute(implicit ctx: ExecutionContext): DataFrame = { // TODO so many bugs !
     val df = in.execute(ctx)
-    delete.expressions foreach { exp =>
+    deleteExpr.foreach { exp =>
       val projected = df.project(Seq(("delete", exp)))(ctx.expressionContext)
       val (_, elementType) = projected.schema.head
       elementType match {
         case CTNode =>
           graphModel.deleteNodesSafely(
             dropNull(projected.records) map { _.asInstanceOf[LynxNode].id },
-            delete.forced
+            forceToDelete
           )
         case CTRelationship =>
           graphModel.deleteRelations(dropNull(projected.records) map {

lynx/src/main/scala/org/grapheco/lynx/physical/plan/DefaultPhysicalPlanner.scala

@@ -44,7 +44,8 @@ class DefaultPhysicalPlanner(runnerContext: QueryRunnerContext) extends Physical
         PhysicalMergeTranslator(m).translate(lm.in.map(plan(_)))(plannerContext)
       case lm @ LogicalMergeAction(m: Seq[MergeAction]) =>
         PhysicalMergeAction(m)(plan(lm.in.get), plannerContext)
-      case ld @ LogicalDelete(d: Delete) => PhysicalDelete(d)(plan(ld.in), plannerContext)
+      case ld @ LogicalDelete(deleteExpr: Seq[Expression], forceToDelete: Boolean) =>
+        PhysicalDelete(deleteExpr, forceToDelete)(plan(ld.in), plannerContext)
       case ls @ LogicalSelect(columns: Seq[(String, Option[String])]) =>
         PhysicalSelect(columns)(plan(ls.in), plannerContext)
       case lp @ LogicalProject(ri)       => PhysicalProject(ri)(plan(lp.in), plannerContext)