Ejemplo n.º 1
0
 protected DbBinaryExpression(DbExpressionType nodeType, Type type, DbExpression left, DbExpression right, MethodInfo method)
     : base(nodeType, type)
 {
     this._left   = left;
     this._right  = right;
     this._method = method;
 }
Ejemplo n.º 2
0
        // g.Max(a=>a.Level)
        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            if (_groupBy != null && node.IsGrouping())
            {
                DbExpressionType dbExpressionType = DbExpressionType.None;
                Enum.TryParse(node.Method.Name, out dbExpressionType);
                Expression exp = dbExpressionType == DbExpressionType.Count
                    ? Expression.Constant(1)
                    : (node.Arguments.Count == 1 ? null : node.Arguments[1]);
                if (exp.NodeType == ExpressionType.Lambda)
                {
                    exp = (exp as LambdaExpression).Body;
                }

                // 如果是 a=> a 这种表达式,那么一定会指定 elementSelector
                if (exp.NodeType == ExpressionType.Parameter)
                {
                    exp = _groupBy.Expressions[1];
                }

                _builder.Append(_statisMethods[dbExpressionType]);
                _builder.Append("(");
                this.Visit(exp);
                _builder.Append(")");

                return(node);
            }

            return(base.VisitMethodCall(node));
        }
Ejemplo n.º 3
0
        /// <summary>
        ///  根据键按升序对序列的元素排序
        /// </summary>
        public static IDbQueryable <TSource> OrderBy <TSource>(this IDbQueryable <TSource> source, string ordering)
        {
            if (string.IsNullOrEmpty(ordering))
            {
                return(source);
            }

            // a.BuyDate ASC
            string[] syntaxes = ordering.Split(' ');
            string[] segs     = syntaxes[0].Split('.');

            ParameterExpression parameter = Expression.Parameter(typeof(TSource), segs[0]);
            MemberExpression    member    = Expression.Property(parameter, segs[1]);
            LambdaExpression    lambda    = Expression.Lambda(member, parameter);

            DbExpressionType d = DbExpressionType.OrderBy;

            if (syntaxes.Length > 1 && (syntaxes[1] ?? string.Empty).ToUpper() == "DESC")
            {
                d = DbExpressionType.OrderByDescending;
            }

            return(source.CreateQuery <TSource>(d, lambda));
            //source.DbExpressions.Add(new DbExpression(d, lambda));
            //return source;
        }
        /// <summary>
        ///  根据键按升序对序列的元素排序
        /// </summary>
        public static IDbQueryable <TSource> OrderBy <TSource>(this IDbQueryable <TSource> source, string order)
        {
            if (string.IsNullOrEmpty(order))
            {
                return(source);
            }

            // a.Product.BuyDate ASC
            string[] syntaxes = order.Split(' ');
            string[] segs     = syntaxes[0].Split('.');
            if (segs.Length <= 1)
            {
                return(source);
            }

            ParameterExpression parameter = Expression.Parameter(typeof(TSource), segs[0]);
            Expression          node      = parameter;

            for (int i = 1; i < segs.Length; i++)
            {
                node = Expression.Property(node, segs[i]);
            }

            LambdaExpression lambda = Expression.Lambda(node, parameter);
            DbExpressionType d      = DbExpressionType.OrderBy;

            if (syntaxes.Length > 1 && (syntaxes[1] ?? string.Empty).ToUpper() == "DESC")
            {
                d = DbExpressionType.OrderByDescending;
            }

            return(source.CreateQuery <TSource>(d, lambda));
        }
Ejemplo n.º 5
0
 /// <summary>
 /// 创建查询
 /// </summary>
 public IDbQueryable <TResult> CreateQuery <TResult>(DbExpressionType dbExpressionType, System.Linq.Expressions.Expression expression = null)
 {
     return(this.CreateQuery <TResult>(new DbExpression
     {
         DbExpressionType = dbExpressionType,
         Expressions = expression != null ? new[] { expression } : null
     }));
 }
