anchor.diff:                              let sql = sql |> sqlInBracketsIfNeeded parentJunction junctionSql
                               sql, parms
                           | None, Some sqlOper -> leafExpression expr sqlOper curSqlParams
  -                        | _ -> "expression is not a junction and not a supported leaf" |> failwith
  +                        | _ -> failwith "expression is not a junction and not a supported leaf"
                       | _ -> comparisonToWhereClause expr parentJunction curSqlParams
   
                   let lSql, curSqlParams = consumeExpr body.Left curSqlParams
  
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:         | :? UnaryExpression as body when body.NodeType = ExpressionType.Not && body.Type = typeof<System.Boolean> ->
              match body.Operand with
              | :? MemberExpression as body -> boolValueToWhereClause body curSqlParams false
              | _ -> 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 -> 
  