/// <summary>
/// Obtiene el SQL de una referencia a una columna de una tabla.
/// </summary>
/// <param name="table">Si es null se devuelve sólo la columna sin el identificador de la tabla</param>
/// <param name="column">Nombre de la columna. Puede ser * para indicar todas las columnas</param>
static string TableRefToSql(string table, string column)
{
var colSql = SqlSelect.ColNameToStr(column);
var tableRaw = table != null ? $"\"{table}\"" : null;
return(RawTableRefToSql(tableRaw, colSql));
}
/// <summary>
/// Convierte un <see cref="MemberExpression"/> a SQL, tomando en cuenta los aliases de la lista de froms
/// y la lógica descrita en <see cref="SqlExprParams"/>
/// </summary>
static string SingleMemberToSql(SqlExprParams pars, string baseMemberName, string subpath, MemberExpression mem)
{
var memberName = baseMemberName + subpath;
if (pars.FromListNamed)
{
//Si la lista de FROM tiene aliases, el parametro del select no hace referencia a una tabla,
//si no a un objeto de aliases donde cada propiedad es una tabla o un elemento de un JOIN
MemberExpression firstExpr = mem;
while (firstExpr is MemberExpression sm1 && sm1.Expression is MemberExpression sm2)
{
firstExpr = sm2;
}
if (IsFromParam(mem.Expression))
{
throw new ArgumentException("No esta soportado obtener una expresión de * en el SingleMemberSql");
}
else if (IsFromParam(firstExpr.Expression))
{
return(TableRefToSql(firstExpr.Member.Name, memberName));
}
else if (IsRawTableRef(firstExpr.Expression, out var raw))
{
return(RawTableRefToSql(raw, SqlSelect.ColNameToStr(memberName)));
}
}
else
{
//Si la lista de FROM no tiene aliases, el parámetro del SELECT hace referencia a la tabla del SELECT
Expression firstExpr = mem;
while (firstExpr is MemberExpression sm)
{
firstExpr = sm.Expression;
}
if (IsFromParam(firstExpr))
{
return(TableRefToSql(pars.FromListAlias, memberName));
}
else if (IsRawTableRef(firstExpr, out var raw))
{
return(RawTableRefToSql(raw, SqlSelect.ColNameToStr(memberName)));
}
}
//Intentamos convertir al Expr a string con el replace:
var exprRep = SqlFromList.ReplaceStringAliasMembers(mem.Expression, pars.Replace);
if (exprRep != null)
{
return($"{exprRep}.\"{memberName}\"");
}
var exprStr = ExprToSql(mem.Expression, pars, false);
return($"{exprStr}.\"{memberName}\"");
}
/// <summary>
/// Convierte el cuerpo de la expresión SET a SQL
/// </summary>
public static string SetToSql(Expression body,
ParamMode paramMode,
SqlParamDic paramDic,
IEnumerable <SqlFromList.ExprStrRawSql> exprAlias
)
{
var b = new StringBuilder();
var pars = new SqlExprParams(null, null, false, null, exprAlias.ToList(), paramMode, paramDic);
//Hacer el rewrite en todo el body:
var visitor = new SqlRewriteVisitor(pars);
body = visitor.Visit(body);
var exprs = SqlSelect
.ExtractInitExpr(body)
.Select(x => (x.mem, sql: SqlExpression.ExprToSqlStar(x.expr, pars, false)))
;
if (exprs.Any(y => y.sql.star))
{
throw new ArgumentException("No esta soportado una expresión star '*' en la asignación de los valores de un INSERT");
}
var subpaths = exprs.SelectMany(x => x.sql.sql, (parent, child) => (member: parent.mem, subpath: child));
var sets = subpaths.Select(x => (
column: SqlSelect.MemberToColumnName(x.member, x.subpath),
value: x.subpath.Sql))
;
var setSql = sets
.Select(x =>
$"{SqlSelect.ColNameToStr(x.column)} = {x.value}"
);
var sql = string.Join($", {Environment.NewLine}", setSql);
return(sql);
}