Ejemplo n.º 6
0
 /// <summary>
 /// 实例化<see cref="DbExpression"/>类的新实例
 /// </summary>
 /// <param name="dbExpressionType">表达式类型</param>
 /// <param name="expression">查询表达式</param>
 public DbExpression(DbExpressionType dbExpressionType, Expression expression = null)
 {
     this.DbExpressionType = dbExpressionType;
     if (expression != null)
     {
         Expressions = new[] { expression }
     }
     ;
 }
        protected DbSubqueryExpression(DbExpressionType expressionType, 
            Type type, DbSelectExpression select)
            : base(expressionType, type)
        {
            Debug.Assert(expressionType == DbExpressionType.Scalar || 
                expressionType == DbExpressionType.Exists || 
                expressionType == DbExpressionType.In);

            _select = select;
        }
        protected DbSubqueryExpression(DbExpressionType expressionType,
                                       Type type, DbSelectExpression select)
            : base(expressionType, type)
        {
            Debug.Assert(expressionType == DbExpressionType.Scalar ||
                         expressionType == DbExpressionType.Exists ||
                         expressionType == DbExpressionType.In);

            _select = select;
        }
        /// <summary>
        ///  根据键按升序对序列的元素排序
        /// </summary>
        public static IDbQueryable <TSource> OrderBy <TSource, TKey>(this IDbQueryable <TSource> source, Expression <Func <TSource, TKey> > keySelector, string order)
        {
            if (string.IsNullOrEmpty(order))
            {
                order = "ASC";
            }
            DbExpressionType t = order == "ASC" ? DbExpressionType.OrderBy : DbExpressionType.OrderByDescending;

            return(source.CreateQuery <TSource>(t, keySelector));
        }
        /// <summary>
        /// 初始化 <see cref="NpgJoinExpressionVisitor"/> 类的新实例
        /// </summary>
        /// <param name="ag">表别名解析器</param>
        /// <param name="builder">SQL 语句生成器</param>
        /// <param name="dbExpressionType">表达式类型</param>
        /// <param name="cmd">SQL 命令</param>
        public NpgJoinExpressionVisitor(AliasGenerator ag, ISqlBuilder builder, DbExpressionType dbExpressionType, NpgDbSelectCommand cmd)
            : base(ag, builder)
        {
            _ag = ag;
            _dbExpressionType = dbExpressionType;
            _cmd = cmd;

            if (_dbExpressionType == DbExpressionType.Delete)
            {
                _keywordName = "USING ";
            }
            else if (_dbExpressionType == DbExpressionType.Update)
            {
                _keywordName = "FROM ";
            }
            _pad = "".PadLeft(_keywordName.Length, ' ');
        }
Ejemplo n.º 11
0
        /// <summary>
        /// 实例化 <see cref="NpgDbSelectCommand" /> 的新实例
        /// </summary>
        /// <param name="context">解析SQL命令上下文</param>
        /// <param name="aliasGenerator">别名</param>
        /// <param name="dbExpressionType">表达式类型</param>
        /// <param name="hasMany">是否包含一对多导航属性</param>
        public NpgDbSelectCommand(ITranslateContext context, AliasGenerator aliasGenerator, DbExpressionType dbExpressionType, bool hasMany)
            : base(context, aliasGenerator, hasMany)
        {
            _aliasGenerator   = aliasGenerator;
            _onPhrase         = ((DbQueryProvider)context.Provider).CreateSqlBuilder(context);
            _dbExpressionType = dbExpressionType;

            if (_dbExpressionType == DbExpressionType.Delete)
            {
                _keywordName = "USING ";
            }
            else if (_dbExpressionType == DbExpressionType.Update)
            {
                _keywordName = "FROM ";
            }
            _pad = "".PadLeft(_keywordName.Length, ' ');
        }
Ejemplo n.º 12
0
        static Stack<DbExpression> GatherBinaryExpressionOperand(DbBinaryExpression exp)
        {
            DbExpressionType nodeType = exp.NodeType;

            Stack<DbExpression> items = new Stack<DbExpression>();
            items.Push(exp.Right);

            DbExpression left = exp.Left;
            while (left.NodeType == nodeType)
            {
                exp = (DbBinaryExpression)left;
                items.Push(exp.Right);
                left = exp.Left;
            }

            items.Push(left);
            return items;
        }
