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