private List <SqlExpression> GetIdentityExpressions(MetaType type, SqlExpression expr) { List <MetaDataMember> list = this.GetIdentityMembers(type).ToList <MetaDataMember>(); var list2 = new List <SqlExpression>(list.Count); foreach (MetaDataMember member in list) { list2.Add(this.sql.Member((SqlExpression)SqlDuplicator.Copy(expr), member)); } return(list2); }
internal override SqlExpression VisitMultiset(SqlSubSelect sms) { if (((((this.options & SqlMultiplexer.Options.EnableBigJoin) != SqlMultiplexer.Options.None) && !this.hasBigJoin) && (this.canJoin && this.isTopLevel)) && (((this.outerSelect != null) && !MultisetChecker.HasMultiset(sms.Select.Selection)) && BigJoinChecker.CanBigJoin(sms.Select))) { sms.Select = this.VisitSelect(sms.Select); SqlAlias right = new SqlAlias(sms.Select); SqlJoin join = new SqlJoin(SqlJoinType.OuterApply, this.outerSelect.From, right, null, sms.SourceExpression); this.outerSelect.From = join; this.outerSelect.OrderingType = SqlOrderingType.Always; SqlExpression expression = (SqlExpression)SqlDuplicator.Copy(sms.Select.Selection); SqlSelect node = (SqlSelect)SqlDuplicator.Copy(sms.Select); SqlAlias from = new SqlAlias(node); SqlSelect select = new SqlSelect(this.sql.Unary(SqlNodeType.Count, null, sms.SourceExpression), from, sms.SourceExpression); select.OrderingType = SqlOrderingType.Never; SqlExpression count = this.sql.SubSelect(SqlNodeType.ScalarSubSelect, select); SqlJoinedCollection joineds = new SqlJoinedCollection(sms.ClrType, sms.SqlType, expression, count, sms.SourceExpression); this.hasBigJoin = true; return(joineds); } return(QueryExtractor.Extract(sms, this.parentParameters, sqlIdentity)); }
internal override SqlSelect VisitSelect(SqlSelect select) { bool topSelect = this.topSelect; bool addPrimaryKeys = this.addPrimaryKeys; SqlSelect currentSelect = this.currentSelect; this.currentSelect = select; if (select.OrderingType == SqlOrderingType.Always) { this.addPrimaryKeys = true; } this.topSelect = false; if (select.GroupBy.Count > 0) { this.Visit(select.From); this.orders = null; } else { this.Visit(select.From); } if (select.OrderBy.Count > 0) { this.PrependOrderExpressions(select.OrderBy); } List <SqlOrderExpression> orders = this.orders; this.orders = null; this.rowNumberOrders = orders; select.Where = this.VisitExpression(select.Where); int num = 0; int count = select.GroupBy.Count; while (num < count) { select.GroupBy[num] = this.VisitExpression(select.GroupBy[num]); num++; } select.Having = this.VisitExpression(select.Having); int num3 = 0; int num4 = select.OrderBy.Count; while (num3 < num4) { select.OrderBy[num3].Expression = this.VisitExpression(select.OrderBy[num3].Expression); num3++; } select.Top = this.VisitExpression(select.Top); select.Selection = this.VisitExpression(select.Selection); select.Row = (SqlRow)this.Visit(select.Row); this.topSelect = topSelect; this.addPrimaryKeys = addPrimaryKeys; this.orders = orders; if (select.OrderingType == SqlOrderingType.Blocked) { this.orders = null; } select.OrderBy.Clear(); SqlRowNumberChecker checker = new SqlRowNumberChecker(); if (checker.HasRowNumber(select) && (checker.RowNumberColumn != null)) { select.Row.Columns.Remove(checker.RowNumberColumn); this.PushDown(checker.RowNumberColumn); this.Orders.Add(new SqlOrderExpression(SqlOrderType.Ascending, new SqlColumnRef(checker.RowNumberColumn))); } if ((this.topSelect || (select.Top != null)) && ((select.OrderingType != SqlOrderingType.Never) && (this.orders != null))) { SqlDuplicator duplicator = new SqlDuplicator(true); foreach (SqlOrderExpression expression in this.orders) { select.OrderBy.Add(new SqlOrderExpression(expression.OrderType, (SqlExpression) duplicator.Duplicate(expression.Expression))); } } this.currentSelect = currentSelect; return(select); }
internal override SqlRowNumber VisitRowNumber(SqlRowNumber rowNumber) { if (rowNumber.OrderBy.Count <= 0) { SqlDuplicator duplicator = new SqlDuplicator(true); List <SqlOrderExpression> list = new List <SqlOrderExpression>(); List <SqlOrderExpression> list2 = new List <SqlOrderExpression>(); if ((this.rowNumberOrders != null) && (this.rowNumberOrders.Count != 0)) { list2 = new List <SqlOrderExpression>(this.rowNumberOrders); } else if (this.orders != null) { list2 = new List <SqlOrderExpression>(this.orders); } foreach (SqlOrderExpression expression in list2) { if (!expression.Expression.IsConstantColumn) { list.Add(expression); if (this.rowNumberOrders != null) { this.rowNumberOrders.Remove(expression); } if (this.orders != null) { this.orders.Remove(expression); } } } rowNumber.OrderBy.Clear(); if (list.Count == 0) { foreach ( SqlColumn column in SqlReorderer.SqlGatherColumnsProduced.GatherColumns(this.currentSelect.From)) { if (column.Expression.SqlType.IsOrderable) { list.Add(new SqlOrderExpression(SqlOrderType.Ascending, new SqlColumnRef(column))); } } if (list.Count == 0) { var column2 = new SqlColumn("rowNumberOrder", sql.Value(typeof(int), typeProvider.From(typeof(int)), 1, false, rowNumber.SourceExpression)); this.PushDown(column2); list.Add(new SqlOrderExpression(SqlOrderType.Ascending, new SqlColumnRef(column2))); } } foreach (SqlOrderExpression expression2 in list) { rowNumber.OrderBy.Add(new SqlOrderExpression(expression2.OrderType, (SqlExpression) duplicator.Duplicate(expression2.Expression))); } } return(rowNumber); }
private SqlExpression TranslateEqualsOp(SqlNodeType op, SqlExpression left, SqlExpression right, bool allowExpand) { switch (op) { case SqlNodeType.EQ: case SqlNodeType.NE: return(this.sql.Binary(op, left, right)); case SqlNodeType.EQ2V: { if ((SqlExpressionNullability.CanBeNull(left) != false) && (SqlExpressionNullability.CanBeNull(right) != false)) { SqlNodeType type = allowExpand ? SqlNodeType.EQ2V : SqlNodeType.EQ; return(this.sql.Binary(SqlNodeType.Or, this.sql.Binary(SqlNodeType.And, this.sql.Unary(SqlNodeType.IsNull, (SqlExpression)SqlDuplicator.Copy(left)), this.sql.Unary(SqlNodeType.IsNull, (SqlExpression)SqlDuplicator.Copy(right))), this.sql.Binary(SqlNodeType.And, this.sql.Binary(SqlNodeType.And, this.sql.Unary(SqlNodeType.IsNotNull, (SqlExpression)SqlDuplicator.Copy(left)), this.sql.Unary(SqlNodeType.IsNotNull, (SqlExpression)SqlDuplicator.Copy(right))), this.sql.Binary(type, left, right)))); } SqlNodeType nodeType = allowExpand ? SqlNodeType.EQ2V : SqlNodeType.EQ; return(this.sql.Binary(nodeType, left, right)); } case SqlNodeType.NE2V: { if ((SqlExpressionNullability.CanBeNull(left) == false) || (SqlExpressionNullability.CanBeNull(right) == false)) { SqlNodeType type4 = allowExpand ? SqlNodeType.NE2V : SqlNodeType.NE; return(this.sql.Binary(type4, left, right)); } SqlNodeType type3 = allowExpand ? SqlNodeType.EQ2V : SqlNodeType.EQ; return(this.sql.Unary(SqlNodeType.Not, this.sql.Binary(SqlNodeType.Or, this.sql.Binary(SqlNodeType.And, this.sql.Unary(SqlNodeType.IsNull, (SqlExpression)SqlDuplicator.Copy(left)), this.sql.Unary(SqlNodeType.IsNull, (SqlExpression)SqlDuplicator.Copy(right))), this.sql.Binary(SqlNodeType.And, this.sql.Binary(SqlNodeType.And, this.sql.Unary(SqlNodeType.IsNotNull, (SqlExpression)SqlDuplicator.Copy(left)), this.sql.Unary(SqlNodeType.IsNotNull, (SqlExpression)SqlDuplicator.Copy(right))), this.sql.Binary(type3, left, right))))); } } throw Error.UnexpectedNode(op); }