Ejemplo n.º 13
0
        /// <summary>
        /// 实例化 <see cref="NpgMappingDbCommand" /> 的新实例
        /// </summary>
        /// <param name="provider">数据查询提供者</param>
        /// <param name="aliases">别名</param>
        /// <param name="dbExpressionType">表达式类型</param>
        /// <param name="token">解析上下文参数</param>
        public NpgMappingDbCommand(IDbQueryProvider provider, TableAlias aliases, DbExpressionType dbExpressionType, ResolveToken token)
            : base(provider, aliases, token)
        {
            _provider         = provider;
            _aliases          = aliases;
            _onPhrase         = _provider.CreateSqlBuilder(token);
            _dbExpressionType = dbExpressionType;

            if (_dbExpressionType == DbExpressionType.Delete)
            {
                _keywordName = "USING ";
            }
            else if (_dbExpressionType == DbExpressionType.Update)
            {
                _keywordName = "FROM ";
            }
            _pad = "".PadLeft(_keywordName.Length, ' ');
        }
Ejemplo n.º 14
0
        protected virtual void VisitLog(String prefix, Expression exp)
        {
            if (exp == null)
            {
                return;
            }
            var title = $"Visit {prefix}: {this.GetType().FullName}";

            if ((Int32)exp.NodeType < 1000)
            {
                Logger.WriteLine(title + " NodeType " + exp.NodeType.ToString());
            }
            else
            {
                DbExpressionType dbExpType = (DbExpressionType)exp.NodeType;
                Logger.WriteLine(title + " DbExpNodeType " + dbExpType.ToString());
            }
        }
Ejemplo n.º 15
0
        /// <summary>
        /// 初始化 <see cref="NpgJoinExpressionVisitor"/> 类的新实例
        /// </summary>
        public NpgJoinExpressionVisitor(IDbQueryProvider provider, TableAliasCache aliases, List <DbExpression> qJoin, DbExpressionType dbExpressionType)
            : base(provider, aliases, qJoin)
        {
            _qJoin            = qJoin;
            _aliases          = aliases;
            _provider         = provider;
            _dbExpressionType = dbExpressionType;

            if (_dbExpressionType == DbExpressionType.Delete)
            {
                _keywordName = "USING ";
            }
            else if (_dbExpressionType == DbExpressionType.Update)
            {
                _keywordName = "FROM ";
            }
            _pad = "".PadLeft(_keywordName.Length, ' ');
        }
Ejemplo n.º 16
0
        protected override Expression VisitSource(Expression source)
        {
            bool isNested = this.isNested;

            this.isNested = true;
            DbExpressionType nodeType = (DbExpressionType)source.NodeType;

            if (nodeType != DbExpressionType.Table)
            {
                if (nodeType != DbExpressionType.Select)
                {
                    if (nodeType != DbExpressionType.Join)
                    {
                        throw new InvalidOperationException("Select source is not valid type");
                    }
                    this.VisitJoin((JoinExpression)source);
                    goto Label_00EB;
                }
            }
            else
            {
                TableExpression expression = (TableExpression)source;
                this.WriteTableName(expression.Name);
                if (!this.HideTableAliases)
                {
                    this.Write(" ");
                    this.WriteAsAliasName(this.GetAliasName(expression.Alias));
                }
                goto Label_00EB;
            }
            SelectExpression exp = (SelectExpression)source;

            this.Write("(");
            this.WriteLine(Indentation.Inner);
            this.Visit(exp);
            this.WriteLine(Indentation.Same);
            this.Write(") ");
            this.WriteAsAliasName(this.GetAliasName(exp.Alias));
            this.Indent(Indentation.Outer);
Label_00EB:
            this.isNested = isNested;
            return(source);
        }
Ejemplo n.º 17
0
 public DbExpression(Expression expression, DbExpressionType expressionType)
 {
     Expression     = expression;
     ExpressionType = expressionType;
 }
Ejemplo n.º 18
0
 protected DbExpression(DbExpressionType nodeType)
     : this(nodeType, PublicConstants.TypeOfVoid)
 {
 }
