/// <summary> /// Create a new VarInfo for a structured type Var /// </summary> /// <param name="v"> The structured type Var </param> /// <param name="newType"> "Mapped" type for v </param> /// <param name="newVars"> List of vars corresponding to v </param> /// <param name="newProperties"> Flattened Properties </param> /// <param name="newVarsIncludeNullSentinelVar"> Do the new vars include a var that represents a null sentinel either for this type or for any nested type </param> /// <returns> the VarInfo </returns> internal VarInfo CreateStructuredVarInfo( Var v, RowType newType, List<Var> newVars, List<EdmProperty> newProperties, bool newVarsIncludeNullSentinelVar) { VarInfo varInfo = new StructuredVarInfo(newType, newVars, newProperties, newVarsIncludeNullSentinelVar); m_map.Add(v, varInfo); return varInfo; }
private readonly List<Var> m_newVars; // always a singleton list /// <summary> /// Initializes a new instance of <see cref="PrimitiveTypeVarInfo"/> class. /// </summary> /// <param name="newVar"> /// New <see cref="Var"/> that replaces current <see cref="Var"/>. /// </param> internal PrimitiveTypeVarInfo(Var newVar) { Debug.Assert(newVar != null, "newVar != null"); m_newVars = new List<Var> { newVar }; }
private readonly List<Var> m_newVars; // always a singleton list /// <summary> /// Initializes a new instance of <see cref="PrimitiveTypeVarInfo" /> class. /// </summary> /// <param name="newVar"> /// New <see cref="Var" /> that replaces current <see cref="Var" /> . /// </param> internal PrimitiveTypeVarInfo(Var newVar) { DebugCheck.NotNull(newVar); m_newVars = new List<Var> { newVar }; }
protected Node AddSubqueryToParentRelOp(Var outputVar, Node subquery) { var ancestor = FindRelOpAncestor(); PlanCompiler.Assert(ancestor != null, "no ancestors found?"); AddSubqueryToRelOpNode(ancestor, subquery); subquery = m_command.CreateNode(m_command.CreateVarRefOp(outputVar)); return subquery; }
/// <summary> /// Determines whether the given node is a VarRef over the given var /// </summary> /// <param name="node"> </param> /// <param name="var"> </param> /// <returns> </returns> internal static bool IsVarRefOverGivenVar(Node node, Var var) { if (node.Op.OpType != OpType.VarRef) { return false; } return ((VarRefOp)node.Op).Var == var; }
internal CollectionInfo( Var collectionVar, ColumnMap columnMap, VarList flattenedElementVars, VarVec keys, List<SortKey> sortKeys, object discriminatorValue) { m_collectionVar = collectionVar; m_columnMap = columnMap; m_flattenedElementVars = flattenedElementVars; m_keys = keys; m_sortKeys = sortKeys; m_discriminatorValue = discriminatorValue; }
internal VarInfo CreatePrimitiveTypeVarInfo(Var v, Var newVar) { DebugCheck.NotNull(v); DebugCheck.NotNull(newVar); PlanCompiler.Assert(TypeSemantics.IsScalarType(v.Type), "The current variable should be of primitive or enum type."); PlanCompiler.Assert(TypeSemantics.IsScalarType(newVar.Type), "The new variable should be of primitive or enum type."); VarInfo varInfo = new PrimitiveTypeVarInfo(newVar); m_map.Add(v, varInfo); return varInfo; }
// <summary> // Add an entry that the given property of the given var is a computation represented // by the computationTemplate over the var represented by the given groupAggregateVarInfo // </summary> internal void Add( Var var, GroupAggregateVarInfo groupAggregateVarInfo, Node computationTemplate, bool isUnnested, EdmMember property) { if (property == null) { Add(var, groupAggregateVarInfo, computationTemplate, isUnnested); return; } if (_groupAggregateVarRelatedVarPropertyToInfo == null) { _groupAggregateVarRelatedVarPropertyToInfo = new Dictionary<Var, Dictionary<EdmMember, GroupAggregateVarRefInfo>>(); } Dictionary<EdmMember, GroupAggregateVarRefInfo> varPropertyDictionary; if (!_groupAggregateVarRelatedVarPropertyToInfo.TryGetValue(var, out varPropertyDictionary)) { varPropertyDictionary = new Dictionary<EdmMember, GroupAggregateVarRefInfo>(); _groupAggregateVarRelatedVarPropertyToInfo.Add(var, varPropertyDictionary); } varPropertyDictionary.Add(property, new GroupAggregateVarRefInfo(groupAggregateVarInfo, computationTemplate, isUnnested)); // Note: The following line is not necessary with the current usage pattern, this method is // never called with a new groupAggregateVarInfo thus it is a no-op. _groupAggregateVarInfos.Add(groupAggregateVarInfo); }
/// <summary> /// Builds up a join between the relationshipset and the entityset corresponding to its toEnd. In essence, /// we produce /// SELECT r, e /// FROM RS as r, OFTYPE(ES, T) as e /// WHERE r.ToEnd = Ref(e) /// /// "T" is the entity type of the toEnd of the relationship. /// </summary> /// <param name="relSet">the relationshipset</param> /// <param name="end">the toEnd of the relationship</param> /// <param name="rsVar">the var representing the relationship instance ("r") in the output subquery</param> /// <param name="esVar">the var representing the entity instance ("e") in the output subquery</param> /// <returns>the join subquery described above</returns> private Node BuildJoinForNavProperty( RelationshipSet relSet, RelationshipEndMember end, out Var rsVar, out Var esVar) { var entitySet = FindTargetEntitySet(relSet, end); // // Build out the ScanTable ops for the relationshipset and the entityset. Add the // var asTableNode = BuildOfTypeTable(relSet, null, out rsVar); var esTableNode = BuildOfTypeTable(entitySet, TypeHelpers.GetElementTypeUsage(end.TypeUsage), out esVar); // // Build up a join between the entityset and the associationset; join on the to-end // var joinPredicate = m_command.BuildComparison( OpType.EQ, m_command.CreateNode(m_command.CreateGetEntityRefOp(end.TypeUsage), m_command.CreateNode(m_command.CreateVarRefOp(esVar))), m_command.CreateNode(m_command.CreatePropertyOp(end), m_command.CreateNode(m_command.CreateVarRefOp(rsVar))) ); var joinNode = m_command.CreateNode( m_command.CreateInnerJoinOp(), asTableNode, esTableNode, joinPredicate); return joinNode; }
/// <summary> /// Simple constructor /// </summary> /// <param name="type"> datatype of this Var </param> /// <param name="name"> the name of the column </param> /// <param name="v"> the var producing the value for this column </param> internal VarRefColumnMap(TypeUsage type, string name, Var v) : base(type, name) { m_var = v; }
/// <summary> /// Produces a relop tree that "logically" produces the target of the derefop. In essence, this gets rewritten /// into /// SELECT VALUE e /// FROM (SELECT VALUE e0 FROM OFTYPE(ES0, T) as e0 /// UNION ALL /// SELECT VALUE e1 FROM OFTYPE(ES1, T) as e1 /// ... /// SELECT VALUE eN from OFTYPE(ESN, T) as eN)) as e /// WHERE REF(e) = myRef /// /// "T" is the target type of the Deref, and myRef is the (single) argument to the DerefOp /// /// ES0, ES1 etc. are all the EntitySets that could hold instances that are at least of type "T". We identify this list of sets /// by looking at all entitycontainers referenced in the query, and looking at all entitysets in those /// containers that are of the right type /// An EntitySet ES (of entity type X) can hold instances of T, if one of the following is true /// - T is a subtype of X /// - X is equal to T /// Our situation is a little trickier, since we also need to look for cases where X is a subtype of T. /// </summary> /// <param name="derefOpNode">the derefOp subtree</param> /// <param name="derefOp">the derefOp</param> /// <param name="outputVar">output var produced</param> /// <returns>the subquery described above</returns> private Node RewriteDerefOp(Node derefOpNode, DerefOp derefOp, out Var outputVar) { var entityType = derefOp.Type; var targetEntitySets = GetEntitySets(entityType); if (targetEntitySets.Count == 0) { // We didn't find any entityset that could match this. Simply return a null-value outputVar = null; return m_command.CreateNode(m_command.CreateNullOp(entityType)); } var scanTableNodes = new List<Node>(); var scanTableVars = new List<Var>(); foreach (var entitySet in targetEntitySets) { Var tableVar; var tableNode = BuildOfTypeTable(entitySet, entityType, out tableVar); scanTableNodes.Add(tableNode); scanTableVars.Add(tableVar); } Node unionAllNode; Var unionAllVar; m_command.BuildUnionAllLadder(scanTableNodes, scanTableVars, out unionAllNode, out unionAllVar); // // Finally build up the key comparison predicate // var entityRefNode = m_command.CreateNode( m_command.CreateGetEntityRefOp(derefOpNode.Child0.Op.Type), m_command.CreateNode(m_command.CreateVarRefOp(unionAllVar))); var keyComparisonPred = m_command.BuildComparison(OpType.EQ, derefOpNode.Child0, entityRefNode); var filterNode = m_command.CreateNode( m_command.CreateFilterOp(), unionAllNode, keyComparisonPred); outputVar = unionAllVar; return filterNode; }
// <summary> // Convert a SingleStreamNestOp into a massive UnionAllOp // </summary> private Node BuildUnionAllSubqueryForNestOp( NestBaseOp nestOp, Node nestNode, VarList drivingNodeVars, VarList discriminatorVarList, out Var discriminatorVar, out List<Dictionary<Var, Var>> varMapList) { var drivingNode = nestNode.Child0; // For each of the NESTED collections... Node unionAllNode = null; VarList unionAllOutputs = null; for (var i = 1; i < nestNode.Children.Count; i++) { // Ensure we only use the driving collection tree once, so other // transformations do not unintentionally change more than one path. // To prevent nodes in the tree from being used in multiple paths, // we copy the driving input on successive nodes. VarList newDrivingNodeVars; Node newDrivingNode; VarList newFlattenedElementVars; Op op; if (i > 1) { newDrivingNode = OpCopier.Copy(Command, drivingNode, drivingNodeVars, out newDrivingNodeVars); // // Bug 450245: If we copied the driver node, then references to driver node vars // from the collection subquery must be patched up // var varRemapper = new VarRemapper(Command); for (var j = 0; j < drivingNodeVars.Count; j++) { varRemapper.AddMapping(drivingNodeVars[j], newDrivingNodeVars[j]); } // Remap all references in the current subquery varRemapper.RemapSubtree(nestNode.Children[i]); // Bug 479183: Remap the flattened element vars newFlattenedElementVars = varRemapper.RemapVarList(nestOp.CollectionInfo[i - 1].FlattenedElementVars); // Create a cross apply for all but the first collection op = Command.CreateCrossApplyOp(); } else { newDrivingNode = drivingNode; newDrivingNodeVars = drivingNodeVars; newFlattenedElementVars = nestOp.CollectionInfo[i - 1].FlattenedElementVars; // Create an outer apply for the first collection, // that way we ensure at least one row for each row in the driver node. op = Command.CreateOuterApplyOp(); } // Create an outer apply with the driver node and the nested collection. var applyNode = Command.CreateNode(op, newDrivingNode, nestNode.Children[i]); // Now create a ProjectOp that augments the output from the OuterApplyOp // with nulls for each column from other collections // Build the VarDefList (the list of vars) for the Project, starting // with the collection discriminator var var varDefListChildren = new List<Node>(); var projectOutputs = Command.CreateVarList(); // Add the collection discriminator var to the output. projectOutputs.Add(discriminatorVarList[i]); // Add all columns from the driving node projectOutputs.AddRange(newDrivingNodeVars); // Add all the vars from all the nested collections; for (var j = 1; j < nestNode.Children.Count; j++) { var otherCollectionInfo = nestOp.CollectionInfo[j - 1]; // For the current nested collection, we just pick the var that's // coming from there and don't need have a new var defined, but for // the rest we construct null values. if (i == j) { projectOutputs.AddRange(newFlattenedElementVars); } else { foreach (var v in otherCollectionInfo.FlattenedElementVars) { var nullOp = Command.CreateNullOp(v.Type); var nullOpNode = Command.CreateNode(nullOp); Var nullOpVar; var nullOpVarDefNode = Command.CreateVarDefNode(nullOpNode, out nullOpVar); varDefListChildren.Add(nullOpVarDefNode); projectOutputs.Add(nullOpVar); } } } var varDefListNode = Command.CreateNode(Command.CreateVarDefListOp(), varDefListChildren); // Now, build up the projectOp var projectOutputsVarSet = Command.CreateVarVec(projectOutputs); var projectOp = Command.CreateProjectOp(projectOutputsVarSet); var projectNode = Command.CreateNode(projectOp, applyNode, varDefListNode); // finally, build the union all if (unionAllNode == null) { unionAllNode = projectNode; unionAllOutputs = projectOutputs; } else { var unionAllMap = new VarMap(); var projectMap = new VarMap(); for (var idx = 0; idx < unionAllOutputs.Count; idx++) { Var outputVar = Command.CreateSetOpVar(unionAllOutputs[idx].Type); unionAllMap.Add(outputVar, unionAllOutputs[idx]); projectMap.Add(outputVar, projectOutputs[idx]); } var unionAllOp = Command.CreateUnionAllOp(unionAllMap, projectMap); unionAllNode = Command.CreateNode(unionAllOp, unionAllNode, projectNode); // Get the output vars from the union-op. This must be in the same order // as the original list of Vars unionAllOutputs = GetUnionOutputs(unionAllOp, unionAllOutputs); } } // We're done building the node, but now we have to build a mapping from // the before-Vars to the after-Vars varMapList = new List<Dictionary<Var, Var>>(); IEnumerator<Var> outputVarsEnumerator = unionAllOutputs.GetEnumerator(); if (!outputVarsEnumerator.MoveNext()) { throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.ColumnCountMismatch, 4, null); // more columns from children than are on the unionAll? } // The discriminator var is always first discriminatorVar = outputVarsEnumerator.Current; // Build a map for each input for (var i = 0; i < nestNode.Children.Count; i++) { var varMap = new Dictionary<Var, Var>(); var varList = (i == 0) ? drivingNodeVars : nestOp.CollectionInfo[i - 1].FlattenedElementVars; foreach (var v in varList) { if (!outputVarsEnumerator.MoveNext()) { throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.ColumnCountMismatch, 5, null); // more columns from children than are on the unionAll? } varMap[v] = outputVarsEnumerator.Current; } varMapList.Add(varMap); } if (outputVarsEnumerator.MoveNext()) { throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.ColumnCountMismatch, 6, null); // at this point, we better be done with both lists... } return unionAllNode; }
// <summary> // Input => Filter(input, Ref(var) is not null) // </summary> private Node CapWithIsNotNullFilter(Node input, Var var) { var varRefNode = Command.CreateNode(Command.CreateVarRefOp(var)); var predicateNode = Command.CreateNode( Command.CreateConditionalOp(OpType.Not), Command.CreateNode( Command.CreateConditionalOp(OpType.IsNull), varRefNode)); var filterNode = Command.CreateNode(Command.CreateFilterOp(), input, predicateNode); return filterNode; }
// <summary> // Convert a CollectOp subtree (when used as the defining expression for a // VarDefOp) into a reasonable input to a NestOp. // </summary> // <remarks> // There are a couple of cases that we handle here: // (a) PhysicalProject(X) ==> X // (b) PhysicalProject(Sort(X)) ==> Sort(X) // </remarks> // <param name="physicalProjectNode"> the child of the CollectOp </param> // <param name="collectionVar"> the collectionVar being defined </param> // <param name="collectionInfoList"> where to append the new collectionInfo </param> // <param name="collectionNodes"> where to append the collectionNode </param> // <param name="externalReferences"> a bit vector of external references of the physicalProject </param> // <param name="collectionReferences"> a bit vector of collection vars </param> private void ConvertToNestOpInput( Node physicalProjectNode, Var collectionVar, List<CollectionInfo> collectionInfoList, List<Node> collectionNodes, VarVec externalReferences, VarVec collectionReferences) { // Keep track of any external references the physicalProjectOp has externalReferences.Or(Command.GetNodeInfo(physicalProjectNode).ExternalReferences); // Case: (a) PhysicalProject(X) ==> X var nestOpInput = physicalProjectNode.Child0; // Now build the collectionInfo for this input, including the flattened // list of vars, which is essentially the outputs from the physicalProject // with the sortKey vars that aren't already in the outputs we already // have. var physicalProjectOp = (PhysicalProjectOp)physicalProjectNode.Op; var flattenedElementVarList = Command.CreateVarList(physicalProjectOp.Outputs); var flattenedElementVarVec = Command.CreateVarVec(flattenedElementVarList); // Use a VarVec to make the lookups faster List<SortKey> sortKeys = null; if (OpType.Sort == nestOpInput.Op.OpType) { // Case: (b) PhysicalProject(Sort(X)) ==> Sort(X) var sortOp = (SortOp)nestOpInput.Op; sortKeys = OpCopier.Copy(Command, sortOp.Keys); foreach (var sk in sortKeys) { if (!flattenedElementVarVec.IsSet(sk.Var)) { flattenedElementVarList.Add(sk.Var); flattenedElementVarVec.Set(sk.Var); } } } else { sortKeys = new List<SortKey>(); } // Get the keys for the collection var keyVars = Command.GetExtendedNodeInfo(nestOpInput).Keys.KeyVars; //Check whether all key are projected var keyVarsClone = keyVars.Clone(); keyVarsClone.Minus(flattenedElementVarVec); var keys = (keyVarsClone.IsEmpty) ? keyVars.Clone() : Command.CreateVarVec(); // Create the collectionInfo var collectionInfo = Command.CreateCollectionInfo( collectionVar, physicalProjectOp.ColumnMap.Element, flattenedElementVarList, keys, sortKeys, null /*discriminatorValue*/); // Now update the collections we're tracking. collectionInfoList.Add(collectionInfo); collectionNodes.Add(nestOpInput); collectionReferences.Set(collectionVar); }
// <summary> // 'Extend' a given input node to also project out an internal integer constant with the given value // </summary> private Node AugmentNodeWithInternalIntegerConstant(Node input, int value, out Var internalConstantVar) { return AugmentNodeWithConstant( input, () => Command.CreateInternalConstantOp(Command.IntegerType, value), out internalConstantVar); }
/// <summary> /// Given a list of vars try to get one that is of type Int32 /// </summary> /// <param name="varList"> </param> /// <param name="int32Var"> </param> /// <returns> </returns> internal static bool TryGetInt32Var(IEnumerable<Var> varList, out Var int32Var) { foreach (var v in varList) { // Any Int32 var regardless of the fasets will do PrimitiveTypeKind typeKind; if (TypeHelpers.TryGetPrimitiveTypeKind(v.Type, out typeKind) && typeKind == PrimitiveTypeKind.Int32) { int32Var = v; return true; } } int32Var = null; return false; }
/// <summary> /// Is the given var guaranteed to be non-nullable with regards to the node /// that is currently being processed. /// True, if it is listed as such on any on the node infos on any of the /// current relop ancestors. /// </summary> /// <param name="var"> </param> /// <returns> </returns> internal bool IsNonNullable(Var var) { foreach (var relOpAncestor in m_relOpAncestors) { // Rules applied to the children of the relOpAncestor may have caused it change. // Thus, if the node is used, it has to have its node info recomputed Command.RecomputeNodeInfo(relOpAncestor); var nodeInfo = Command.GetExtendedNodeInfo(relOpAncestor); if (nodeInfo.NonNullableVisibleDefinitions.IsSet(var)) { return true; } else if (nodeInfo.LocalDefinitions.IsSet(var)) { //The var is defined on this ancestor but is not non-nullable, // therefore there is no need to further check other ancestors return false; } } return false; }
private Node RewriteFromOneNavigationProperty( RelProperty relProperty, List<RelationshipSet> relationshipSets, Node sourceRefNode, out Var outputVar) { PlanCompiler.Assert(relationshipSets.Count > 0, "expected at least one relationship set here"); PlanCompiler.Assert( relProperty.FromEnd.RelationshipMultiplicity != RelationshipMultiplicity.Many, "Expected source end multiplicity to be one. Found 'Many' instead " + relProperty); var entityType = TypeHelpers.GetElementTypeUsage(relProperty.ToEnd.TypeUsage); var scanTableNodes = new List<Node>(relationshipSets.Count); var scanTableVars = new List<Var>(relationshipSets.Count); foreach (var r in relationshipSets) { var entitySet = FindTargetEntitySet(r, relProperty.ToEnd); Var tableVar; var tableNode = BuildOfTypeTable(entitySet, entityType, out tableVar); scanTableNodes.Add(tableNode); scanTableVars.Add(tableVar); } // // Build the union-all node // Node unionAllNode; m_command.BuildUnionAllLadder(scanTableNodes, scanTableVars, out unionAllNode, out outputVar); // // Now build up the appropriate filter. Select out the relproperty from the other end // var inverseRelProperty = new RelProperty(relProperty.Relationship, relProperty.ToEnd, relProperty.FromEnd); PlanCompiler.Assert( m_command.IsRelPropertyReferenced(inverseRelProperty), "Unreferenced rel property? " + inverseRelProperty); var inverseRelPropertyNode = m_command.CreateNode( m_command.CreateRelPropertyOp(inverseRelProperty), m_command.CreateNode(m_command.CreateVarRefOp(outputVar))); var predicateNode = m_command.BuildComparison( OpType.EQ, sourceRefNode, inverseRelPropertyNode); var ret = m_command.CreateNode(m_command.CreateFilterOp(), unionAllNode, predicateNode); return ret; }
internal VarRefColumnMap(Var v) : this(v.Type, null, v) { }
internal UnionAllOp(VarVec outputs, VarMap left, VarMap right, Var branchDiscriminator) : base(OpType.UnionAll, outputs, left, right) { m_branchDiscriminator = branchDiscriminator; }
private readonly List<Var> m_newVars; // always a singleton list /// <summary> /// Create a CollectionVarInfo /// </summary> internal CollectionVarInfo(Var newVar) { m_newVars = new List<Var>(); m_newVars.Add(newVar); }
// <summary> // Gets the groupAggregateVarRefInfo representing the definition of the given var over // a group aggregate var if any. // </summary> internal bool TryGetReferencedGroupAggregateVarInfo(Var var, out GroupAggregateVarRefInfo groupAggregateVarRefInfo) { return _groupAggregateVarRelatedVarToInfo.TryGetValue(var, out groupAggregateVarRefInfo); }
/// <summary> /// Builds a NULLIF expression (ie) a Case expression that looks like /// CASE WHEN v is null THEN null ELSE expr END /// where v is the conditionVar parameter, and expr is the value of the expression /// when v is non-null /// </summary> /// <param name="conditionVar"> null discriminator var </param> /// <param name="expr"> expression </param> /// <returns> </returns> internal Node BuildNullIfExpression(Var conditionVar, Node expr) { var varRefOp = Command.CreateVarRefOp(conditionVar); var varRefNode = Command.CreateNode(varRefOp); var whenNode = Command.CreateNode(Command.CreateConditionalOp(OpType.IsNull), varRefNode); var elseNode = expr; var thenNode = Command.CreateNode(Command.CreateNullOp(elseNode.Op.Type)); var caseNode = Command.CreateNode(Command.CreateCaseOp(elseNode.Op.Type), whenNode, thenNode, elseNode); return caseNode; }
// <summary> // Gets the groupAggregateVarRefInfo representing the definition of the given property of the given // var over a group aggregate var if any. // </summary> internal bool TryGetReferencedGroupAggregateVarInfo( Var var, EdmMember property, out GroupAggregateVarRefInfo groupAggregateVarRefInfo) { if (property == null) { return TryGetReferencedGroupAggregateVarInfo(var, out groupAggregateVarRefInfo); } Dictionary<EdmMember, GroupAggregateVarRefInfo> varPropertyDictionary; if (_groupAggregateVarRelatedVarPropertyToInfo == null || !_groupAggregateVarRelatedVarPropertyToInfo.TryGetValue(var, out varPropertyDictionary)) { groupAggregateVarRefInfo = null; return false; } return varPropertyDictionary.TryGetValue(property, out groupAggregateVarRefInfo); }
/// <summary> /// Adds a mapping from oldVar to newVar /// </summary> /// <param name="oldVar"> </param> /// <param name="newVar"> </param> internal void AddVarMapping(Var oldVar, Var newVar) { m_remapper.AddMapping(oldVar, newVar); m_remappedVars.Set(oldVar); }
/// <summary> /// Get the list of desired properties for a Var /// </summary> /// <param name="v"> the var </param> /// <returns> List of desired properties </returns> private PropertyRefList GetPropertyRefList(Var v) { PropertyRefList propRefs; if (!m_varPropertyRefMap.TryGetValue(v, out propRefs)) { propRefs = new PropertyRefList(); m_varPropertyRefMap[v] = propRefs; } return propRefs; }
// <summary> // Follow the VarRef chain to the defining var // </summary> private Var ResolveVarReference(Var refVar) { var x = refVar; while (m_varRefMap.TryGetValue(x, out x)) { refVar = x; } return refVar; }
/// <summary> /// Add a new set of properties to a Var /// </summary> /// <param name="v"> the var </param> /// <param name="propertyRefs"> desired properties </param> private void AddPropertyRefs(Var v, PropertyRefList propertyRefs) { var currentRefs = GetPropertyRefList(v); currentRefs.Append(propertyRefs); }
// <summary> // Add a constant to a node. Specifically: // N ==> Project(N,{definitions-from-N, constant}) // </summary> // <param name="input"> the input node to augment </param> // <param name="createOp"> The fucntion to create the constant op </param> // <param name="constantVar"> the computed Var for the internal constant </param> // <returns> the augmented node </returns> private Node AugmentNodeWithConstant(Node input, Func<ConstantBaseOp> createOp, out Var constantVar) { // Construct the op for the constant value and // a VarDef node that that defines it. var constantOp = createOp(); var constantNode = Command.CreateNode(constantOp); var varDefListNode = Command.CreateVarDefListNode(constantNode, out constantVar); // Now identify the list of definitions from the input, and project out // every one of them and include the constantVar var inputNodeInfo = Command.GetExtendedNodeInfo(input); var projectOutputs = Command.CreateVarVec(inputNodeInfo.Definitions); projectOutputs.Set(constantVar); var projectOp = Command.CreateProjectOp(projectOutputs); var projectNode = Command.CreateNode(projectOp, input, varDefListNode); return projectNode; }
private Node RewriteNavigateOp(Node navigateOpNode, NavigateOp navigateOp, out Var outputVar) { outputVar = null; // // Currently, navigation of composition relationships is not supported. // if (!Helper.IsAssociationType(navigateOp.Relationship)) { throw new NotSupportedException(Strings.Cqt_RelNav_NoCompositions); } // // If the input to the navigateOp is a GetEntityRefOp, and the navigation // is to the 1-end of the relationship, convert this into a RelPropertyOp instead - operating on the // input child to the GetEntityRefOp // if (navigateOpNode.Child0.Op.OpType == OpType.GetEntityRef && (navigateOp.ToEnd.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne || navigateOp.ToEnd.RelationshipMultiplicity == RelationshipMultiplicity.One)) { PlanCompiler.Assert( m_command.IsRelPropertyReferenced(navigateOp.RelProperty), "Unreferenced rel property? " + navigateOp.RelProperty); Op relPropertyOp = m_command.CreateRelPropertyOp(navigateOp.RelProperty); var relPropertyNode = m_command.CreateNode( relPropertyOp, navigateOpNode.Child0.Child0); return relPropertyNode; } var relationshipSets = GetRelationshipSets(navigateOp.Relationship); // // Special case: when no relationshipsets can be found. Return NULL or an empty multiset, // depending on the multiplicity of the toEnd // if (relationshipSets.Count == 0) { // // If we're navigating to the 1-end of the relationship, then simply return a null constant // if (navigateOp.ToEnd.RelationshipMultiplicity != RelationshipMultiplicity.Many) { return m_command.CreateNode(m_command.CreateNullOp(navigateOp.Type)); } else // return an empty set { return m_command.CreateNode(m_command.CreateNewMultisetOp(navigateOp.Type)); } } // // Build up a UNION-ALL ladder over all the relationshipsets // var scanTableNodes = new List<Node>(); var scanTableVars = new List<Var>(); foreach (var relSet in relationshipSets) { var tableMD = Command.CreateTableDefinition(relSet); var tableOp = m_command.CreateScanTableOp(tableMD); var branchNode = m_command.CreateNode(tableOp); var branchVar = tableOp.Table.Columns[0]; scanTableVars.Add(branchVar); scanTableNodes.Add(branchNode); } Node unionAllNode = null; Var unionAllVar; m_command.BuildUnionAllLadder(scanTableNodes, scanTableVars, out unionAllNode, out unionAllVar); // // Now build up the predicate // var targetEnd = m_command.CreateNode( m_command.CreatePropertyOp(navigateOp.ToEnd), m_command.CreateNode(m_command.CreateVarRefOp(unionAllVar))); var sourceEnd = m_command.CreateNode( m_command.CreatePropertyOp(navigateOp.FromEnd), m_command.CreateNode(m_command.CreateVarRefOp(unionAllVar))); var predicateNode = m_command.BuildComparison(OpType.EQ, navigateOpNode.Child0, sourceEnd); var filterNode = m_command.CreateNode( m_command.CreateFilterOp(), unionAllNode, predicateNode); Var projectVar; var projectNode = m_command.BuildProject(filterNode, targetEnd, out projectVar); // // Finally, some magic about single-valued vs collection-valued ends // Node ret; if (navigateOp.ToEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many) { ret = m_command.BuildCollect(projectNode, projectVar); } else { ret = projectNode; outputVar = projectVar; } return ret; }
// <summary> // Applies a IsNotNull(sentinelVar) filter to the given node. // The filter is pushed below all MultiStremNest-s, because this part of the tree has // already been visited and it is expected that the MultiStreamNests have bubbled up // above the filters. // </summary> private Node ApplyIsNotNullFilter(Node node, Var sentinelVar) { var newFilterChild = node; Node newFilterParent = null; while (newFilterChild.Op.OpType == OpType.MultiStreamNest) { newFilterParent = newFilterChild; newFilterChild = newFilterChild.Child0; } var newFilterNode = CapWithIsNotNullFilter(newFilterChild, sentinelVar); Node result; if (newFilterParent != null) { newFilterParent.Child0 = newFilterNode; result = node; } else { result = newFilterNode; } return result; }
/// <summary> /// Build up a node tree that represents the set of instances from the given table that are at least /// of the specified type ("ofType"). If "ofType" is NULL, then all rows are returned /// /// Return the outputVar from the nodetree /// </summary> /// <param name="entitySet">the entityset or relationshipset to scan over</param> /// <param name="ofType">the element types we're interested in</param> /// <param name="resultVar">the output var produced by this node tree</param> /// <returns>the node tree</returns> private Node BuildOfTypeTable(EntitySetBase entitySet, TypeUsage ofType, out Var resultVar) { var tableMetadata = Command.CreateTableDefinition(entitySet); var tableOp = m_command.CreateScanTableOp(tableMetadata); var tableNode = m_command.CreateNode(tableOp); var tableVar = tableOp.Table.Columns[0]; Node resultNode; // // Build a logical "oftype" expression - simply a filter predicate // if ((ofType != null) && !entitySet.ElementType.EdmEquals(ofType.EdmType)) { m_command.BuildOfTypeTree(tableNode, tableVar, ofType, true, out resultNode, out resultVar); } else { resultNode = tableNode; resultVar = tableVar; } return resultNode; }
// <summary> // Get the Var corresponding to a specific property // </summary> // <param name="p"> the requested property </param> // <param name="v"> the corresponding Var </param> // <returns> true, if the Var was found </returns> internal bool TryGetVar(EdmProperty p, out Var v) { if (m_propertyToVarMap == null) { InitPropertyToVarMap(); } return m_propertyToVarMap.TryGetValue(p, out v); }
internal UnnestOp(Var v, Table t) : this() { m_var = v; m_table = t; }