public void ToSqlRuleContainsifCond() { string[] nombres = null; Expression <Func <Cliente, bool> > selectBody = x => SqlExpr.IfCond.Invoke(nombres.Any(), nombres.Contains(x.Nombre)); var pars = new SqlExprParams(selectBody.Parameters[0], null, false, "cli", new SqlFromList.ExprStrRawSql[0], ParamMode.None, new SqlParamDic()); var visitor = new SqlRewriteVisitor(pars); { nombres = new[] { "rafa", "hola" }; var ret = visitor.Visit(selectBody); var rawBody = ((MethodCallExpression)((LambdaExpression)ret).Body).Arguments[0]; ExprEval.TryEvalExpr <string>(rawBody, out var rawStr); var expected = "(\"cli\".\"Nombre\" IN ('rafa', 'hola'))"; Assert.AreEqual(expected, rawStr); } { nombres = new string[0]; var ret = visitor.Visit(selectBody); var rawBody = ((MethodCallExpression)((LambdaExpression)ret).Body).Arguments[0]; ExprEval.TryEvalExpr <string>(rawBody, out var rawStr); var expected = "True"; Assert.AreEqual(expected, rawStr); } }
public void ToSqlRuleContains() { var nombres = new[] { "rafa", "hola" }; Expression <Func <Cliente, string[]> > selectBody = x => Sql.Record(nombres); var pars = new SqlExprParams(selectBody.Parameters[0], null, false, "cli", new SqlFromList.ExprStrRawSql[0], ParamMode.None, new SqlParamDic()); var rules = SqlFunctions.AtomRawRule(pars) .Concat( SqlFunctions.ExprParamsRules(pars) ) .Concat(new[] { DefaultRewrite.StringFormat }) .Concat(SqlFunctions.stringCalls) .Concat(SqlFunctions.sqlCalls) .Concat(SqlFunctions.rawAtom) .ToList(); var ret = ApplyRules(selectBody, rules); var rawBody = ((MethodCallExpression)((LambdaExpression)ret).Body).Arguments[0]; ExprEval.TryEvalExpr <string>(rawBody, out var rawStr); var expected = "('rafa', 'hola')"; Assert.AreEqual(expected, rawStr); }
public void ToSqlRule3() { Expression <Func <Cliente, bool> > selectBody = x => x.Nombre.Contains("Hola"); var pars = new SqlExprParams(selectBody.Parameters[0], null, false, "cli", new SqlFromList.ExprStrRawSql[0], ParamMode.None, new SqlParamDic()); var rules = SqlFunctions.rawAtom.Concat( SqlFunctions.ExprParamsRules(pars) ) .Concat(new[] { DefaultRewrite.StringFormat }) .Concat(SqlFunctions.stringCalls) .Concat(SqlFunctions.AtomRawRule(pars)) .ToList(); var ret = ApplyRules(selectBody, rules); var rawBody = ((MethodCallExpression)((LambdaExpression)ret).Body).Arguments[0]; ExprEval.TryEvalExpr <string>(rawBody, out var rawStr); var expected = "(\"cli\".\"Nombre\" LIKE '%' || 'Hola' || '%')"; Assert.AreEqual(expected, rawStr); }
public void ToSqlStringConcat() { Expression <Func <Uruz.Factura, string> > nombreFactura = x => x.Serie + "-" + x.Folio; Expression <Func <Uruz.Factura, string> > selectBody = x => nombreFactura.Invoke(x); var pars = new SqlExprParams(selectBody.Parameters[0], null, false, "cli", new SqlFromList.ExprStrRawSql[0], ParamMode.None, new SqlParamDic()); var visitor = new SqlRewriteVisitor(pars); var ret = visitor.Visit(selectBody); var rawBody = ((MethodCallExpression)((LambdaExpression)ret).Body).Arguments[0]; ExprEval.TryEvalExpr <string>(rawBody, out var rawStr); var expected = @"((""cli"".""Serie"" || '-') || ""cli"".""Folio"")"; Assert.AreEqual(expected, rawStr); }
public void ToSqlRuleContainsEmpty() { var nombres = new string[0]; Expression <Func <Cliente, bool> > selectBody = x => nombres.Contains(x.Nombre); var pars = new SqlExprParams(selectBody.Parameters[0], null, false, "cli", new SqlFromList.ExprStrRawSql[0], ParamMode.None, new SqlParamDic()); var visitor = new SqlRewriteVisitor(pars); { nombres = new string[0]; var ret = visitor.Visit(selectBody); var rawBody = ((MethodCallExpression)((LambdaExpression)ret).Body).Arguments[0]; ExprEval.TryEvalExpr <string>(rawBody, out var rawStr); var expected = "False"; Assert.AreEqual(expected, rawStr); } }
public void CompareToTest() { Expression <Func <Cliente, bool> > select = (cli) => cli.Nombre.CompareTo(cli.Apellido) >= 0; var pars = new SqlExprParams(select.Parameters[0], null, false, "cli", new SqlFromList.ExprStrRawSql[0], ParamMode.None, new SqlParamDic()); var rules = SqlFunctions.rawAtom.Concat( SqlOperators.compareTo ) .Concat( SqlFunctions.AtomRawRule(pars) ) ; var ret = (LambdaExpression)ApplyRules(select, rules); var raw = ExprEval.EvalExpr <string>(((MethodCallExpression)ret.Body).Arguments[0]).Value; var expected = "(\"cli\".\"Nombre\" >= \"cli\".\"Apellido\")"; Assert.AreEqual(expected, raw); }
public void EvalBooleanRule() { //Evalua las expresiones booleanas, sólo se aplica la regla si la expresión no es ya una constante var evalBool = RewriteRule.Create("", (bool x) => RewriteSpecial.NotConstant(x), null, null, (_, x, visit) => ExprEval.EvalExprExpr(x)); var rules = new[] { evalBool }; var a = true; Expression <Func <bool, bool, bool> > expr = (x, y) => x && y || !(true || a); var red = ApplyRules(expr, rules); //Note que la expresión !(true || a) se evaluó por completo: Assert.AreEqual("(x, y) => ((x AndAlso y) OrElse False)", red.ToString()); }
/// <summary> /// La regla que se aplica a las llamadas Atom(Raw(x)), lo que hace es convertir las llamadas ToSql del Atom(Raw(x)) /// </summary> public static IEnumerable <RewriteRule> AtomRawRule(SqlExprParams pars) { var deferredToSqlRule = RewriteRule.Create( "deferredToSql", (RewriteTypes.C1 x) => SqlFunctions.ToSql <RewriteTypes.C1>(x), null, null, (match, expr, visit) => Expression.Call( typeof(SqlExpression), nameof(SqlExpression.ExprToSql), new Type[0], Expression.Constant(match.Args[0]), Expression.Constant(pars), Expression.Constant(true))); var toSqlRule = RewriteRule.Create( "toSql", () => RewriteSpecial.Call <string>(typeof(SqlFunctions), nameof(ToSql)), null, null, (match, expr, visit) => Expression.Constant(SqlExpression.ExprToSql(((MethodCallExpression)expr).Arguments[0], pars, true))); var toSelectBodySqlRule = RewriteRule.Create( "toSelectBodySqlRule", () => RewriteSpecial.Call <string>(typeof(SqlFunctions), nameof(ToSelectBodySql)), null, null, (match, expr, visit) => Expression.Constant( SqlSelect.SelectExprToStr(SqlSelect.SelectBodyToStr(((MethodCallExpression)expr).Arguments[0], pars).Values) ) ); var windowToSqlRule = RewriteRule.Create( "windowToSql", (ISqlWindow a) => WindowToSql(a), null, null, (match, expr, visit) => Expression.Constant(SqlCalls.WindowToSql(match.Args[0])) ); var toSqlRules = new[] { toSelectBodySqlRule, toSqlRule, windowToSqlRule }; Func <Expression, Expression> applySqlRule = (Expression ex) => new RewriteVisitor(toSqlRules, ExcludeFromRewrite).Visit(ex); var atomRawRule = RewriteRule.Create( "executeAtomRaw", (string x) => RewriteSpecial.Atom(Sql.Raw <RewriteTypes.C1>(RewriteSpecial.NotConstant(x))), null, null, (match, expr, visit) => { var arg = match.Args[0]; var applySql = applySqlRule(arg); if (applySql == arg) { return(expr); } var type = match.Types[typeof(RewriteTypes.C1)]; var value = ExprEval.EvalExpr <string>(applySql).Value; var ret = Expression.Call(typeof(RewriteSpecial), nameof(RewriteSpecial.Atom), new[] { type }, Expression.Call(typeof(Sql), nameof(Sql.Raw), new[] { type }, Expression.Constant(value)) ); return(ret); }); return(new[] { atomRawRule }); }