private SqlJoin GetLeftOuterWithUnreferencedSingletonOnLeft(SqlSource source)
{
SqlAlias alias = source as SqlAlias;
if (alias != null)
{
SqlSelect node = alias.Node as SqlSelect;
if ((((node != null) && (node.Where == null)) && ((node.Top == null) && (node.GroupBy.Count == 0))) &&
(node.OrderBy.Count == 0))
{
return(this.GetLeftOuterWithUnreferencedSingletonOnLeft(node.From));
}
}
SqlJoin join = source as SqlJoin;
if ((join == null) || (join.JoinType != SqlJoinType.LeftOuter))
{
return(null);
}
if (!this.IsSingletonSelect(join.Left))
{
return(null);
}
Dictionary <SqlAlias, bool> dictionary = SqlGatherProducedAliases.Gather(join.Left);
foreach (SqlAlias alias2 in SqlGatherConsumedAliases.Gather(join.Right).Keys)
{
if (dictionary.ContainsKey(alias2))
{
return(null);
}
}
return(join);
}
internal override SqlAlias VisitAlias(SqlAlias a)
{
if (!IsTableAlias(a) || !this.addPrimaryKeys)
{
return(base.VisitAlias(a));
}
SqlTable node = (SqlTable)a.Node;
List <SqlOrderExpression> exprs = new List <SqlOrderExpression>();
foreach (MetaDataMember member in node.RowType.IdentityMembers)
{
string mappedName = member.MappedName;
SqlColumn item = node.Find(mappedName);
if (item == null)
{
item = new SqlColumn(member.MemberAccessor.Type,
this.typeProvider.From(member.MemberAccessor.Type), mappedName, member,
null, node.SourceExpression);
item.Alias = a;
node.Columns.Add(item);
}
exprs.Add(new SqlOrderExpression(SqlOrderType.Ascending, new SqlColumnRef(item)));
}
this.PrependOrderExpressions(exprs);
return(a);
}
internal override SqlAlias VisitAlias(SqlAlias sqlAlias)
{
SqlAlias alias = this.alias;
this.alias = sqlAlias;
sqlAlias.Node = this.Visit(sqlAlias.Node);
this.alias = alias;
return(sqlAlias);
}
// Methods
internal SqlAliasRef(SqlAlias alias)
: base(SqlNodeType.AliasRef, GetClrType(alias.Node), alias.SourceExpression)
{
if (alias == null)
{
throw Error.ArgumentNull("alias");
}
this.alias = alias;
}
internal override SqlAlias VisitAlias(SqlAlias a)
{
SqlAlias alias = new SqlAlias(a.Node);
this.nodeMap[a] = alias;
alias.Node = this.Visit(a.Node);
alias.Name = a.Name;
return(alias);
}
private bool HasTrivialSource(SqlSource node)
{
SqlAlias alias = node as SqlAlias;
if (alias == null)
{
return(false);
}
return(alias.Node is SqlSelect);
}
internal override SqlExpression VisitAliasRef(SqlAliasRef aref)
{
SqlExpression expression = base.VisitAliasRef(aref);
if ((expression != null) && (expression == aref))
{
SqlAlias alias = aref.Alias;
return(new SqlAliasRef(new SqlAlias(new SqlNop(aref.ClrType, aref.SqlType, null))));
}
return(expression);
}
internal override SqlExpression VisitAliasRef(SqlAliasRef aref)
{
SqlAlias alias2;
SqlAlias key = aref.Alias;
if (this.removedMap.TryGetValue(key, out alias2))
{
throw Error.InvalidReferenceToRemovedAliasDuringDeflation();
}
return(aref);
}
internal SqlSelect BuildDefaultQuery(MetaType rowType, bool allowDeferred, SqlLink link, Expression source)
{
if (rowType.HasInheritance && (rowType.InheritanceRoot != rowType))
{
throw Error.ArgumentWrongValue("rowType");
}
SqlTable node = sql.Table(rowType.Table, rowType, source);
var alias = new SqlAlias(node);
var item = new SqlAliasRef(alias);
return(new SqlSelect(BuildProjection(item, node.RowType, allowDeferred, link, source), alias, source));
}
// Methods
private SqlUnion GetUnion(SqlSource source)
{
SqlAlias alias = source as SqlAlias;
if (alias != null)
{
SqlUnion node = alias.Node as SqlUnion;
if (node != null)
{
return(node);
}
}
return(null);
}
private bool HasEmptySource(SqlSource node)
{
SqlAlias alias = node as SqlAlias;
if (alias == null)
{
return(false);
}
SqlSelect select = alias.Node as SqlSelect;
if (select == null)
{
return(false);
}
return(((((select.Row.Columns.Count == 0) && (select.From == null)) && ((select.Where == null) && (select.GroupBy.Count == 0))) && (select.Having == null)) && (select.OrderBy.Count == 0));
}
internal override SqlSource VisitSource(SqlSource node)
{
node = (SqlSource)this.Visit(node);
SqlAlias alias = node as SqlAlias;
if (alias != null)
{
SqlSelect select = alias.Node as SqlSelect;
if ((select != null) && this.IsTrivialSelect(select))
{
this.removedMap[alias] = alias;
node = select.From;
}
}
return(node);
}
private void GetSelectionsBeforeJoin(SqlSource source, List <List <SqlColumn> > selections)
{
if (!(source is SqlJoin))
{
SqlAlias alias = source as SqlAlias;
if (alias != null)
{
SqlSelect node = alias.Node as SqlSelect;
if (node != null)
{
this.GetSelectionsBeforeJoin(node.From, selections);
//selections.Add(node.Row.Columns);
List <SqlColumn> columns = new List <SqlColumn>(node.Row.Columns);
selections.Add(columns);
}
}
}
}
internal SqlAlias VisitAliasConsumed(SqlAlias a)
{
if (a != null)
{
bool flag = false;
foreach (SqlAlias alias in this.aliases)
{
if (alias == a)
{
flag = true;
break;
}
}
if (flag)
{
this.referencesAnyMatchingAliases = true;
}
}
return(a);
}
private bool IsSingletonSelect(SqlSource source)
{
SqlAlias alias = source as SqlAlias;
if (alias == null)
{
return(false);
}
SqlSelect node = alias.Node as SqlSelect;
if (node == null)
{
return(false);
}
if (node.From != null)
{
return(false);
}
return(true);
}
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 SqlSource VisitJoin(SqlJoin join)
{
base.VisitJoin(join);
switch (join.JoinType)
{
case SqlJoinType.Cross:
case SqlJoinType.Inner:
return(join);
case SqlJoinType.LeftOuter:
case SqlJoinType.CrossApply:
case SqlJoinType.OuterApply:
{
if (!this.HasEmptySource(join.Right))
{
return(join);
}
SqlAlias right = (SqlAlias)join.Right;
this.removedMap[right] = right;
return(join.Left);
}
}
return(join);
}
// Methods
internal void VisitAliasConsumed(SqlAlias a)
{
this.Consumed[a] = true;
}
internal virtual SqlAlias VisitAlias(SqlAlias a)
{
a.Node = this.Visit(a.Node);
return(a);
}
internal SqlExpression TranslateEquals(SqlBinary expr)
{
IList <SqlExpression> keyExpressions;
IList <SqlExpression> identityExpressions;
SqlExpression left = expr.Left;
SqlExpression right = expr.Right;
if (right.NodeType == SqlNodeType.Element)
{
var select = (SqlSubSelect)right;
var alias = new SqlAlias(select.Select);
var selection = new SqlAliasRef(alias);
var select2 = new SqlSelect(selection, alias, expr.SourceExpression)
{
Where = sql.Binary(expr.NodeType, sql.DoNotVisitExpression(left), selection)
};
return(sql.SubSelect(SqlNodeType.Exists, select2));
}
if (left.NodeType == SqlNodeType.Element)
{
var select3 = (SqlSubSelect)left;
var alias2 = new SqlAlias(select3.Select);
var ref3 = new SqlAliasRef(alias2);
var select4 = new SqlSelect(ref3, alias2, expr.SourceExpression)
{
Where = sql.Binary(expr.NodeType, sql.DoNotVisitExpression(right), ref3)
};
return(sql.SubSelect(SqlNodeType.Exists, select4));
}
var sourceMetaType = TypeSource.GetSourceMetaType(left, services.Model);
var type = TypeSource.GetSourceMetaType(right, services.Model);
if (left.NodeType == SqlNodeType.TypeCase)
{
left = BestIdentityNode((SqlTypeCase)left);
}
if (right.NodeType == SqlNodeType.TypeCase)
{
right = BestIdentityNode((SqlTypeCase)right);
}
if ((sourceMetaType.IsEntity && type.IsEntity) && (sourceMetaType.Table != type.Table))
{
throw Error.CannotCompareItemsAssociatedWithDifferentTable();
}
if (((!sourceMetaType.IsEntity && !type.IsEntity) && ((left.NodeType != SqlNodeType.New) || left.SqlType.CanBeColumn)) && ((right.NodeType != SqlNodeType.New) || right.SqlType.CanBeColumn))
{
if ((expr.NodeType == SqlNodeType.EQ2V) || (expr.NodeType == SqlNodeType.NE2V))
{
return(TranslateEqualsOp(expr.NodeType, sql.DoNotVisitExpression(expr.Left),
sql.DoNotVisitExpression(expr.Right), false));
}
return(expr);
}
if ((sourceMetaType != type) && (sourceMetaType.InheritanceRoot != type.InheritanceRoot))
{
return(this.sql.Binary(SqlNodeType.EQ, sql.ValueFromObject(0, expr.SourceExpression), this.sql.ValueFromObject(1, expr.SourceExpression)));
}
var link = left as SqlLink;
if (((link != null) && link.Member.IsAssociation) && link.Member.Association.IsForeignKey)
{
keyExpressions = link.KeyExpressions;
}
else
{
keyExpressions = this.GetIdentityExpressions(sourceMetaType, this.sql.DoNotVisitExpression(left));
}
var link2 = right as SqlLink;
if (((link2 != null) && link2.Member.IsAssociation) && link2.Member.Association.IsForeignKey)
{
identityExpressions = link2.KeyExpressions;
}
else
{
identityExpressions = this.GetIdentityExpressions(type, sql.DoNotVisitExpression(right));
}
SqlExpression expression3 = null;
SqlNodeType op = ((expr.NodeType == SqlNodeType.EQ2V) || (expr.NodeType == SqlNodeType.NE2V)) ? SqlNodeType.EQ2V : SqlNodeType.EQ;
int num = 0;
int count = keyExpressions.Count;
while (num < count)
{
SqlExpression expression4 = this.TranslateEqualsOp(op, keyExpressions[num], identityExpressions[num], !sourceMetaType.IsEntity);
if (expression3 == null)
{
expression3 = expression4;
}
else
{
expression3 = this.sql.Binary(SqlNodeType.And, expression3, expression4);
}
num++;
}
if ((expr.NodeType != SqlNodeType.NE) && (expr.NodeType != SqlNodeType.NE2V))
{
return(expression3);
}
return(this.sql.Unary(SqlNodeType.Not, expression3, expression3.SourceExpression));
}
// Methods
internal override SqlAlias VisitAlias(SqlAlias a)
{
this.Produced[a] = true;
return(base.VisitAlias(a));
}
private static bool IsTableAlias(SqlSource src)
{
SqlAlias alias = src as SqlAlias;
return((alias != null) && (alias.Node is SqlTable));
}
