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 });
}
