protected DbBinaryExpression(DbExpressionType nodeType, Type type, DbExpression left, DbExpression right, MethodInfo method) : base(nodeType, type) { this._left = left; this._right = right; this._method = method; }
// 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)); }
/// <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)); }
/// <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 })); }
/// <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; }
/// <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, ' '); }
/// <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, ' '); }
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; }
/// <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, ' '); }
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()); } }
/// <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, ' '); }
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); }
public DbExpression(Expression expression, DbExpressionType expressionType) { Expression = expression; ExpressionType = expressionType; }
protected DbExpression(DbExpressionType nodeType) : this(nodeType, PublicConstants.TypeOfVoid) { }
/// <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));
/// <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; }
protected AliasedExpression(DbExpressionType nodeType, Type type, IdentifiableAlias alias) : base(nodeType, type) { this.alias = alias; }
protected DbExpression(DbExpressionType expressionType, Type type) : base((ExpressionType)expressionType, type) { }
protected CommandExpression(DbExpressionType eType, Type type) : base(eType, type) { }
protected AliasedExpression(DbExpressionType nodeType, Type type, TableAlias alias) : base(nodeType, type) { this.alias = alias; }
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; }
protected DbBinaryExpression(DbExpressionType nodeType, Type type, DbExpression left, DbExpression right) : this(nodeType, type, left, right, null) { }
protected DbExpression(DbExpressionType eType, Type type) : base((ExpressionType)eType, type) { }
public CommandExpression(DbExpressionType nodeType) : base(nodeType, typeof(void)) { }
public SourceWithAliasExpression(DbExpressionType nodeType, Alias alias) : base(nodeType) { this.Alias = alias; }
protected DbExpression(DbExpressionType eType, Type type) { this.expressionType = eType; this.type = type; }
public SourceExpression(DbExpressionType nodeType) : base(nodeType, typeof(void)) { }
/// <summary> /// Extended constructor /// </summary> /// <param name="expressionType"></param> /// <param name="columnName"></param> public DbFilterExpression(DbExpressionType expressionType, string columnName) { ExpressionType = expressionType; ColumnName = columnName; }
protected DbExpression(DbExpressionType nodeType, Type type) { this.type = type; this.dbNodeType = nodeType; }
protected DbStatementExpression(DbExpressionType expressionType, Type type) : base(expressionType, type) { }