anchor.diff:                   .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
  
positive.code:             )
          )
  
      let inline private tryGenerateMatchNode (node: 'T) nodeName =
          tryFindNeo4jKey node
          |> Option.map (fun (keyName, keyValue) ->
              sprintf "(%s:%s {%s:'%O'})" nodeName typeof<'T>.Name keyName keyValue
          )
  
      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
          )
  
      let createNode (node: 'T) (query: ICypherFluentQuery) =
          let argName = "arg"
          let createText = sprintf "(node:%s {%s})" typeof<'T>.Name argName
          query.Create(createText)
               .WithParam(argName, node)
  
      // TODO denisok: enforce INeo4jRelationship
      let createNodeAndUniquelyRelateTo (sourceNode: NodeMatch<'TSourceKey>) (relationship: 'TRelationship) (targetNodeToCreate: 'TTargetNode) (query: ICypherFluentQuery) =
          let sourceNodeMatchExpr' = tryGenerateMatchExpr sourceNode "sourceNode"
          match sourceNodeMatchExpr' with
          | Some sourceNodeMatchExpr ->
  
negative.code: type Neo4jKeyAttribute() =
      inherit Attribute()
  
  [<NoComparison>]
  type internal NodeMatch<'TKey> = 
      { Key : 'TKey
        TypeInfo : Type }
      static member Create<'T>(key: 'TKey) =
  