anchor.diff:          | :? UnaryExpression as body when body.NodeType = ExpressionType.Not && body.Type = typeof<System.Boolean> ->
               match body.Operand with
               | :? MemberExpression as body -> boolValueToWhereClause body curSqlParams false
  -            | _ -> sprintf "not condition has unexpected type %A" body |> failwith
  +            | _ -> failwithf "not condition has unexpected type %A" body
           | :? MemberExpression as body when body.NodeType = ExpressionType.MemberAccess && body.Type = typeof<System.Boolean> ->
               boolValueToWhereClause body curSqlParams true
           | :? BinaryExpression as body -> 
  
positive.code:             | None -> 
                  match binExpToSqlOper body with
                  | Some sqlOper -> leafExpression body sqlOper curSqlParams
                  | None -> sprintf "unsupported operator %A in leaf" body.NodeType |> failwith
          | _ -> sprintf "conditions has unexpected type %A" body |> failwith
  
  type ExpressionToSql = 
      static member Translate<'T> (conditions:Expression<Func<'T, bool>>) =
  
negative.code:                             let sql = sql |> sqlInBracketsIfNeeded parentJunction junctionSql
                              sql, parms
                          | None, Some sqlOper -> leafExpression expr sqlOper curSqlParams
                          | _ -> failwith "expression is not a junction and not a supported leaf"
                      | _ -> comparisonToWhereClause expr parentJunction curSqlParams
  
                  let lSql, curSqlParams = consumeExpr body.Left curSqlParams
  