Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / ndp / fx / src / DLinq / Dlinq / SqlClient / Query / SqlDeflator.cs / 1 / SqlDeflator.cs
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
namespace System.Data.Linq.SqlClient {
internal class SqlDeflator {
SqlValueDeflator vDeflator;
SqlColumnDeflator cDeflator;
SqlAliasDeflator aDeflator;
SqlTopSelectDeflator tsDeflator;
SqlDuplicateColumnDeflator dupColumnDeflator;
internal SqlDeflator() {
this.vDeflator = new SqlValueDeflator();
this.cDeflator = new SqlColumnDeflator();
this.aDeflator = new SqlAliasDeflator();
this.tsDeflator = new SqlTopSelectDeflator();
this.dupColumnDeflator = new SqlDuplicateColumnDeflator();
}
internal SqlNode Deflate(SqlNode node) {
node = this.vDeflator.Visit(node);
node = this.cDeflator.Visit(node);
node = this.aDeflator.Visit(node);
node = this.tsDeflator.Visit(node);
node = this.dupColumnDeflator.Visit(node);
return node;
}
// remove references to literal values
class SqlValueDeflator : SqlVisitor {
SelectionDeflator sDeflator;
bool isTopLevel = true;
internal SqlValueDeflator() {
this.sDeflator = new SelectionDeflator();
}
internal override SqlSelect VisitSelect(SqlSelect select) {
if (this.isTopLevel) {
select.Selection = sDeflator.VisitExpression(select.Selection);
}
return select;
}
internal override SqlExpression VisitSubSelect(SqlSubSelect ss) {
bool saveIsTopLevel = this.isTopLevel;
try {
return base.VisitSubSelect(ss);
}
finally {
this.isTopLevel = saveIsTopLevel;
}
}
class SelectionDeflator : SqlVisitor {
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
SqlExpression literal = this.GetLiteralValue(cref);
if (literal != null) {
return literal;
}
return cref;
}
private SqlValue GetLiteralValue(SqlExpression expr) {
while (expr != null && expr.NodeType == SqlNodeType.ColumnRef) {
expr = ((SqlColumnRef)expr).Column.Expression;
}
return expr as SqlValue;
}
}
}
// remove unreferenced items in projection list
class SqlColumnDeflator : SqlVisitor {
Dictionary referenceMap;
bool isTopLevel;
bool forceReferenceAll;
SqlAggregateChecker aggregateChecker;
internal SqlColumnDeflator() {
this.referenceMap = new Dictionary();
this.aggregateChecker = new SqlAggregateChecker();
this.isTopLevel = true;
}
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
this.referenceMap[cref.Column] = cref.Column;
return cref;
}
internal override SqlExpression VisitScalarSubSelect(SqlSubSelect ss) {
bool saveIsTopLevel = this.isTopLevel;
this.isTopLevel = false;
bool saveForceReferenceAll = this.forceReferenceAll;
this.forceReferenceAll = true;
try {
return base.VisitScalarSubSelect(ss);
}
finally {
this.isTopLevel = saveIsTopLevel;
this.forceReferenceAll = saveForceReferenceAll;
}
}
internal override SqlExpression VisitExists(SqlSubSelect ss) {
bool saveIsTopLevel = this.isTopLevel;
this.isTopLevel = false;
try {
return base.VisitExists(ss);
}
finally {
this.isTopLevel = saveIsTopLevel;
}
}
internal override SqlNode VisitUnion(SqlUnion su) {
bool saveForceReferenceAll = this.forceReferenceAll;
this.forceReferenceAll = true;
su.Left = this.Visit(su.Left);
su.Right = this.Visit(su.Right);
this.forceReferenceAll = saveForceReferenceAll;
return su;
}
internal override SqlSelect VisitSelect(SqlSelect select) {
bool saveForceReferenceAll = this.forceReferenceAll;
this.forceReferenceAll = false;
bool saveIsTopLevel = this.isTopLevel;
try {
if (this.isTopLevel) {
// top-level projection references columns!
select.Selection = this.VisitExpression(select.Selection);
}
this.isTopLevel = false;
for (int i = select.Row.Columns.Count - 1; i >= 0; i--) {
SqlColumn c = select.Row.Columns[i];
bool safeToRemove =
!saveForceReferenceAll
&& !this.referenceMap.ContainsKey(c)
// don't remove anything from a distinct select (except maybe a literal value) since it would change the meaning of the comparison
&& !select.IsDistinct
// don't remove an aggregate expression that may be the only expression that forces the grouping (since it would change the cardinality of the results)
&& !(select.GroupBy.Count == 0 && this.aggregateChecker.HasAggregates(c.Expression));
if (safeToRemove) {
select.Row.Columns.RemoveAt(i);
}
else {
this.VisitExpression(c.Expression);
}
}
select.Top = this.VisitExpression(select.Top);
for (int i = select.OrderBy.Count - 1; i >= 0; i--) {
select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
}
select.Having = this.VisitExpression(select.Having);
for (int i = select.GroupBy.Count - 1; i >= 0; i--) {
select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
}
select.Where = this.VisitExpression(select.Where);
select.From = this.VisitSource(select.From);
}
finally {
this.isTopLevel = saveIsTopLevel;
this.forceReferenceAll = saveForceReferenceAll;
}
return select;
}
internal override SqlSource VisitJoin(SqlJoin join) {
join.Condition = this.VisitExpression(join.Condition);
join.Right = this.VisitSource(join.Right);
join.Left = this.VisitSource(join.Left);
return join;
}
internal override SqlNode VisitLink(SqlLink link) {
// don't visit expansion...
for (int i = 0, n = link.KeyExpressions.Count; i < n; i++) {
link.KeyExpressions[i] = this.VisitExpression(link.KeyExpressions[i]);
}
return link;
}
}
class SqlColumnEqualizer : SqlVisitor {
Dictionary map;
internal SqlColumnEqualizer() {
}
internal void BuildEqivalenceMap(SqlSource scope) {
this.map = new Dictionary();
this.Visit(scope);
}
internal bool AreEquivalent(SqlExpression e1, SqlExpression e2) {
if (SqlComparer.AreEqual(e1, e2))
return true;
SqlColumnRef cr1 = e1 as SqlColumnRef;
SqlColumnRef cr2 = e2 as SqlColumnRef;
if (cr1 != null && cr2 != null) {
SqlColumn c1 = cr1.GetRootColumn();
SqlColumn c2 = cr2.GetRootColumn();
SqlColumn r;
return this.map.TryGetValue(c1, out r) && r == c2;
}
return false;
}
internal override SqlSource VisitJoin(SqlJoin join) {
base.VisitJoin(join);
if (join.Condition != null) {
this.CheckJoinCondition(join.Condition);
}
return join;
}
internal override SqlSelect VisitSelect(SqlSelect select) {
base.VisitSelect(select);
if (select.Where != null) {
this.CheckJoinCondition(select.Where);
}
return select;
}
[SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification="[....]: Cast is dependent on node type and casts do not happen unecessarily in a single code path.")]
private void CheckJoinCondition(SqlExpression expr) {
switch (expr.NodeType) {
case SqlNodeType.And: {
SqlBinary b = (SqlBinary)expr;
CheckJoinCondition(b.Left);
CheckJoinCondition(b.Right);
break;
}
case SqlNodeType.EQ:
case SqlNodeType.EQ2V: {
SqlBinary b = (SqlBinary)expr;
SqlColumnRef crLeft = b.Left as SqlColumnRef;
SqlColumnRef crRight = b.Right as SqlColumnRef;
if (crLeft != null && crRight != null) {
SqlColumn cLeft = crLeft.GetRootColumn();
SqlColumn cRight = crRight.GetRootColumn();
this.map[cLeft] = cRight;
this.map[cRight] = cLeft;
}
break;
}
}
}
internal override SqlExpression VisitSubSelect(SqlSubSelect ss) {
return ss;
}
}
// remove redundant/trivial aliases
class SqlAliasDeflator : SqlVisitor {
Dictionary removedMap;
internal SqlAliasDeflator() {
this.removedMap = new Dictionary();
}
internal override SqlExpression VisitAliasRef(SqlAliasRef aref) {
SqlAlias alias = aref.Alias;
SqlAlias value;
if (this.removedMap.TryGetValue(alias, out value)) {
throw Error.InvalidReferenceToRemovedAliasDuringDeflation();
}
return aref;
}
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
if (cref.Column.Alias != null && this.removedMap.ContainsKey(cref.Column.Alias)) {
SqlColumnRef c = cref.Column.Expression as SqlColumnRef;
if (c != null) {
//The following code checks for cases where there are differences between the type returned
//by a ColumnRef and the column that refers to it. This situation can occur when conversions
//are optimized out of the SQL node tree. As mentioned in the SetClrType comments this is not
//an operation that can have adverse effects and should only be used in limited cases, such as
//this one.
if (c.ClrType != cref.ClrType) {
c.SetClrType(cref.ClrType);
return this.VisitColumnRef(c);
}
}
return c;
}
return cref;
}
internal override SqlSource VisitSource(SqlSource node) {
node = (SqlSource)this.Visit(node);
SqlAlias alias = node as SqlAlias;
if (alias != null) {
SqlSelect sel = alias.Node as SqlSelect;
if (sel != null && this.IsTrivialSelect(sel)) {
this.removedMap[alias] = alias;
node = sel.From;
}
}
return node;
}
internal override SqlSource VisitJoin(SqlJoin join) {
base.VisitJoin(join);
switch (join.JoinType) {
case SqlJoinType.Cross:
case SqlJoinType.Inner:
// reducing either side would effect cardinality of results
break;
case SqlJoinType.LeftOuter:
case SqlJoinType.CrossApply:
case SqlJoinType.OuterApply:
// may reduce to left if no references to the right
if (this.HasEmptySource(join.Right)) {
SqlAlias a = (SqlAlias)join.Right;
this.removedMap[a] = a;
return join.Left;
}
break;
}
return join;
}
private bool IsTrivialSelect(SqlSelect select) {
if (select.OrderBy.Count != 0 ||
select.GroupBy.Count != 0 ||
select.Having != null ||
select.Top != null ||
select.IsDistinct ||
select.Where != null)
return false;
return this.HasTrivialSource(select.From) && this.HasTrivialProjection(select);
}
private bool HasTrivialSource(SqlSource node) {
SqlJoin join = node as SqlJoin;
if (join != null) {
return this.HasTrivialSource(join.Left) &&
this.HasTrivialSource(join.Right);
}
return node is SqlAlias;
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private bool HasTrivialProjection(SqlSelect select) {
foreach (SqlColumn c in select.Row.Columns) {
if (c.Expression != null && c.Expression.NodeType != SqlNodeType.ColumnRef) {
return false;
}
}
return true;
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private bool HasEmptySource(SqlSource node) {
SqlAlias alias = node as SqlAlias;
if (alias == null) return false;
SqlSelect sel = alias.Node as SqlSelect;
if (sel == null) return false;
return sel.Row.Columns.Count == 0 &&
sel.From == null &&
sel.Where == null &&
sel.GroupBy.Count == 0 &&
sel.Having == null &&
sel.OrderBy.Count == 0;
}
}
// remove duplicate columns from order by and group by lists
class SqlDuplicateColumnDeflator : SqlVisitor
{
SqlColumnEqualizer equalizer = new SqlColumnEqualizer();
internal override SqlSelect VisitSelect(SqlSelect select) {
select.From = this.VisitSource(select.From);
select.Where = this.VisitExpression(select.Where);
for (int i = 0, n = select.GroupBy.Count; i < n; i++)
{
select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
}
// remove duplicate group expressions
for (int i = select.GroupBy.Count - 1; i >= 0; i--)
{
for (int j = i - 1; j >= 0; j--)
{
if (SqlComparer.AreEqual(select.GroupBy[i], select.GroupBy[j]))
{
select.GroupBy.RemoveAt(i);
break;
}
}
}
select.Having = this.VisitExpression(select.Having);
for (int i = 0, n = select.OrderBy.Count; i < n; i++)
{
select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
}
// remove duplicate order expressions
if (select.OrderBy.Count > 0)
{
this.equalizer.BuildEqivalenceMap(select.From);
for (int i = select.OrderBy.Count - 1; i >= 0; i--)
{
for (int j = i - 1; j >= 0; j--)
{
if (this.equalizer.AreEquivalent(select.OrderBy[i].Expression, select.OrderBy[j].Expression))
{
select.OrderBy.RemoveAt(i);
break;
}
}
}
}
select.Top = this.VisitExpression(select.Top);
select.Row = (SqlRow)this.Visit(select.Row);
select.Selection = this.VisitExpression(select.Selection);
return select;
}
}
// if the top level select is simply a reprojection of the subquery, then remove it,
// pushing any distinct names down
class SqlTopSelectDeflator : SqlVisitor {
internal override SqlSelect VisitSelect(SqlSelect select) {
if (IsTrivialSelect(select)) {
SqlSelect aselect = (SqlSelect)((SqlAlias)select.From).Node;
// build up a column map, so we can rewrite the top-level selection expression
Dictionary map = new Dictionary();
foreach (SqlColumn c in select.Row.Columns) {
SqlColumnRef cref = (SqlColumnRef)c.Expression;
map.Add(c, cref);
// push the interesting column names down (non null)
if (!string.IsNullOrEmpty(c.Name)) {
cref.Column.Name = c.Name;
}
}
aselect.Selection = new ColumnMapper(map).VisitExpression(select.Selection);
return aselect;
}
return select;
}
private bool IsTrivialSelect(SqlSelect select) {
if (select.OrderBy.Count != 0 ||
select.GroupBy.Count != 0 ||
select.Having != null ||
select.Top != null ||
select.IsDistinct ||
select.Where != null)
return false;
return this.HasTrivialSource(select.From) && this.HasTrivialProjection(select);
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private bool HasTrivialSource(SqlSource node) {
SqlAlias alias = node as SqlAlias;
if (alias == null) return false;
return alias.Node is SqlSelect;
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private bool HasTrivialProjection(SqlSelect select) {
foreach (SqlColumn c in select.Row.Columns) {
if (c.Expression != null && c.Expression.NodeType != SqlNodeType.ColumnRef) {
return false;
}
}
return true;
}
class ColumnMapper : SqlVisitor {
Dictionary map;
internal ColumnMapper(Dictionary map) {
this.map = map;
}
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
SqlColumnRef mapped;
if (this.map.TryGetValue(cref.Column, out mapped)) {
return mapped;
}
return cref;
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
namespace System.Data.Linq.SqlClient {
internal class SqlDeflator {
SqlValueDeflator vDeflator;
SqlColumnDeflator cDeflator;
SqlAliasDeflator aDeflator;
SqlTopSelectDeflator tsDeflator;
SqlDuplicateColumnDeflator dupColumnDeflator;
internal SqlDeflator() {
this.vDeflator = new SqlValueDeflator();
this.cDeflator = new SqlColumnDeflator();
this.aDeflator = new SqlAliasDeflator();
this.tsDeflator = new SqlTopSelectDeflator();
this.dupColumnDeflator = new SqlDuplicateColumnDeflator();
}
internal SqlNode Deflate(SqlNode node) {
node = this.vDeflator.Visit(node);
node = this.cDeflator.Visit(node);
node = this.aDeflator.Visit(node);
node = this.tsDeflator.Visit(node);
node = this.dupColumnDeflator.Visit(node);
return node;
}
// remove references to literal values
class SqlValueDeflator : SqlVisitor {
SelectionDeflator sDeflator;
bool isTopLevel = true;
internal SqlValueDeflator() {
this.sDeflator = new SelectionDeflator();
}
internal override SqlSelect VisitSelect(SqlSelect select) {
if (this.isTopLevel) {
select.Selection = sDeflator.VisitExpression(select.Selection);
}
return select;
}
internal override SqlExpression VisitSubSelect(SqlSubSelect ss) {
bool saveIsTopLevel = this.isTopLevel;
try {
return base.VisitSubSelect(ss);
}
finally {
this.isTopLevel = saveIsTopLevel;
}
}
class SelectionDeflator : SqlVisitor {
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
SqlExpression literal = this.GetLiteralValue(cref);
if (literal != null) {
return literal;
}
return cref;
}
private SqlValue GetLiteralValue(SqlExpression expr) {
while (expr != null && expr.NodeType == SqlNodeType.ColumnRef) {
expr = ((SqlColumnRef)expr).Column.Expression;
}
return expr as SqlValue;
}
}
}
// remove unreferenced items in projection list
class SqlColumnDeflator : SqlVisitor {
Dictionary referenceMap;
bool isTopLevel;
bool forceReferenceAll;
SqlAggregateChecker aggregateChecker;
internal SqlColumnDeflator() {
this.referenceMap = new Dictionary();
this.aggregateChecker = new SqlAggregateChecker();
this.isTopLevel = true;
}
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
this.referenceMap[cref.Column] = cref.Column;
return cref;
}
internal override SqlExpression VisitScalarSubSelect(SqlSubSelect ss) {
bool saveIsTopLevel = this.isTopLevel;
this.isTopLevel = false;
bool saveForceReferenceAll = this.forceReferenceAll;
this.forceReferenceAll = true;
try {
return base.VisitScalarSubSelect(ss);
}
finally {
this.isTopLevel = saveIsTopLevel;
this.forceReferenceAll = saveForceReferenceAll;
}
}
internal override SqlExpression VisitExists(SqlSubSelect ss) {
bool saveIsTopLevel = this.isTopLevel;
this.isTopLevel = false;
try {
return base.VisitExists(ss);
}
finally {
this.isTopLevel = saveIsTopLevel;
}
}
internal override SqlNode VisitUnion(SqlUnion su) {
bool saveForceReferenceAll = this.forceReferenceAll;
this.forceReferenceAll = true;
su.Left = this.Visit(su.Left);
su.Right = this.Visit(su.Right);
this.forceReferenceAll = saveForceReferenceAll;
return su;
}
internal override SqlSelect VisitSelect(SqlSelect select) {
bool saveForceReferenceAll = this.forceReferenceAll;
this.forceReferenceAll = false;
bool saveIsTopLevel = this.isTopLevel;
try {
if (this.isTopLevel) {
// top-level projection references columns!
select.Selection = this.VisitExpression(select.Selection);
}
this.isTopLevel = false;
for (int i = select.Row.Columns.Count - 1; i >= 0; i--) {
SqlColumn c = select.Row.Columns[i];
bool safeToRemove =
!saveForceReferenceAll
&& !this.referenceMap.ContainsKey(c)
// don't remove anything from a distinct select (except maybe a literal value) since it would change the meaning of the comparison
&& !select.IsDistinct
// don't remove an aggregate expression that may be the only expression that forces the grouping (since it would change the cardinality of the results)
&& !(select.GroupBy.Count == 0 && this.aggregateChecker.HasAggregates(c.Expression));
if (safeToRemove) {
select.Row.Columns.RemoveAt(i);
}
else {
this.VisitExpression(c.Expression);
}
}
select.Top = this.VisitExpression(select.Top);
for (int i = select.OrderBy.Count - 1; i >= 0; i--) {
select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
}
select.Having = this.VisitExpression(select.Having);
for (int i = select.GroupBy.Count - 1; i >= 0; i--) {
select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
}
select.Where = this.VisitExpression(select.Where);
select.From = this.VisitSource(select.From);
}
finally {
this.isTopLevel = saveIsTopLevel;
this.forceReferenceAll = saveForceReferenceAll;
}
return select;
}
internal override SqlSource VisitJoin(SqlJoin join) {
join.Condition = this.VisitExpression(join.Condition);
join.Right = this.VisitSource(join.Right);
join.Left = this.VisitSource(join.Left);
return join;
}
internal override SqlNode VisitLink(SqlLink link) {
// don't visit expansion...
for (int i = 0, n = link.KeyExpressions.Count; i < n; i++) {
link.KeyExpressions[i] = this.VisitExpression(link.KeyExpressions[i]);
}
return link;
}
}
class SqlColumnEqualizer : SqlVisitor {
Dictionary map;
internal SqlColumnEqualizer() {
}
internal void BuildEqivalenceMap(SqlSource scope) {
this.map = new Dictionary();
this.Visit(scope);
}
internal bool AreEquivalent(SqlExpression e1, SqlExpression e2) {
if (SqlComparer.AreEqual(e1, e2))
return true;
SqlColumnRef cr1 = e1 as SqlColumnRef;
SqlColumnRef cr2 = e2 as SqlColumnRef;
if (cr1 != null && cr2 != null) {
SqlColumn c1 = cr1.GetRootColumn();
SqlColumn c2 = cr2.GetRootColumn();
SqlColumn r;
return this.map.TryGetValue(c1, out r) && r == c2;
}
return false;
}
internal override SqlSource VisitJoin(SqlJoin join) {
base.VisitJoin(join);
if (join.Condition != null) {
this.CheckJoinCondition(join.Condition);
}
return join;
}
internal override SqlSelect VisitSelect(SqlSelect select) {
base.VisitSelect(select);
if (select.Where != null) {
this.CheckJoinCondition(select.Where);
}
return select;
}
[SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification="[....]: Cast is dependent on node type and casts do not happen unecessarily in a single code path.")]
private void CheckJoinCondition(SqlExpression expr) {
switch (expr.NodeType) {
case SqlNodeType.And: {
SqlBinary b = (SqlBinary)expr;
CheckJoinCondition(b.Left);
CheckJoinCondition(b.Right);
break;
}
case SqlNodeType.EQ:
case SqlNodeType.EQ2V: {
SqlBinary b = (SqlBinary)expr;
SqlColumnRef crLeft = b.Left as SqlColumnRef;
SqlColumnRef crRight = b.Right as SqlColumnRef;
if (crLeft != null && crRight != null) {
SqlColumn cLeft = crLeft.GetRootColumn();
SqlColumn cRight = crRight.GetRootColumn();
this.map[cLeft] = cRight;
this.map[cRight] = cLeft;
}
break;
}
}
}
internal override SqlExpression VisitSubSelect(SqlSubSelect ss) {
return ss;
}
}
// remove redundant/trivial aliases
class SqlAliasDeflator : SqlVisitor {
Dictionary removedMap;
internal SqlAliasDeflator() {
this.removedMap = new Dictionary();
}
internal override SqlExpression VisitAliasRef(SqlAliasRef aref) {
SqlAlias alias = aref.Alias;
SqlAlias value;
if (this.removedMap.TryGetValue(alias, out value)) {
throw Error.InvalidReferenceToRemovedAliasDuringDeflation();
}
return aref;
}
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
if (cref.Column.Alias != null && this.removedMap.ContainsKey(cref.Column.Alias)) {
SqlColumnRef c = cref.Column.Expression as SqlColumnRef;
if (c != null) {
//The following code checks for cases where there are differences between the type returned
//by a ColumnRef and the column that refers to it. This situation can occur when conversions
//are optimized out of the SQL node tree. As mentioned in the SetClrType comments this is not
//an operation that can have adverse effects and should only be used in limited cases, such as
//this one.
if (c.ClrType != cref.ClrType) {
c.SetClrType(cref.ClrType);
return this.VisitColumnRef(c);
}
}
return c;
}
return cref;
}
internal override SqlSource VisitSource(SqlSource node) {
node = (SqlSource)this.Visit(node);
SqlAlias alias = node as SqlAlias;
if (alias != null) {
SqlSelect sel = alias.Node as SqlSelect;
if (sel != null && this.IsTrivialSelect(sel)) {
this.removedMap[alias] = alias;
node = sel.From;
}
}
return node;
}
internal override SqlSource VisitJoin(SqlJoin join) {
base.VisitJoin(join);
switch (join.JoinType) {
case SqlJoinType.Cross:
case SqlJoinType.Inner:
// reducing either side would effect cardinality of results
break;
case SqlJoinType.LeftOuter:
case SqlJoinType.CrossApply:
case SqlJoinType.OuterApply:
// may reduce to left if no references to the right
if (this.HasEmptySource(join.Right)) {
SqlAlias a = (SqlAlias)join.Right;
this.removedMap[a] = a;
return join.Left;
}
break;
}
return join;
}
private bool IsTrivialSelect(SqlSelect select) {
if (select.OrderBy.Count != 0 ||
select.GroupBy.Count != 0 ||
select.Having != null ||
select.Top != null ||
select.IsDistinct ||
select.Where != null)
return false;
return this.HasTrivialSource(select.From) && this.HasTrivialProjection(select);
}
private bool HasTrivialSource(SqlSource node) {
SqlJoin join = node as SqlJoin;
if (join != null) {
return this.HasTrivialSource(join.Left) &&
this.HasTrivialSource(join.Right);
}
return node is SqlAlias;
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private bool HasTrivialProjection(SqlSelect select) {
foreach (SqlColumn c in select.Row.Columns) {
if (c.Expression != null && c.Expression.NodeType != SqlNodeType.ColumnRef) {
return false;
}
}
return true;
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private bool HasEmptySource(SqlSource node) {
SqlAlias alias = node as SqlAlias;
if (alias == null) return false;
SqlSelect sel = alias.Node as SqlSelect;
if (sel == null) return false;
return sel.Row.Columns.Count == 0 &&
sel.From == null &&
sel.Where == null &&
sel.GroupBy.Count == 0 &&
sel.Having == null &&
sel.OrderBy.Count == 0;
}
}
// remove duplicate columns from order by and group by lists
class SqlDuplicateColumnDeflator : SqlVisitor
{
SqlColumnEqualizer equalizer = new SqlColumnEqualizer();
internal override SqlSelect VisitSelect(SqlSelect select) {
select.From = this.VisitSource(select.From);
select.Where = this.VisitExpression(select.Where);
for (int i = 0, n = select.GroupBy.Count; i < n; i++)
{
select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
}
// remove duplicate group expressions
for (int i = select.GroupBy.Count - 1; i >= 0; i--)
{
for (int j = i - 1; j >= 0; j--)
{
if (SqlComparer.AreEqual(select.GroupBy[i], select.GroupBy[j]))
{
select.GroupBy.RemoveAt(i);
break;
}
}
}
select.Having = this.VisitExpression(select.Having);
for (int i = 0, n = select.OrderBy.Count; i < n; i++)
{
select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
}
// remove duplicate order expressions
if (select.OrderBy.Count > 0)
{
this.equalizer.BuildEqivalenceMap(select.From);
for (int i = select.OrderBy.Count - 1; i >= 0; i--)
{
for (int j = i - 1; j >= 0; j--)
{
if (this.equalizer.AreEquivalent(select.OrderBy[i].Expression, select.OrderBy[j].Expression))
{
select.OrderBy.RemoveAt(i);
break;
}
}
}
}
select.Top = this.VisitExpression(select.Top);
select.Row = (SqlRow)this.Visit(select.Row);
select.Selection = this.VisitExpression(select.Selection);
return select;
}
}
// if the top level select is simply a reprojection of the subquery, then remove it,
// pushing any distinct names down
class SqlTopSelectDeflator : SqlVisitor {
internal override SqlSelect VisitSelect(SqlSelect select) {
if (IsTrivialSelect(select)) {
SqlSelect aselect = (SqlSelect)((SqlAlias)select.From).Node;
// build up a column map, so we can rewrite the top-level selection expression
Dictionary map = new Dictionary();
foreach (SqlColumn c in select.Row.Columns) {
SqlColumnRef cref = (SqlColumnRef)c.Expression;
map.Add(c, cref);
// push the interesting column names down (non null)
if (!string.IsNullOrEmpty(c.Name)) {
cref.Column.Name = c.Name;
}
}
aselect.Selection = new ColumnMapper(map).VisitExpression(select.Selection);
return aselect;
}
return select;
}
private bool IsTrivialSelect(SqlSelect select) {
if (select.OrderBy.Count != 0 ||
select.GroupBy.Count != 0 ||
select.Having != null ||
select.Top != null ||
select.IsDistinct ||
select.Where != null)
return false;
return this.HasTrivialSource(select.From) && this.HasTrivialProjection(select);
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private bool HasTrivialSource(SqlSource node) {
SqlAlias alias = node as SqlAlias;
if (alias == null) return false;
return alias.Node is SqlSelect;
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private bool HasTrivialProjection(SqlSelect select) {
foreach (SqlColumn c in select.Row.Columns) {
if (c.Expression != null && c.Expression.NodeType != SqlNodeType.ColumnRef) {
return false;
}
}
return true;
}
class ColumnMapper : SqlVisitor {
Dictionary map;
internal ColumnMapper(Dictionary map) {
this.map = map;
}
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
SqlColumnRef mapped;
if (this.map.TryGetValue(cref.Column, out mapped)) {
return mapped;
}
return cref;
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- TextReader.cs
- DataComponentNameHandler.cs
- PackWebRequest.cs
- TypeExtensionConverter.cs
- SHA1Managed.cs
- OleDbParameter.cs
- XmlValidatingReader.cs
- Floater.cs
- RayMeshGeometry3DHitTestResult.cs
- RootBrowserWindow.cs
- SrgsSemanticInterpretationTag.cs
- ReadOnlyActivityGlyph.cs
- HandledEventArgs.cs
- CodeNamespaceImportCollection.cs
- XsdBuilder.cs
- DnsPermission.cs
- OutputChannel.cs
- XmlSchemaDatatype.cs
- RC2.cs
- SimpleHandlerFactory.cs
- ClientSettings.cs
- RepeaterCommandEventArgs.cs
- ProcessInfo.cs
- ImageMap.cs
- PlaceHolder.cs
- XmlSchemaImport.cs
- AccessedThroughPropertyAttribute.cs
- OracleSqlParser.cs
- VisualBasicImportReference.cs
- BitmapEffectOutputConnector.cs
- AttachedAnnotationChangedEventArgs.cs
- TextParentUndoUnit.cs
- SamlConditions.cs
- MenuCommands.cs
- RuleDefinitions.cs
- DataGridCell.cs
- ListItem.cs
- ImageMap.cs
- FrameworkElement.cs
- InputLanguageSource.cs
- WebHttpBindingElement.cs
- SynchronizedInputAdaptor.cs
- FormatterConverter.cs
- TextLine.cs
- ServerType.cs
- EntityClassGenerator.cs
- IResourceProvider.cs
- TreeNodeStyleCollection.cs
- RealizationDrawingContextWalker.cs
- TCPListener.cs
- XPathNavigatorKeyComparer.cs
- HtmlInputCheckBox.cs
- Constants.cs
- Propagator.cs
- SerialPinChanges.cs
- TypeSystem.cs
- DomainUpDown.cs
- OutputCacheModule.cs
- OverflowException.cs
- JoinQueryOperator.cs
- CommandBindingCollection.cs
- HwndAppCommandInputProvider.cs
- StylusLogic.cs
- CodeGotoStatement.cs
- HttpStreamMessageEncoderFactory.cs
- SchemaImporter.cs
- EventHandlersDesigner.cs
- TreeNodeSelectionProcessor.cs
- ComboBoxRenderer.cs
- XPathScanner.cs
- ListBoxAutomationPeer.cs
- TextTreeNode.cs
- InplaceBitmapMetadataWriter.cs
- TypeCodeDomSerializer.cs
- HtmlTableRow.cs
- XmlDomTextWriter.cs
- BlurBitmapEffect.cs
- PasswordRecovery.cs
- AsyncStreamReader.cs
- AuthenticationModuleElementCollection.cs
- validationstate.cs
- SiteMapDataSourceDesigner.cs
- ModifyActivitiesPropertyDescriptor.cs
- StartFileNameEditor.cs
- MultiBinding.cs
- DefaultValueConverter.cs
- WorkflowRuntimeEndpoint.cs
- BindingGroup.cs
- SymbolPair.cs
- TraceInternal.cs
- WebPartEditorApplyVerb.cs
- WindowsButton.cs
- SqlSelectClauseBuilder.cs
- ArraySegment.cs
- QuaternionValueSerializer.cs
- ApplicationHost.cs
- CommandHelper.cs
- XhtmlConformanceSection.cs
- RequestCachePolicyConverter.cs
- LiteralText.cs