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);
}
