anchor.diff:              neededVariables
               |> List.map (
                   fun var ->
  -                    var, source |>SqlSource.getColumn var |> Column
  +                    var, source |> SqlSource.getColumn var |> Column
               )
               |> Map.ofList
   
  
positive.code:                     None
                  
              mayBeUsableSource
              |> Option.defaultWith (fun () ->
                  {
                      Schema = schema
                      Columns =
                          schema.Columns
                          |> Seq.toList
                          |> List.map (fun col -> { Schema = schema.GetColumn(col) })
                  }
              )
  
          | Statement _ -> "SQL Statements are not yet supported" |> NotImplementedException |> raise
          |> fun x ->
              let updatedSources = sqlSources |> Map.tryFind pattern |> Option.defaultValue List.empty |> fun xs -> x :: xs
              x, sqlSources |> Map.add pattern updatedSources
  
      let applyPatternMatch filters (valueBindings: Map<_,_>) source pattern mapping =
          let variables =
  
negative.code:             }
  
  let private expressionSetValuesEqualCondition left right =
      let isTypeEqual =
          Comparison(Comparisons.EqualTo, left.TypeExpression, right.TypeExpression)
          |> optimizeRelationalCondition
  
      let notIsValueInCategory category =
          Comparison(Comparisons.EqualTo, left.TypeCategoryExpression, category |> int |> Int |> Constant)
          |> optimizeRelationalCondition
          |> Not
          |> optimizeRelationalCondition
  
      let notIsValueNumeric = notIsValueInCategory TypeIndexer.TypeCategory.NumericLiteral
      let notIsValueBoolean = notIsValueInCategory TypeIndexer.TypeCategory.BooleanLiteral
      let notIsValueDateTime = notIsValueInCategory TypeIndexer.TypeCategory.DateTimeLiteral
      let notIsValueString =
          [
              notIsValueInCategory TypeIndexer.TypeCategory.BlankNode
              notIsValueInCategory TypeIndexer.TypeCategory.Iri
              notIsValueInCategory TypeIndexer.TypeCategory.StringLiteral
              notIsValueInCategory TypeIndexer.TypeCategory.SimpleLiteral
              notIsValueInCategory TypeIndexer.TypeCategory.OtherLiteral
          ]
          |> Conjunction |> optimizeRelationalCondition
  
      let expressionEqual selector =
          Comparison(Comparisons.EqualTo, left |> selector, right |> selector)
          |> optimizeRelationalCondition
  
      [
          isTypeEqual
          [ notIsValueString; expressionEqual (fun x -> x.StringExpression) ] |> Disjunction |> optimizeRelationalCondition
          [ notIsValueNumeric; expressionEqual (fun x -> x.NumericExpression) ] |> Disjunction |> optimizeRelationalCondition
          [ notIsValueBoolean; expressionEqual (fun x -> x.BooleanExpression) ] |> Disjunction |> optimizeRelationalCondition
          [ notIsValueDateTime; expressionEqual (fun x -> x.DateTimeExpresion) ] |> Disjunction |> optimizeRelationalCondition
      ]
      |> Conjunction
      |> optimizeRelationalCondition
  
  let private valueBinderValueEqualToNodeCondition typeIndexer valueBinder node =
      (valueBinder |> valueBinderToExpressionSet typeIndexer, node |> nodeToExpressionSet typeIndexer)
  