anchor.diff:  
               printfn "MatchRelation: %s" matchExpr
               let newCypher = cypher.Match(matchExpr)
  -            executeRest newCypher rest
  +            executeWhere newCypher rest
   
           | _ -> unhandledExpr q
   
  
positive.code:     let inline (|DeleteNodeCall|_|) (callExpr: Expr) =
          match callExpr with
          | SpecificCall <@ deleteNode @> (_, _, [node]) -> Some node
          | _ -> None
  
      let inline (|MatchNodeCall|_|) (callExpr: Expr) =
  
negative.code:     let private executeDelete (cypher: ICypherFluentQuery) deleteExpr =
          match deleteExpr with
          | DeleteNodeCall(Var(node)) ->
              printfn "Delete node: %s (type: %s)" node.Name node.Type.Name
              cypher.Delete(node.Name)
          | DeleteRelationshipCall(Var(rel)) ->
              printfn "Delete relationship: %s (type: %s)" rel.Name rel.Type.Name
              cypher.Delete(rel.Name)
          | _ -> unsupportedScenario "Delete node" deleteExpr
  
      let private executeWhere<'T> (cypher: ICypherFluentQuery) (whereExpr: Expr): InterpreterResult<'T> =
          let executeNextExpr context cypher next =
              match next with
              | ReturnResultsCall(returnExpr) -> executeReturn cypher returnExpr
              | CreateNodeCall _
              | CreateRelationCall _ -> Choice1Of2 (executeCreate cypher next)
              | DeleteNodeCall _
              | DeleteRelationshipCall _ -> Choice1Of2 (executeDelete cypher next)
              | _ -> unexpectedExpr context next
          let context = "After WHERE expression"
              
          match whereExpr with
          | Sequential(expr, next) ->
              let cypher =
                  match expr with
                  | WhereCall(BinaryExpr(op, arg1, arg2)) ->
                      let formattedArg1 = getOperand arg1
                      let formattedArg2 = getOperand arg2
                      let whereExpr = sprintf "%s %s %s" formattedArg1 op formattedArg2
                      printfn "Where %s" whereExpr
                      cypher.Where(whereExpr)
                  | _ -> cypher
  
              executeNextExpr context cypher next
          | _ -> executeNextExpr context cypher whereExpr
  
      let rec private executeMatch<'T> (cypher: ICypherFluentQuery) (q: Expr): InterpreterResult<'T> =
          let nodeCypherExpr (n: Expr) =
              match n with
              | Var v -> sprintf "(%O:%s)" v.Name v.Type.Name
  