anchor.diff:              printfn "MatchNode: %A (expr: %s)" nodeArg matchExpr
               executeMatch false (cypher.Match(matchExpr)) rest
   
  -        | Sequential(AnyMatchRelation(node1, rel, node2) as matchRel, rest) ->
  -            let relCypherExpr (r: Expr) =
  -                match r with
  -                | Var v -> sprintf "[%s:%s]" v.Name v.Type.Name
  -                | DeclareRelationshipCall typ -> sprintf "[:%s]" typ.Name
  -                | _ -> unhandledExpr r
  -
  -            let matchExpr =
  -                let formatter =
  -                    match matchRel with
  -                    | SpecificCall <@ matchRelation @> _ -> sprintf "%s-%s-%s"
  -                    | SpecificCall <@ matchRightRelation @> _ -> sprintf "%s-%s->%s"
  -                    | SpecificCall <@ matchLeftRelation @> _ -> sprintf "%s<-%s-%s"
  -                    | _ -> unhandledExpr matchRel
  -
  -                formatter (nodeCypherExpr node1) (relCypherExpr rel) (nodeCypherExpr node2)
  -
  -            printfn "MatchRelation: %s" matchExpr
  -            let newCypher = cypher.Match(matchExpr)
  -            executeMatch false newCypher rest
  +        | Sequential(IsMatchRelationClause(matchRel), rest) ->
  +            let matchExpr = matchRel.CypherExpr
  +            printfn "MatchRelation: %s"  matchExpr
  +            executeMatch false (cypher.Match(matchExpr)) rest
   
           | _ when not isFirstCall -> executeWhere cypher q
           | _ -> unhandledExpr q
  
positive.code:     type NodeExpr =
          | Var of var:Var
          | NamedValue of cypherExpr:string * paramName:string * value:obj
          member x.CypherExpr =
              match x with
              | Var(var) -> sprintf "(%s)" var.Name
              | NamedValue(cypherExpr, _, _) -> cypherExpr
          member x.Parameter =
              match x with
              | Var(_var) -> None
              | NamedValue(_, paramName, value) -> Some (paramName, value)
          member x.Create(cypher: ICypherFluentQuery) =
              match x with
              | Var(_var) -> cypher.Create(x.CypherExpr)
              | NamedValue(cypherExpr, paramName, value) ->
                  cypher.Create(cypherExpr).WithParam(paramName, value)
  
      [<RequireQualifiedAccess>]
      [<NoComparison>]
      type RelExpr =
          | NamedValue of name:string * typ:Type * value:obj
          | TypedPattern of cypherExpr:string
  
          static member GenParamName name = sprintf "__neo4jrel__%s" name
  
          member x.CypherExpr =
              match x with
              | NamedValue(name, typ, value) ->
                  sprintf "[%s:%s {%s}]" name typ.Name (RelExpr.GenParamName name)
              | TypedPattern(cypherExpr) -> cypherExpr
  
          member x.UnparameterizedCypherExpr =
              match x with
              | NamedValue(name,typ,_) -> sprintf "[%s:%s]" name typ.Name
              | TypedPattern(cypherExpr) -> cypherExpr
  
          member x.Parameter =
              match x with
              | NamedValue(name, typ, value) -> Some (RelExpr.GenParamName name, value)
              | TypedPattern _ -> None
  
          member x.Create(cypher: ICypherFluentQuery) =
              match x with
              | NamedValue(name, typ, value) ->
                  let paramName = RelExpr.GenParamName name
                  cypher.Create(x.CypherExpr).WithParam(paramName, value)
              | TypedPattern(cypherExpr) -> cypher.Create(cypherExpr)
  
      [<RequireQualifiedAccess>]
      [<NoComparison>]
      type CypherPattern =
          | LeftRel of leftNode:NodeExpr * rel:RelExpr * rightNode:NodeExpr * isUnique:bool
          | RightRel of leftNode:NodeExpr * rel:RelExpr * rightNode:NodeExpr * isUnique:bool
          | LeftOrRightRel of leftNode:NodeExpr * rel:RelExpr * rightNode:NodeExpr
          member x.CypherExprForCreate =
              match x with
              | LeftRel(lnode,rel,rnode,_) ->
                  sprintf "%s<-%s-%s" lnode.CypherExpr rel.CypherExpr rnode.CypherExpr
              | RightRel(lnode,rel,rnode,_) ->
                  sprintf "%s-%s->%s" lnode.CypherExpr rel.CypherExpr rnode.CypherExpr
              | LeftOrRightRel(lnode,rel,rnode) ->
                  sprintf "%s-%s-%s" lnode.CypherExpr rel.CypherExpr rnode.CypherExpr
  
          member x.CypherExprForMerge =
              match x with
              | LeftRel((NodeExpr.Var(_) as lnode), RelExpr.NamedValue(relName, relType, _), (NodeExpr.Var(_) as rnode),_) ->
                  sprintf "%s<-[%s:%s]-%s" lnode.CypherExpr relName relType.Name rnode.CypherExpr
              | RightRel((NodeExpr.Var(_) as lnode), RelExpr.NamedValue(relName, relType, _), (NodeExpr.Var(_) as rnode),_) ->
                  sprintf "%s-[%s:%s]->%s" lnode.CypherExpr relName relType.Name rnode.CypherExpr
              | _ -> failwith (sprintf "Invalid MERGE expression: %A" x)
  
          member x.Create(cypher: ICypherFluentQuery) =
              match x with
  
negative.code:             let paramName = sprintf "__neo4jnode__%s" name
              let cypherExpr = sprintf "(%s:%s {%s})" name typ.Name paramName
              Some (NodeExpr.NamedValue(cypherExpr, paramName, value))
          | DeclareNodeCall(nodeType) -> Some (NodeExpr.Anonymous(nodeType))
          | _ ->
              debug (string expr)
              None
  
      let inline (|IsRelExpr|_|) expr: Option<RelExpr> =
          match expr with
          | Var(var) -> Some (RelExpr.Var(var))
          | ValueWithName(value, typ, name) -> Some (RelExpr.NamedValue(name, typ, value))
          | DeclareRelationshipCall typ ->
              let cypherExpr = sprintf "[:%s]" typ.Name
              Some (RelExpr.TypedPattern(cypherExpr))
          | _ ->
              debug (string expr)
              None
  
      let inline (|CreateNodeCall|_|) (callExpr: Expr) =
          match callExpr with
  