anchor.diff:  type Neo4jKeyAttribute() =
       inherit Attribute()
   
  -type NodeMatch<'TKey> = 
  +[<NoComparison>]
  +type internal NodeMatch<'TKey> = 
       { Key : 'TKey
         TypeInfo : Type }
       static member Create<'T>(key: 'TKey) =
  
positive.code:                  .Set(setText)
                   .WithParam(argName, node)
          | None -> raiseNeo4jNodeTypeException<'T>()
  
      let inline matchNodes<'T> (query: ICypherFluentQuery) =
          query.Match(sprintf "(node:%s)" typeof<'T>.Name)
  
      let inline returnNodes<'T> (query: ICypherFluentQuery) =
          <@ Func<_, _>(fun (node: ICypherResultItem) -> node.As<'T>()) @>
          |> QuotationToLambdaExpression
          |> query.Return
  
      let inline getNodes<'T> (query: ICypherFluentQuery) =
          query
          |> matchNodes<'T>
          |> returnNodes<'T>
  
      let inline executeWithoutResults (query: ICypherFluentQuery) =
          query.ExecuteWithoutResults()
  
      let inline asyncExecuteWithoutResults (query: ICypherFluentQuery) =
          query.ExecuteWithoutResultsAsync()
          |> Async.AwaitTask
  
      let inline getResults (query: ICypherFluentQuery<'T>) = query.Results
      let inline getResultsAsync (query: ICypherFluentQuery<'T>) = Async.AwaitTask query.ResultsAsync
  
negative.code:             )
          )
  
      let inline private tryGenerateMatchExpr (data: NodeMatch<'TKey>) nodeName =
          tryGetNeo4jKeyName data.TypeInfo
          |> Option.map (fun keyName ->
              sprintf "%s:%s {%s:'%O'}" nodeName data.TypeInfo.Name keyName data.Key
          )
  
      // TODO denisok: enforce INeo4jRelationship
      let internal createNodeAndUniquelyRelateTo (sourceNode: NodeMatch<'TSourceKey>) (relationship: 'TRelationship) (targetNodeToCreate: 'TTargetNode) (query: ICypherFluentQuery) =
          let sourceNodeMatchExpr' = tryGenerateMatchExpr sourceNode "sourceNode"
          match sourceNodeMatchExpr' with
          | Some sourceNodeMatchExpr ->
  