/// <summary>
/// Execute each current validator.
/// </summary>
internal void Validate(SqlNode node)
{
foreach(SqlVisitor validator in this.validators)
{
validator.Visit(node);
}
}
internal override SqlNode Visit(SqlNode node) {
node = base.Visit(node);
if (node != null) {
node.ClearSourceExpression();
}
return node;
}
internal SqlColumn BubbleUp(SqlColumn col, SqlNode source)
{
this.match = this.GetOriginatingColumn(col);
this.found = null;
this.Visit(source);
return this.found;
}
internal override SqlNode Visit(SqlNode node) {
// Short-circuit when the answer is alreading known
if (this.referencesAnyMatchingAliases) {
return node;
}
return base.Visit(node);
}
internal SqlUnion(SqlNode left, SqlNode right, bool all)
: base(SqlNodeType.Union, right.SourceExpression)
{
this.Left = left;
this.Right = right;
this.All = all;
}
private static ProviderType GetSqlType(SqlNode node)
{
SqlExpression exp = node as SqlExpression;
if (exp != null)
{
return(exp.SqlType);
}
SqlSelect sel = node as SqlSelect;
if (sel != null)
{
return(sel.Selection.SqlType);
}
SqlTable tab = node as SqlTable;
if (tab != null)
{
return(tab.SqlRowType);
}
SqlUnion su = node as SqlUnion;
if (su != null)
{
return(su.GetSqlType());
}
throw Error.UnexpectedNode(node.NodeType);
}
internal override SqlNode Visit(SqlNode node) {
if (node == null)
return null;
sourceExpression = node as SqlExpression;
if (sourceExpression != null) {
Type type = sourceExpression.ClrType;
UnwrapStack unwrap = this.UnwrapSequences;
while (unwrap != null) {
if (unwrap.Unwrap) {
type = TypeSystem.GetElementType(type);
}
unwrap = unwrap.Last;
}
sourceType = type;
}
if (sourceType != null && TypeSystem.GetNonNullableType(sourceType).IsValueType) {
return node; // Value types can't also have a dynamic type.
}
if (sourceType != null && TypeSystem.HasIEnumerable(sourceType)) {
return node; // Sequences can't be polymorphic.
}
switch (node.NodeType) {
case SqlNodeType.ScalarSubSelect:
case SqlNodeType.Multiset:
case SqlNodeType.Element:
case SqlNodeType.SearchedCase:
case SqlNodeType.ClientCase:
case SqlNodeType.SimpleCase:
case SqlNodeType.Member:
case SqlNodeType.DiscriminatedType:
case SqlNodeType.New:
case SqlNodeType.FunctionCall:
case SqlNodeType.MethodCall:
case SqlNodeType.Convert: // Object identity does not survive convert. It does survive Cast.
// Dig no further.
return node;
case SqlNodeType.TypeCase:
sourceType = ((SqlTypeCase)node).RowType.Type;
return node;
case SqlNodeType.Link:
sourceType = ((SqlLink)node).RowType.Type;
return node;
case SqlNodeType.Table:
sourceType = ((SqlTable)node).RowType.Type;
return node;
case SqlNodeType.Value:
SqlValue val = (SqlValue)node;
if (val.Value != null) {
// In some cases the ClrType of a Value node may
// differ from the actual runtime type of the value.
// Therefore, we ensure here that the correct type is set.
sourceType = val.Value.GetType();
}
return node;
}
return base.Visit(node);
}
internal QueryInfo(SqlNode query, string commandText, ReadOnlyCollection<SqlParameterInfo> parameters, ResultShape resultShape, Type resultType)
{
this.query = query;
this.commandText = commandText;
this.parameters = parameters;
this.resultShape = resultShape;
this.resultType = resultType;
}
internal SqlNode Deflate(SqlNode node)
{
node = _valueDeflator.Visit(node);
node = _columnDeflator.Visit(node);
node = _aliasDeflator.Visit(node);
node = _topselectDeflator.Visit(node);
node = _duplicateColumnDeflator.Visit(node);
return node;
}
internal override SqlNode Visit(SqlNode node)
{
// recurse until we know we're invalid
if(_isValid && node != null)
{
return base.Visit(node);
}
return node;
}
internal override SqlNode Visit(SqlNode node)
{
SqlExpression e = node as SqlExpression;
if(this.hasDependency)
return node;
if(e != null && this.ignoreExpressions.Contains(e))
{
return node;
}
return base.Visit(node);
}
private void Validate(SqlNode node)
{
if (node == null)
{
throw Error.ArgumentNull("node");
}
if (!(node is SqlExpression || node is SqlSelect || node is SqlUnion))
{
throw Error.UnexpectedNode(node.NodeType);
}
}
internal string Format(SqlNode node, bool isDebug)
{
_commandStringBuilder = new StringBuilder();
_isDebugMode = isDebug;
_aliasMap.Clear();
if(isDebug)
{
new AliasMapper(_aliasMap).Visit(node);
}
this.Visit(node);
return _commandStringBuilder.ToString();
}
/// <summary>
/// Add an annotation to the given node.
/// </summary>
internal void Add(SqlNode node, SqlNodeAnnotation annotation)
{
List<SqlNodeAnnotation> list = null;
if(!this.annotationMap.TryGetValue(node, out list))
{
list = new List<SqlNodeAnnotation>();
this.annotationMap[node] = list;
}
uniqueTypes[annotation.GetType()] = String.Empty;
list.Add(annotation);
}
internal override SqlNode Visit(SqlNode node)
{
if(annotations.NodeIsAnnotated(node))
{
foreach(SqlNodeAnnotation annotation in annotations.Get(node))
{
CompatibilityAnnotation ssca = annotation as CompatibilityAnnotation;
if(ssca != null && ssca.AppliesTo(_providerMode))
{
reasons.Add(annotation.Message);
}
}
}
return base.Visit(node);
}
/// <summary>
/// Checks whether the given node is supported on the given server.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="annotations">The annotations.</param>
/// <param name="providerMode">The provider mode to check for.</param>
internal static void ThrowIfUnsupported(SqlNode node, SqlNodeAnnotations annotations, Enum providerMode)
{
// Check to see whether there's at least one SqlServerCompatibilityAnnotation.
if(annotations.HasAnnotationType(typeof(CompatibilityAnnotation)))
{
Visitor visitor = new Visitor(providerMode) {annotations = annotations};
visitor.Visit(node);
// If any messages were recorded, then throw an exception.
if(visitor.reasons.Count > 0)
{
throw Error.ExpressionNotSupportedForSqlServerVersion(visitor.reasons);
}
}
}
private static ProviderType GetSqlType(SqlNode node) {
SqlExpression exp = node as SqlExpression;
if (exp != null)
return exp.SqlType;
SqlSelect sel = node as SqlSelect;
if (sel != null)
return sel.Selection.SqlType;
SqlTable tab = node as SqlTable;
if (tab != null)
return tab.SqlRowType;
SqlUnion su = node as SqlUnion;
if (su != null)
return su.GetSqlType();
throw Error.UnexpectedNode(node.NodeType);
}
internal override SqlNode Visit(SqlNode node)
{
if(node == null)
{
return null;
}
SqlNode result = null;
if(this.nodeMap.TryGetValue(node, out result))
{
return result;
}
result = base.Visit(node);
this.nodeMap[node] = result;
return result;
}
internal static SqlNode Copy(SqlNode node)
{
if(node == null)
return null;
switch(node.NodeType)
{
case SqlNodeType.ColumnRef:
case SqlNodeType.Value:
case SqlNodeType.Parameter:
case SqlNodeType.Variable:
return node;
default:
return new SqlDuplicator().Duplicate(node);
}
}
internal override SqlNode Visit(SqlNode node) {
SqlExpression expr = node as SqlExpression;
if (expr != null) {
if (this.candidates.Contains(expr)) {
if (expr.NodeType == SqlNodeType.Column ||
expr.NodeType == SqlNodeType.ColumnRef) {
return expr;
}
else {
return new SqlColumn(expr.ClrType, expr.SqlType, null, null, expr, expr.SourceExpression);
}
}
}
return base.Visit(node);
}
internal override SqlNode Visit(SqlNode node) {
SqlExpression expression = node as SqlExpression;
if (expression != null) {
bool saveIsBlocked = this.isBlocked;
this.isBlocked = false;
if (CanRecurseColumnize(expression)) {
base.Visit(expression);
}
if (!this.isBlocked) {
if (CanBeColumn(expression)) {
this.candidates.Add(expression);
}
else {
this.isBlocked = true;
}
}
this.isBlocked |= saveIsBlocked;
}
return node;
}
private static Type GetClrType(SqlNode node) {
SqlTableValuedFunctionCall tvf = node as SqlTableValuedFunctionCall;
if (tvf != null)
return tvf.RowType.Type;
SqlExpression exp = node as SqlExpression;
if (exp != null) {
if (TypeSystem.IsSequenceType(exp.ClrType))
return TypeSystem.GetElementType(exp.ClrType);
return exp.ClrType;
}
SqlSelect sel = node as SqlSelect;
if (sel != null)
return sel.Selection.ClrType;
SqlTable tab = node as SqlTable;
if (tab != null)
return tab.RowType.Type;
SqlUnion su = node as SqlUnion;
if (su != null)
return su.GetClrType();
throw Error.UnexpectedNode(node.NodeType);
}
private static Type GetClrType(SqlNode node)
{
SqlTableValuedFunctionCall tvf = node as SqlTableValuedFunctionCall;
if (tvf != null)
{
return(tvf.RowType.Type);
}
SqlExpression exp = node as SqlExpression;
if (exp != null)
{
if (TypeSystem.IsSequenceType(exp.ClrType))
{
return(TypeSystem.GetElementType(exp.ClrType));
}
return(exp.ClrType);
}
SqlSelect sel = node as SqlSelect;
if (sel != null)
{
return(sel.Selection.ClrType);
}
SqlTable tab = node as SqlTable;
if (tab != null)
{
return(tab.RowType.Type);
}
SqlUnion su = node as SqlUnion;
if (su != null)
{
return(su.GetClrType());
}
throw Error.UnexpectedNode(node.NodeType);
}
internal virtual void VisitWithParens(SqlNode node, SqlNode outer)
{
if(node == null)
return;
switch(node.NodeType)
{
case SqlNodeType.ColumnRef:
case SqlNodeType.Value:
case SqlNodeType.Member:
case SqlNodeType.Parameter:
case SqlNodeType.FunctionCall:
case SqlNodeType.TableValuedFunctionCall:
case SqlNodeType.OuterJoinedValue:
this.Visit(node);
break;
case SqlNodeType.Add:
case SqlNodeType.Mul:
case SqlNodeType.And:
case SqlNodeType.Or:
case SqlNodeType.Not:
case SqlNodeType.Not2V:
case SqlNodeType.BitAnd:
case SqlNodeType.BitOr:
case SqlNodeType.BitXor:
case SqlNodeType.BitNot:
if(outer.NodeType != node.NodeType)
goto default;
this.Visit(node);
break;
default:
_commandStringBuilder.Append("(");
this.Visit(node);
_commandStringBuilder.Append(")");
break;
}
}
internal static bool CanConvert(SqlNode node)
{
SqlUnary su = node as SqlUnary;
if(su != null && IsSupportedUnary(su))
{
return true;
}
SqlNew sn = node as SqlNew;
if(sn != null && IsSupportedNew(sn))
{
return true;
}
SqlMember sm = node as SqlMember;
if(sm != null && IsSupportedMember(sm))
{
return true;
}
SqlMethodCall mc = node as SqlMethodCall;
if(mc != null && (GetMethodSupport(mc) == MethodSupport.Method))
{
return true;
}
return false;
}
internal static SqlNode Reduce(SqlNode node, SqlNodeAnnotations annotations, Enum[] providerModesWithIncompatibilities)
{
Reducer r = new Reducer(providerModesWithIncompatibilities) {Annotations = annotations};
return r.Visit(node);
}
internal SqlNode Duplicate(SqlNode node)
{
return this.superDuper.Visit(node);
}
internal KnownExpression(SqlNode node, Type type)
: base(InternalExpressionType.Known, type) {
this.node = node;
}
internal bool HasSideEffect(SqlNode node)
{
this.hasSideEffect = false;
this.Visit(node);
return this.hasSideEffect;
}
internal SqlIncludeScope(SqlNode child, Expression sourceExpression)
: base(SqlNodeType.IncludeScope, sourceExpression)
{
this.child = child;
}
internal static bool IsDependent(SqlNode node, HashSet<SqlAlias> aliasesToCheck, HashSet<SqlExpression> ignoreExpressions)
{
AliasDependencyChecker v = new AliasDependencyChecker(aliasesToCheck, ignoreExpressions);
v.Visit(node);
return v.hasDependency;
}
internal bool HasRowNumber(SqlNode node)
{
this.rowNumberVisitor.Visit(node);
return rowNumberVisitor.HasRowNumber;
}
internal virtual SqlNode Visit(SqlNode node) {
SqlNode result = null;
if (node == null) {
return null;
}
try {
nDepth++;
CheckRecursionDepth(500, nDepth);
switch (node.NodeType) {
case SqlNodeType.Not:
case SqlNodeType.Not2V:
case SqlNodeType.Negate:
case SqlNodeType.BitNot:
case SqlNodeType.IsNull:
case SqlNodeType.IsNotNull:
case SqlNodeType.Count:
case SqlNodeType.LongCount:
case SqlNodeType.Max:
case SqlNodeType.Min:
case SqlNodeType.Sum:
case SqlNodeType.Avg:
case SqlNodeType.Stddev:
case SqlNodeType.Convert:
case SqlNodeType.ValueOf:
case SqlNodeType.OuterJoinedValue:
case SqlNodeType.ClrLength:
result = this.VisitUnaryOperator((SqlUnary)node);
break;
case SqlNodeType.Lift:
result = this.VisitLift((SqlLift)node);
break;
case SqlNodeType.Add:
case SqlNodeType.Sub:
case SqlNodeType.Mul:
case SqlNodeType.Div:
case SqlNodeType.Mod:
case SqlNodeType.BitAnd:
case SqlNodeType.BitOr:
case SqlNodeType.BitXor:
case SqlNodeType.And:
case SqlNodeType.Or:
case SqlNodeType.GE:
case SqlNodeType.GT:
case SqlNodeType.LE:
case SqlNodeType.LT:
case SqlNodeType.EQ:
case SqlNodeType.NE:
case SqlNodeType.EQ2V:
case SqlNodeType.NE2V:
case SqlNodeType.Concat:
case SqlNodeType.Coalesce:
result = this.VisitBinaryOperator((SqlBinary)node);
break;
case SqlNodeType.Between:
result = this.VisitBetween((SqlBetween)node);
break;
case SqlNodeType.In:
result = this.VisitIn((SqlIn)node);
break;
case SqlNodeType.Like:
result = this.VisitLike((SqlLike)node);
break;
case SqlNodeType.Treat:
result = this.VisitTreat((SqlUnary)node);
break;
case SqlNodeType.Alias:
result = this.VisitAlias((SqlAlias)node);
break;
case SqlNodeType.AliasRef:
result = this.VisitAliasRef((SqlAliasRef)node);
break;
case SqlNodeType.Member:
result = this.VisitMember((SqlMember)node);
break;
case SqlNodeType.Row:
result = this.VisitRow((SqlRow)node);
break;
case SqlNodeType.Column:
result = this.VisitColumn((SqlColumn)node);
break;
case SqlNodeType.ColumnRef:
result = this.VisitColumnRef((SqlColumnRef)node);
break;
case SqlNodeType.Table:
result = this.VisitTable((SqlTable)node);
break;
case SqlNodeType.UserQuery:
result = this.VisitUserQuery((SqlUserQuery)node);
break;
case SqlNodeType.StoredProcedureCall:
result = this.VisitStoredProcedureCall((SqlStoredProcedureCall)node);
break;
case SqlNodeType.UserRow:
result = this.VisitUserRow((SqlUserRow)node);
break;
case SqlNodeType.UserColumn:
result = this.VisitUserColumn((SqlUserColumn)node);
break;
case SqlNodeType.Multiset:
case SqlNodeType.ScalarSubSelect:
case SqlNodeType.Element:
case SqlNodeType.Exists:
result = this.VisitSubSelect((SqlSubSelect)node);
break;
case SqlNodeType.Join:
result = this.VisitJoin((SqlJoin)node);
break;
case SqlNodeType.Select:
result = this.VisitSelect((SqlSelect)node);
break;
case SqlNodeType.Parameter:
result = this.VisitParameter((SqlParameter)node);
break;
case SqlNodeType.New:
result = this.VisitNew((SqlNew)node);
break;
case SqlNodeType.Link:
result = this.VisitLink((SqlLink)node);
break;
case SqlNodeType.ClientQuery:
result = this.VisitClientQuery((SqlClientQuery)node);
break;
case SqlNodeType.JoinedCollection:
result = this.VisitJoinedCollection((SqlJoinedCollection)node);
break;
case SqlNodeType.Value:
result = this.VisitValue((SqlValue)node);
break;
case SqlNodeType.ClientArray:
result = this.VisitClientArray((SqlClientArray)node);
break;
case SqlNodeType.Insert:
result = this.VisitInsert((SqlInsert)node);
break;
case SqlNodeType.Update:
result = this.VisitUpdate((SqlUpdate)node);
break;
case SqlNodeType.Delete:
result = this.VisitDelete((SqlDelete)node);
break;
case SqlNodeType.MemberAssign:
result = this.VisitMemberAssign((SqlMemberAssign)node);
break;
case SqlNodeType.Assign:
result = this.VisitAssign((SqlAssign)node);
break;
case SqlNodeType.Block:
result = this.VisitBlock((SqlBlock)node);
break;
case SqlNodeType.SearchedCase:
result = this.VisitSearchedCase((SqlSearchedCase)node);
break;
case SqlNodeType.ClientCase:
result = this.VisitClientCase((SqlClientCase)node);
break;
case SqlNodeType.SimpleCase:
result = this.VisitSimpleCase((SqlSimpleCase)node);
break;
case SqlNodeType.TypeCase:
result = this.VisitTypeCase((SqlTypeCase)node);
break;
case SqlNodeType.Union:
result = this.VisitUnion((SqlUnion)node);
break;
case SqlNodeType.ExprSet:
result = this.VisitExprSet((SqlExprSet)node);
break;
case SqlNodeType.Variable:
result = this.VisitVariable((SqlVariable)node);
break;
case SqlNodeType.DoNotVisit:
result = this.VisitDoNotVisit((SqlDoNotVisitExpression)node);
break;
case SqlNodeType.OptionalValue:
result = this.VisitOptionalValue((SqlOptionalValue)node);
break;
case SqlNodeType.FunctionCall:
result = this.VisitFunctionCall((SqlFunctionCall)node);
break;
case SqlNodeType.TableValuedFunctionCall:
result = this.VisitTableValuedFunctionCall((SqlTableValuedFunctionCall)node);
break;
case SqlNodeType.MethodCall:
result = this.VisitMethodCall((SqlMethodCall)node);
break;
case SqlNodeType.Nop:
result = this.VisitNop((SqlNop)node);
break;
case SqlNodeType.SharedExpression:
result = this.VisitSharedExpression((SqlSharedExpression)node);
break;
case SqlNodeType.SharedExpressionRef:
result = this.VisitSharedExpressionRef((SqlSharedExpressionRef)node);
break;
case SqlNodeType.SimpleExpression:
result = this.VisitSimpleExpression((SqlSimpleExpression)node);
break;
case SqlNodeType.Grouping:
result = this.VisitGrouping((SqlGrouping)node);
break;
case SqlNodeType.DiscriminatedType:
result = this.VisitDiscriminatedType((SqlDiscriminatedType)node);
break;
case SqlNodeType.DiscriminatorOf:
result = this.VisitDiscriminatorOf((SqlDiscriminatorOf)node);
break;
case SqlNodeType.ClientParameter:
result = this.VisitClientParameter((SqlClientParameter)node);
break;
case SqlNodeType.RowNumber:
result = this.VisitRowNumber((SqlRowNumber)node);
break;
case SqlNodeType.IncludeScope:
result = this.VisitIncludeScope((SqlIncludeScope)node);
break;
default:
throw Error.UnexpectedNode(node);
}
} finally {
this.nDepth--;
}
return result;
}
internal SqlNode Rewrite(SqlNode node)
{
return this.visitor.Visit(node);
}
internal SqlNode Multiplex(SqlNode node)
{
return this._multiSetMultiPlexor.Visit(node);
}