internal override SqlExpression VisitAliasRef(SqlAliasRef aref)
{
SqlNode node = aref.Alias.Node;
if ((node is SqlTable) || (node is SqlTableValuedFunctionCall))
{
return(aref);
}
SqlUnion union = node as SqlUnion;
if (union != null)
{
return(this.ExpandUnion(union));
}
SqlSelect select = node as SqlSelect;
if (select != null)
{
return(this.VisitExpression(select.Selection));
}
SqlExpression exp = node as SqlExpression;
if (exp == null)
{
throw Error.CouldNotHandleAliasRef(node.NodeType);
}
return(this.VisitExpression(exp));
}
private void GatherUnionExpressions(SqlNode node, IList <SqlExpression> exprs)
{
SqlUnion union = node as SqlUnion;
if (union != null)
{
this.GatherUnionExpressions(union.Left, exprs);
this.GatherUnionExpressions(union.Right, exprs);
}
else
{
SqlSelect select = node as SqlSelect;
if (select != null)
{
SqlAliasRef selection = select.Selection as SqlAliasRef;
if (selection != null)
{
this.GatherUnionExpressions(selection.Alias.Node, exprs);
}
else
{
exprs.Add(select.Selection);
}
}
}
}
internal override SqlExpression VisitAliasRef(SqlAliasRef aref)
{
if (this.ingoreExternalRefs && !this.nodeMap.ContainsKey(aref.Alias))
{
return(aref);
}
return(new SqlAliasRef((SqlAlias)this.Visit(aref.Alias)));
}
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 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 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));
}
internal virtual SqlExpression VisitAliasRef(SqlAliasRef aref)
{
return(aref);
}
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));
}
