anchor.diff:              | Let(_) -> failwith "Invalid 'let' expression: bounded value must have a name"
               | _ -> unhandledExpr query
   
  +        impl cypher query
  +
  +    let private executeCreate (cypher: ICypherFluentQuery) createExpr: ICypherFluentQuery =
  +        match createExpr with
  +        | CreateNodeCall(ValueWithName(value, typ, name)) ->
  +             printfn "Create node: %s (type: %s - value: %A)" name typ.Name value
  +             // TODO denisok: extract constant
  +             let paramName = sprintf "__neo4jfsquot__%s" name
  +             let createExpr = sprintf "(%s:%s {%s})" name typ.Name paramName
  +             cypher.Create(createExpr)
  +                   .WithParam(paramName, value)
  +
  +        | _ -> unsupportedScenario "Create node" createExpr
  +
  +    let executeWriteQuery (cypher: ICypherFluentQuery) (query: Expr<unit>): unit =
  +        let rec impl cypher (query: Expr) =
  +            match query with
  +            | CreateNodeCall(_) as createExpr ->
  +                executeCreate cypher createExpr
  +                |> Cypher.executeWithoutResults
  +
  +            | Sequential(CreateNodeCall(_) as createExpr, rest) ->
  +                let newCypher = executeCreate cypher createExpr
  +                impl newCypher rest
  +
  +            | _ -> unhandledExpr query
  +
           impl cypher query
positive.code: 
          | _ -> unhandledExpr q
  
      let executeQuery (cypher: ICypherFluentQuery) (query: Expr<'T>): seq<'T> =
          let rec impl cypher (query: Expr) =
              match query with
              | Let(var, expr, rest) when var.Name.Length > 0 ->
  
negative.code:     let optionalMatchNode (_: #INeo4jNode) = ()
      let optionalMatchRelation (_: #INeo4jNode) (_: #INeo4jRelationship) (_: #INeo4jNode) = ()
      let where (_boolExpr: bool) = ()
  
      let createNode (_: 'TNode when 'TNode :> INeo4jNode) = ()
  
      let returnResults (_: 'T): 'T = Unchecked.defaultof<'T>
  
  [<AutoOpen>]
  