internal static SqlNode Reduce(SqlNode node, SqlNodeAnnotations annotations) { Reducer r = new Reducer(); r.Annotations = annotations; return(r.Visit(node)); }
internal static HashSet <SqlAlias> Gather(SqlNode node) { Gatherer g = new Gatherer(); g.Visit(node); return(g.Consumed); }
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); }
internal SqlNode TranslateLink(SqlLink link, List <SqlExpression> keyExpressions, bool asExpression) { var member = link.Member; if (member.IsAssociation) { var otherType = member.Association.OtherType; var type = otherType.InheritanceRoot.Type; var table = services.Context.GetTable(type); Expression otherSource = new LinkedTableExpression(link, table, typeof(IQueryable <>).MakeGenericType(otherType.Type)); var array = new Expression[keyExpressions.Count]; for (var i = 0; i < keyExpressions.Count; i++) { var metaDataMember = member.Association.OtherKey[i]; var memberType = TypeSystem.GetMemberType(metaDataMember.Member); array[i] = InternalExpression.Known(keyExpressions[i], memberType); } var thisInstance = (link.Expression != null) ? ((Expression)InternalExpression.Known(link.Expression)) : ((Expression)Expression.Constant(null, link.Member.Member.DeclaringType)); var node = TranslateAssociation(services.Context, member.Association, otherSource, array, thisInstance); var queryConverter = new QueryConverter(services, typeProvider, this, sql); var sqlSelect = (SqlSelect)queryConverter.ConvertInner(node, link.SourceExpression); SqlNode result = sqlSelect; if (asExpression) { result = ((!member.Association.IsMany) ? new SqlSubSelect(SqlNodeType.Element, link.ClrType, link.SqlType, sqlSelect) : new SqlSubSelect(SqlNodeType.Multiset, link.ClrType, link.SqlType, sqlSelect)); } return(result); } return(link.Expansion); }
private List <SqlParameterInfo> ParameterizeInternal(SqlNode node) { Visitor v = new Visitor(this); v.Visit(node); return(new List <SqlParameterInfo>(v.currentParams)); }
/// <summary> /// Execute each current validator. /// </summary> internal void Validate(SqlNode node) { foreach (SqlVisitor validator in this.validators) { validator.Visit(node); } }
private void GatherUnionExpressions(SqlNode node, List <SqlExpression> exprs) { SqlUnion union = node as SqlUnion; if (union != null) { this.GatherUnionExpressions(union.Left, exprs); this.GatherUnionExpressions(union.Right, exprs); } else { SqlSelect sel = node as SqlSelect; if (sel != null) { SqlAliasRef aref = sel.Selection as SqlAliasRef; if (aref != null) { this.GatherUnionExpressions(aref.Alias.Node, exprs); } else { exprs.Add(sel.Selection); } } } }
internal SqlColumn BubbleUp(SqlColumn col, SqlNode source) { this.match = this.GetOriginatingColumn(col); this.found = null; this.Visit(source); return(this.found); }
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 ss = node as SqlSelect; if (ss != null) { return(this.VisitExpression(ss.Selection)); } SqlExpression exp = node as SqlExpression; if (exp != null) { return(this.VisitExpression(exp)); } throw Error.CouldNotHandleAliasRef(node.NodeType); }
internal static bool IsDependent(SqlNode node, HashSet <SqlAlias> aliasesToCheck, HashSet <SqlExpression> ignoreExpressions) { Visitor v = new Visitor(aliasesToCheck, ignoreExpressions); v.Visit(node); return(v.hasDependency); }
internal static HashSet <SqlColumn> Gather(SqlNode node, HashSet <SqlColumn> columns) { Visitor v = new Visitor(columns); v.Visit(node); return(columns); }
internal static SqlNode Lift(SqlNode node) { ColumnLifter cl = new ColumnLifter(); node = cl.Visit(node); return(node); }
/// <summary> /// Gets the annotations for the given node. Null if none. /// </summary> internal List <SqlNodeAnnotation> Get(SqlNode node) { List <SqlNodeAnnotation> list = null; this.annotationMap.TryGetValue(node, out list); return(list); }
internal SqlUnion(SqlNode left, SqlNode right, bool all) : base(SqlNodeType.Union, right.SourceExpression) { Left = left; Right = right; All = all; }
/// <summary> /// Returns true iff the given node references any aliases the list of 'aliases'. /// </summary> internal static bool ReferencesAny(SqlNode node, IEnumerable <SqlAlias> aliases) { Visitor visitor = new Visitor(); visitor.aliases = aliases; visitor.Visit(node); return(visitor.referencesAnyMatchingAliases); }
/// <summary> /// Whether the given node has annotations. /// </summary> internal bool NodeIsAnnotated(SqlNode node) { if (node == null) { return(false); } return(this.annotationMap.ContainsKey(node)); }
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); }
internal override SqlNode Visit(SqlNode node) { // Short-circuit when the answer is alreading known if (this.referencesAnyMatchingAliases) { return(node); } return(base.Visit(node)); }
/// <summary> /// Get a MetaType that represents the dynamic type of the given node. /// </summary> internal static MetaType GetSourceMetaType(SqlNode node, MetaModel model) { Visitor v = new Visitor(); v.Visit(node); Type type = v.sourceType; type = TypeSystem.GetNonNullableType(type); // Emulate CLR's behavior: strip nullability from type. return(model.GetMetaType(type)); }
internal override SqlNode VisitUnion(SqlUnion su) { Scope save = this.current; this.current = null; SqlNode result = base.VisitUnion(su); this.current = save; return(result); }
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)); }
internal static SqlNode Copy(SqlNode node) { if (node == null) { return(null); } var nodeType = node.NodeType; if (nodeType == SqlNodeType.ColumnRef || nodeType == SqlNodeType.Parameter || (uint)(nodeType - 92) <= 1u) { return(node); } return(new SqlDuplicator().Duplicate(node)); }
/// <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 SqlNode TranslateLink(SqlLink link, List <SqlExpression> keyExpressions, bool asExpression) { MetaDataMember mm = link.Member; if (mm.IsAssociation) { // Create the row source. MetaType otherType = mm.Association.OtherType; Type tableType = otherType.InheritanceRoot.Type; ITable table = this.services.Context.GetTable(tableType); Expression source = new LinkedTableExpression(link, table, typeof(IQueryable <>).MakeGenericType(otherType.Type)); // Build key expression nodes. Expression[] keyExprs = new Expression[keyExpressions.Count]; for (int i = 0; i < keyExpressions.Count; ++i) { MetaDataMember metaMember = mm.Association.OtherKey[i]; Type memberType = TypeSystem.GetMemberType(metaMember.Member); keyExprs[i] = InternalExpression.Known(keyExpressions[i], memberType); } Expression lex = link.Expression != null ? (Expression)InternalExpression.Known(link.Expression) : (Expression)Expression.Constant(null, link.Member.Member.DeclaringType); Expression expr = TranslateAssociation(this.services.Context, mm.Association, source, keyExprs, lex); // Convert QueryConverter qc = new QueryConverter(this.services, this.typeProvider, this, this.sql); SqlSelect sel = (SqlSelect)qc.ConvertInner(expr, link.SourceExpression); // Turn it into an expression is necessary SqlNode result = sel; if (asExpression) { if (mm.Association.IsMany) { result = new SqlSubSelect(SqlNodeType.Multiset, link.ClrType, link.SqlType, sel); } else { result = new SqlSubSelect(SqlNodeType.Element, link.ClrType, link.SqlType, sel); } } return(result); } else { System.Diagnostics.Debug.Assert(link.Expansion != null); System.Diagnostics.Debug.Assert(link.KeyExpressions == keyExpressions); // deferred expression already defined... return(link.Expansion); } }
internal override SqlNode Visit(SqlNode node) { if (annotations.NodeIsAnnotated(node)) { foreach (SqlNodeAnnotation annotation in annotations.Get(node)) { SqlServerCompatibilityAnnotation ssca = annotation as SqlServerCompatibilityAnnotation; if (ssca != null && ssca.AppliesTo(provider)) { reasons.Add(annotation.Message); } } } return(base.Visit(node)); }
internal override SqlNode Visit(SqlNode node) { if (node == null) { return(null); } SqlNode value = null; if (nodeMap.TryGetValue(node, out value)) { return(value); } value = base.Visit(node); nodeMap[node] = value; return(value); }
/// <summary> /// Checks whether the given node is supported on the given server. /// </summary> internal static void ThrowIfUnsupported(SqlNode node, SqlNodeAnnotations annotations, SqlProvider.ProviderMode provider) { // Check to see whether there's at least one SqlServerCompatibilityAnnotation. if (annotations.HasAnnotationType(typeof(SqlServerCompatibilityAnnotation))) { Visitor visitor = new Visitor(provider); visitor.annotations = annotations; visitor.Visit(node); // If any messages were recorded, then throw an exception. if (visitor.reasons.Count > 0) { throw Error.ExpressionNotSupportedForSqlServerVersion(visitor.reasons); } } }
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 ReadOnlyCollection <ReadOnlyCollection <SqlParameterInfo> > ParameterizeBlock(SqlBlock block) { SqlParameterInfo rowStatus = new SqlParameterInfo( new SqlParameter(typeof(int), typeProvider.From(typeof(int)), "@ROWCOUNT", block.SourceExpression) ); List <ReadOnlyCollection <SqlParameterInfo> > list = new List <ReadOnlyCollection <SqlParameterInfo> >(); for (int i = 0, n = block.Statements.Count; i < n; i++) { SqlNode statement = block.Statements[i]; List <SqlParameterInfo> parameters = this.ParameterizeInternal(statement); if (i > 0) { parameters.Add(rowStatus); } list.Add(parameters.AsReadOnly()); } return(list.AsReadOnly()); }