Ejemplo n.º 19
0
 /// <summary>
 /// 创建查询表达式
 /// </summary>
 /// <typeparam name="TResult">返回的元素类型</typeparam>
 /// <param name="dbExpressionType">查询类型</param>
 /// <param name="expression">查询表达式</param>
 /// <returns></returns>
 public IDbQueryable <TResult> CreateQuery <TResult>(DbExpressionType dbExpressionType, Expression expression)
 => this.CreateQuery <TResult>(new DbExpression(dbExpressionType, expression));
Ejemplo n.º 20
0
 /// <summary>
 /// 实例化<see cref="DbExpression"/>类的新实例
 /// </summary>
 /// <param name="dbExpressionType">表达式类型</param>
 /// <param name="expressions">查询表达式</param>
 public DbExpression(DbExpressionType dbExpressionType, Expression[] expressions)
 {
     this.DbExpressionType = dbExpressionType;
     this.Expressions      = expressions;
 }
Ejemplo n.º 21
0
 protected AliasedExpression(DbExpressionType nodeType, Type type, IdentifiableAlias alias)
     : base(nodeType, type)
 {
     this.alias = alias;
 }
Ejemplo n.º 22
0
 protected DbExpression(DbExpressionType expressionType, Type type)
     : base((ExpressionType)expressionType, type)
 {
 }
Ejemplo n.º 23
0
 protected CommandExpression(DbExpressionType eType, Type type)
     : base(eType, type)
 {
 }
Ejemplo n.º 24
0
 protected AliasedExpression(DbExpressionType nodeType, Type type, TableAlias alias)
     : base(nodeType, type)
 {
     this.alias = alias;
 }
Ejemplo n.º 25
0
 protected SubqueryExpression(DbExpressionType eType, Type type, SelectExpression select)
     : base(eType, type)
 {
     System.Diagnostics.Debug.Assert(eType == DbExpressionType.Scalar || eType == DbExpressionType.Exists || eType == DbExpressionType.In);
     this.select = select;
 }
 protected DbAliasedExpression(DbExpressionType nodeType, 
     Type type, DbTableAlias alias)
     : base(nodeType, type)
 {
     _alias = alias;
 }
Ejemplo n.º 27
0
 protected SubqueryExpression(DbExpressionType eType, Type type, SelectExpression select)
     : base(eType, type)
 {
     System.Diagnostics.Debug.Assert(eType == DbExpressionType.Scalar || eType == DbExpressionType.Exists || eType == DbExpressionType.In);
     this.select = select;
 }
Ejemplo n.º 28
0
 protected CommandExpression(DbExpressionType eType, Type type)
     : base(eType, type)
 {
 }
Ejemplo n.º 29
0
 protected DbBinaryExpression(DbExpressionType nodeType, Type type, DbExpression left, DbExpression right)
     : this(nodeType, type, left, right, null)
 {
 }
Ejemplo n.º 30
0
 protected DbExpression(DbExpressionType eType, Type type)
     : base((ExpressionType)eType, type)
 {
 }
Ejemplo n.º 31
0
 public CommandExpression(DbExpressionType nodeType)
     : base(nodeType, typeof(void))
 {
 }
Ejemplo n.º 32
0
 public SourceWithAliasExpression(DbExpressionType nodeType, Alias alias)
     : base(nodeType)
 {
     this.Alias = alias;
 }
Ejemplo n.º 33
0
 protected DbExpression(DbExpressionType eType, Type type)
 {
     this.expressionType = eType;
     this.type           = type;
 }
Ejemplo n.º 34
0
 public SourceExpression(DbExpressionType nodeType)
     : base(nodeType, typeof(void))
 {
 }
Ejemplo n.º 35
0
 /// <summary>
 /// Extended constructor
 /// </summary>
 /// <param name="expressionType"></param>
 /// <param name="columnName"></param>
 public DbFilterExpression(DbExpressionType expressionType, string columnName)
 {
     ExpressionType = expressionType;
     ColumnName     = columnName;
 }
Ejemplo n.º 36
0
 protected DbExpression(DbExpressionType nodeType, Type type)
 {
     this.type       = type;
     this.dbNodeType = nodeType;
 }
 protected DbStatementExpression(DbExpressionType expressionType, Type type)
     : base(expressionType, type)
 {
 }