static (IReadOnlyList <SqlSubpath> sql, bool star) MemberToSql(MemberExpression mem, SqlExprParams pars) { //Si es un parametro: if (AddParam(mem, pars.ParamDic) is var param && param != null) { return(SqlSubpath.FromString(ParamToSql(param, pars.ParamMode)), false); } //Si el tipo es un complex type: var subpaths = SubPaths(mem.Type); string memberName = mem.Member.Name; if (Sql2Sql.Mapper.PathAccessor.IsComplexType(mem.Expression.Type) && mem.Expression is MemberExpression) { var complexName = new List <string>(); MemberExpression curr = mem; complexName.Add(mem.Member.Name); while (Sql2Sql.Mapper.PathAccessor.IsComplexType(curr.Expression.Type) && curr.Expression is MemberExpression m2) { curr = m2; complexName.Add(curr.Member.Name); } complexName.Reverse(); var name = string.Join("_", complexName); mem = curr; memberName = name; } //Miembros de string: if (mem.Expression.Type == typeof(string)) { throw new ArgumentException($"No se pudo convertir a SQL el miembro de 'string' '{mem.Member.Name}'"); } //Estrella: if (pars.FromListNamed && IsFromParam(mem.Expression)) { return(SqlSubpath.FromString($"\"{mem.Member.Name}\".*"), true); } var items = subpaths.Select(x => new SqlSubpath(SingleMemberToSql(pars, memberName, x, mem), x)).ToList(); if (subpaths.Count > 1) { ; } return(items, false); }
/// <summary> /// Convierte una expresión a SQL /// </summary> public static (IReadOnlyList <SqlSubpath> sql, bool star) ExprToSqlStar(Expression expr, SqlExprParams pars, bool rewrite) { if (rewrite) { var visitor = new SqlRewriteVisitor(pars); expr = visitor.Visit(expr); } //Es importante primero comprobar la igualdad del parametro, ya que el replace list tiene una entrada para el parametro tambien if (IsFromParam(expr)) { if (pars.FromListNamed) { return(SqlSubpath.FromString($"*"), true); } return(SqlSubpath.FromString(SqlExpression.TableRefToSql(pars.FromListAlias, "*")), true); } var replace = SqlFromList.ReplaceStringAliasMembers(expr, pars.Replace); if (replace != null) { return(SqlSubpath.FromString(replace), false); } if (expr is MemberExpression mem) { return(MemberToSql(mem, pars)); } else if (expr is ConditionalExpression cond) { return(SqlSubpath.FromString(ConditionalToSql(cond, pars)), false); } else if (expr is MethodCallExpression call) { return(SqlSubpath.FromString(CallToSql(call, pars)), false); } else if (expr is MemberInitExpression || expr is NewExpression) { //TODO: Note la similaridad de este código, del InsertToString y del SelectStr //Puede ser que estas 3 funciones sean lógicamente equivalentes y que se puedan unificar var exprs = SqlSelect .ExtractInitExpr(expr) .Select(x => (x.mem, sql: ExprToSqlStar(x.expr, pars, false))); ; if (exprs.Any(y => y.sql.star)) { throw new ArgumentException("No esta soportado una expresión star '*' en una subexpresión"); } var subpaths = exprs .SelectMany(x => x.sql.sql, (parent, child) => (member: parent.mem, subpath: child)) .Select(x => new SqlSubpath(x.subpath.Sql, "_" + x.member.Name + x.subpath.Subpath)) .ToList() ; return(subpaths, false); } throw new ArgumentException("No se pudo convertir a SQL la expresión " + expr.ToString()); }