anchor.diff:                  let v = Expression.Lambda<Func<obj>>(unaryExpr).Compile()
                   literalToSql (v.Invoke ()) curParams
               |"RuntimePropertyInfo" -> false, body.Member.Name, None
  -            |_ as name -> sprintf "unsupported member type name %s" name |> failwith    
  -        | _ -> sprintf "unsupported nodetype %A" body|> failwith    
  +            |_ as name -> failwithf "unsupported member type name %s" name   
  +        | _ -> failwithf "unsupported nodetype %A" body   
   
       let leafExpression (body:BinaryExpression) sqlOperator curParams =
           let _, lVal, lParam = constantOrMemberAccessValue body.Left curParams
  
positive.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
              | _ -> sprintf "not condition has unexpected type %A" body |> failwith
          | :? MemberExpression as body when body.NodeType = ExpressionType.MemberAccess && body.Type = typeof<System.Boolean> ->
              boolValueToWhereClause body curSqlParams true
          | :? BinaryExpression as body -> 
  
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
  