anchor.diff:  
               | None -> 
                   match binExpToSqlOper body with
  -                | Some sqlOper -> leafExpression quote body sqlOper curSqlParams
  +                | Some sqlOper -> leafExpression quote nameExtractor body sqlOper curSqlParams
                   | None -> failwithf "unsupported operator %A in leaf" body.NodeType
           | _ -> failwithf "conditions has unexpected type %A" body
   
  
positive.code:         let call = linq :?> MethodCallExpression
          let lambda = call.Arguments.[0] :?> LambdaExpression
          Expression.Lambda<Func<'T, bool>>(lambda.Body, lambda.Parameters)
          
  type ExpressionToSql = 
      static member Translate<'T>(quoter, conditions:Expression<Func<'T, bool>>, includeWhere) =
          let sql, parms = Translator.comparisonToWhereClause quoter conditions.Body None List.empty
          let where = if includeWhere then "WHERE " else ""
          new Tuple<_,_>(where + sql, parms |> List.rev |> Array.ofList)
  
      static member Translate(quoter:Translator.IQuoter, conditions:Quotations.Expr<(_ -> bool)>, includeWhere) = 
          ExpressionToSql.Translate(quoter, LinqHelpers.conv conditions, includeWhere)
                  
      static member Translate(quoter:Translator.IQuoter,conditions) = 
          ExpressionToSql.Translate(quoter, LinqHelpers.conv conditions, true)
  
      static member Translate(quoter:Translator.IQuoter,conditions:Expression<Func<'T, bool>>) = 
          ExpressionToSql.Translate(quoter, conditions, true)
  
negative.code:                     | :? BinaryExpression as expr ->
                          match junctionToSqlOper expr, binExpToSqlOper expr with
                          | Some _, None -> 
                              let sql, parms = comparisonToWhereClause quote nameExtractor expr (Some junctionSql) curSqlParams
                              let sql = sql |> sqlInBracketsIfNeeded parentJunction junctionSql
                              sql, parms
                          | None, Some sqlOper -> leafExpression quote nameExtractor expr sqlOper curSqlParams
                          | _ -> failwith "expression is not a junction and not a supported leaf"
                      | _ -> comparisonToWhereClause quote nameExtractor expr parentJunction curSqlParams
  
                  let lSql, curSqlParams = consumeExpr body.Left curSqlParams
                  let rSql, curSqlParams = consumeExpr body.Right curSqlParams
  