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 static SqlExpression Lift(SqlSource source, Dictionary <SqlAlias, bool> aliasesForLifting)
{
Visitor visitor = new Visitor(true, aliasesForLifting, null);
visitor.VisitSource(source);
return(visitor.lifted);
}
// Methods
internal static List <SqlColumn> GatherColumns(SqlSource source)
{
List <SqlColumn> columns = new List <SqlColumn>();
new Visitor(columns).Visit(source);
return(columns);
}
internal override SqlSource VisitJoin(SqlJoin join)
{
SqlSource left = this.VisitSource(join.Left);
SqlSource right = this.VisitSource(join.Right);
return(new SqlJoin(join.JoinType, left, right, (SqlExpression)this.Visit(join.Condition), join.SourceExpression));
}
// Methods
internal SqlJoin(SqlJoinType type, SqlSource left, SqlSource right, SqlExpression cond, Expression sourceExpression)
: base(SqlNodeType.Join, sourceExpression)
{
this.JoinType = type;
this.Left = left;
this.Right = right;
this.Condition = cond;
}
internal static List <List <SqlColumn> > Lift(SqlSource source, Dictionary <SqlAlias, bool> aliasesForLifting,
Dictionary <SqlExpression, bool> liftedExpressions)
{
Visitor visitor = new Visitor(true, aliasesForLifting, liftedExpressions);
visitor.VisitSource(source);
return(visitor.lifted);
}
// Methods
internal static bool CanLift(SqlSource source, Dictionary <SqlAlias, bool> aliasesForLifting,
Dictionary <SqlExpression, bool> liftedExpressions)
{
Visitor visitor = new Visitor(false, aliasesForLifting, liftedExpressions);
visitor.VisitSource(source);
return(visitor.canLiftAll);
}
private bool HasTrivialSource(SqlSource node)
{
SqlJoin join = node as SqlJoin;
if (join == null)
{
return(node is SqlAlias);
}
return(this.HasTrivialSource(join.Left) && this.HasTrivialSource(join.Right));
}
private bool HasTrivialSource(SqlSource node)
{
SqlAlias alias = node as SqlAlias;
if (alias == null)
{
return(false);
}
return(alias.Node is SqlSelect);
}
// Methods
internal SqlSelect(SqlExpression selection, SqlSource from, Expression sourceExpression)
: base(SqlNodeType.Select, sourceExpression)
{
this.Row = new SqlRow(sourceExpression);
this.Selection = selection;
this.From = from;
this.GroupBy = new List <SqlExpression>();
this.OrderBy = new List <SqlOrderExpression>();
this.OrderingType = SqlOrderingType.Default;
}
private SqlSource PushSourceDown(SqlSource sqlSource, List <SqlColumn> cols)
{
SqlSelect node = new SqlSelect(
new SqlNop(cols[0].ClrType, cols[0].SqlType, sqlSource.SourceExpression), sqlSource,
sqlSource.SourceExpression);
//node.Row.Columns.AddRange(cols);
foreach (var col in cols)
{
node.Row.Columns.Add(col);
}
return(new SqlAlias(node));
}
// 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);
}
internal override SqlSelect VisitSelect(SqlSelect select)
{
SqlSource from = this.VisitSource(select.From);
List <SqlExpression> collection = null;
if (select.GroupBy.Count > 0)
{
collection = new List <SqlExpression>(select.GroupBy.Count);
foreach (SqlExpression expression in select.GroupBy)
{
collection.Add((SqlExpression)this.Visit(expression));
}
}
SqlExpression expression2 = (SqlExpression)this.Visit(select.Having);
List <SqlOrderExpression> list2 = null;
if (select.OrderBy.Count > 0)
{
list2 = new List <SqlOrderExpression>(select.OrderBy.Count);
foreach (SqlOrderExpression expression3 in select.OrderBy)
{
SqlOrderExpression item = new SqlOrderExpression(expression3.OrderType, (SqlExpression)this.Visit(expression3.Expression));
list2.Add(item);
}
}
SqlExpression expression5 = (SqlExpression)this.Visit(select.Top);
SqlExpression expression6 = (SqlExpression)this.Visit(select.Where);
SqlRow row = (SqlRow)this.Visit(select.Row);
SqlSelect select2 = new SqlSelect(this.VisitExpression(select.Selection), from, select.SourceExpression);
if (collection != null)
{
select2.GroupBy.AddRange(collection);
}
select2.Having = expression2;
if (list2 != null)
{
select2.OrderBy.AddRange(list2);
}
select2.OrderingType = select.OrderingType;
select2.Row = row;
select2.Top = expression5;
select2.IsDistinct = select.IsDistinct;
select2.IsPercent = select.IsPercent;
select2.Where = expression6;
select2.DoNotOutput = select.DoNotOutput;
return(select2);
}
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);
}
}
}
}
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 SqlSource VisitJoin(SqlJoin join)
{
if (join.JoinType != SqlJoinType.CrossApply)
{
return(base.VisitJoin(join));
}
join.Left = this.VisitSource(join.Left);
join.Condition = this.VisitExpression(join.Condition);
SelectScope expressionSink = this.expressionSink;
this.expressionSink = new SelectScope();
this.expressionSink.LeftProduction = SqlGatherProducedAliases.Gather(join.Left).Keys;
join.Right = this.VisitSource(join.Right);
SqlSource sqlSource = join;
foreach (List <SqlColumn> list in this.expressionSink.Lifted)
{
sqlSource = this.PushSourceDown(sqlSource, list);
}
this.expressionSink = expressionSink;
return(sqlSource);
}
private static bool IsTableAlias(SqlSource src)
{
SqlAlias alias = src as SqlAlias;
return((alias != null) && (alias.Node is SqlTable));
}
internal virtual SqlSource VisitSource(SqlSource source)
{
return((SqlSource)this.Visit(source));
}
internal override SqlSource VisitSource(SqlSource source)
{
source = base.VisitSource(source);
SqlJoin node = source as SqlJoin;
if (node != null)
{
if (node.JoinType == SqlJoinType.OuterApply)
{
Dictionary <SqlAlias, bool> aliasesForLifting = SqlGatherProducedAliases.Gather(node.Left);
Dictionary <SqlExpression, bool> liftedExpressions = new Dictionary <SqlExpression, bool>();
if (
(SqlOuterApplyReducer.SqlPredicateLifter.CanLift(node.Right, aliasesForLifting,
liftedExpressions) &&
SqlOuterApplyReducer.SqlSelectionLifter.CanLift(node.Right, aliasesForLifting,
liftedExpressions)) &&
!SqlOuterApplyReducer.SqlAliasDependencyChecker.IsDependent(node.Right, aliasesForLifting,
liftedExpressions))
{
SqlExpression expression = SqlOuterApplyReducer.SqlPredicateLifter.Lift(node.Right,
aliasesForLifting);
List <List <SqlColumn> > list = SqlOuterApplyReducer.SqlSelectionLifter.Lift(node.Right,
aliasesForLifting,
liftedExpressions);
node.JoinType = SqlJoinType.LeftOuter;
node.Condition = expression;
if (list != null)
{
foreach (List <SqlColumn> list2 in list)
{
source = this.PushSourceDown(source, list2);
}
}
}
else
{
this.AnnotateSqlIncompatibility(node,
new SqlProvider.ProviderMode[]
{ SqlProvider.ProviderMode.Sql2000 });
}
}
else if (node.JoinType == SqlJoinType.CrossApply)
{
SqlJoin leftOuterWithUnreferencedSingletonOnLeft =
this.GetLeftOuterWithUnreferencedSingletonOnLeft(node.Right);
if (leftOuterWithUnreferencedSingletonOnLeft != null)
{
Dictionary <SqlAlias, bool> dictionary3 = SqlGatherProducedAliases.Gather(node.Left);
Dictionary <SqlExpression, bool> dictionary4 = new Dictionary <SqlExpression, bool>();
if (
(SqlOuterApplyReducer.SqlPredicateLifter.CanLift(
leftOuterWithUnreferencedSingletonOnLeft.Right, dictionary3, dictionary4) &&
SqlOuterApplyReducer.SqlSelectionLifter.CanLift(
leftOuterWithUnreferencedSingletonOnLeft.Right, dictionary3, dictionary4)) &&
!SqlOuterApplyReducer.SqlAliasDependencyChecker.IsDependent(
leftOuterWithUnreferencedSingletonOnLeft.Right, dictionary3, dictionary4))
{
SqlExpression right =
SqlOuterApplyReducer.SqlPredicateLifter.Lift(
leftOuterWithUnreferencedSingletonOnLeft.Right, dictionary3);
List <List <SqlColumn> > selections =
SqlOuterApplyReducer.SqlSelectionLifter.Lift(
leftOuterWithUnreferencedSingletonOnLeft.Right, dictionary3, dictionary4);
this.GetSelectionsBeforeJoin(node.Right, selections);
foreach (
List <SqlColumn> list4 in
selections.Where <List <SqlColumn> >(
delegate(List <SqlColumn> s) { return(s.Count > 0); }))
{
source = this.PushSourceDown(source, list4);
}
node.JoinType = SqlJoinType.LeftOuter;
node.Condition =
this.factory.AndAccumulate(leftOuterWithUnreferencedSingletonOnLeft.Condition, right);
node.Right = leftOuterWithUnreferencedSingletonOnLeft.Right;
}
else
{
this.AnnotateSqlIncompatibility(node,
new SqlProvider.ProviderMode[]
{ SqlProvider.ProviderMode.Sql2000 });
}
}
}
while (node.JoinType == SqlJoinType.LeftOuter)
{
SqlJoin join3 = this.GetLeftOuterWithUnreferencedSingletonOnLeft(node.Left);
if (join3 == null)
{
return(source);
}
List <List <SqlColumn> > list5 = new List <List <SqlColumn> >();
this.GetSelectionsBeforeJoin(node.Left, list5);
foreach (List <SqlColumn> list6 in list5)
{
source = this.PushSourceDown(source, list6);
}
SqlSource source2 = node.Right;
SqlExpression condition = node.Condition;
node.Left = join3.Left;
node.Right = join3;
node.Condition = join3.Condition;
join3.Left = join3.Right;
join3.Right = source2;
join3.Condition = condition;
}
}
return(source);
}
internal void BuildEqivalenceMap(SqlSource scope)
{
this.map = new Dictionary <SqlColumn, SqlColumn>();
this.Visit(scope);
}