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());
}
public static string ExprToSql(Expression expr, SqlExprParams pars, bool rewrite)
{
return(SqlSubpath.Single(ExprToSqlStar(expr, pars, rewrite).sql));
}