/// <summary> /// Is the current predicate a "key-satisfying" predicate? /// </summary> /// <param name="keyVars">list of keyVars</param> /// <param name="definitions">current table definitions</param> /// <returns>true, if this predicate satisfies the keys</returns> internal bool SatisfiesKey(VarVec keyVars, VarVec definitions) { if (keyVars.Count > 0) { VarVec missingKeys = keyVars.Clone(); foreach (Node part in m_parts) { if (part.Op.OpType != OpType.EQ) { continue; } Var keyVar; if (IsKeyPredicate(part.Child0, part.Child1, keyVars, definitions, out keyVar)) { missingKeys.Clear(keyVar); } else if (IsKeyPredicate(part.Child1, part.Child0, keyVars, definitions, out keyVar)) { missingKeys.Clear(keyVar); } } return(missingKeys.IsEmpty); } return(false); }
internal bool SatisfiesKey(VarVec keyVars, VarVec definitions) { if (keyVars.Count <= 0) { return(false); } VarVec varVec = keyVars.Clone(); foreach (System.Data.Entity.Core.Query.InternalTrees.Node part in this.m_parts) { if (part.Op.OpType == OpType.EQ) { Var keyVar; if (this.IsKeyPredicate(part.Child0, part.Child1, keyVars, definitions, out keyVar)) { varVec.Clear(keyVar); } else if (this.IsKeyPredicate(part.Child1, part.Child0, keyVars, definitions, out keyVar)) { varVec.Clear(keyVar); } } } return(varVec.IsEmpty); }
private void Map(List <SortKey> sortKeys) { VarVec varVec = this.m_command.CreateVarVec(); bool flag = false; foreach (SortKey sortKey in sortKeys) { sortKey.Var = this.Map(sortKey.Var); if (varVec.IsSet(sortKey.Var)) { flag = true; } varVec.Set(sortKey.Var); } if (!flag) { return; } List <SortKey> sortKeyList = new List <SortKey>((IEnumerable <SortKey>)sortKeys); sortKeys.Clear(); varVec.Clear(); foreach (SortKey sortKey in sortKeyList) { if (!varVec.IsSet(sortKey.Var)) { sortKeys.Add(sortKey); } varVec.Set(sortKey.Var); } }
private static bool ProcessGroupByOverProject( RuleProcessingContext context, System.Data.Entity.Core.Query.InternalTrees.Node n, out System.Data.Entity.Core.Query.InternalTrees.Node newNode) { newNode = n; GroupByOp op = (GroupByOp)n.Op; Command command = context.Command; System.Data.Entity.Core.Query.InternalTrees.Node child0 = n.Child0; System.Data.Entity.Core.Query.InternalTrees.Node child1_1 = child0.Child1; System.Data.Entity.Core.Query.InternalTrees.Node child1_2 = n.Child1; System.Data.Entity.Core.Query.InternalTrees.Node child2 = n.Child2; if (child1_2.Children.Count > 0) { return(false); } VarVec varVec = command.GetExtendedNodeInfo(child0).LocalDefinitions; if (op.Outputs.Overlaps(varVec)) { return(false); } bool flag = false; for (int index = 0; index < child1_1.Children.Count; ++index) { System.Data.Entity.Core.Query.InternalTrees.Node child = child1_1.Children[index]; if (child.Child0.Op.OpType == OpType.Constant || child.Child0.Op.OpType == OpType.InternalConstant || child.Child0.Op.OpType == OpType.NullSentinel) { if (!flag) { varVec = command.CreateVarVec(varVec); flag = true; } varVec.Clear(((VarDefOp)child.Op).Var); } } if (GroupByOpRules.VarRefUsageFinder.AnyVarUsedMoreThanOnce(varVec, child2, command)) { return(false); } Dictionary <Var, System.Data.Entity.Core.Query.InternalTrees.Node> varReplacementTable = new Dictionary <Var, System.Data.Entity.Core.Query.InternalTrees.Node>(child1_1.Children.Count); for (int index = 0; index < child1_1.Children.Count; ++index) { System.Data.Entity.Core.Query.InternalTrees.Node child = child1_1.Children[index]; Var var = ((VarDefOp)child.Op).Var; varReplacementTable.Add(var, child.Child0); } newNode.Child2 = GroupByOpRules.VarRefReplacer.Replace(varReplacementTable, child2, command); newNode.Child0 = child0.Child0; return(true); }
private void Map(List <InternalTrees.SortKey> sortKeys) { VarVec sortVars = m_command.CreateVarVec(); bool hasDuplicates = false; // // Map each var in the sort list. Remapping may introduce duplicates, and // we should get rid of duplicates, since sql doesn't like them // foreach (InternalTrees.SortKey sk in sortKeys) { sk.Var = Map(sk.Var); if (sortVars.IsSet(sk.Var)) { hasDuplicates = true; } sortVars.Set(sk.Var); } // // Get rid of any duplicates // if (hasDuplicates) { List <InternalTrees.SortKey> newSortKeys = new List <SortKey>(sortKeys); sortKeys.Clear(); sortVars.Clear(); foreach (InternalTrees.SortKey sk in newSortKeys) { if (!sortVars.IsSet(sk.Var)) { sortKeys.Add(sk); } sortVars.Set(sk.Var); } } }
// <summary> // If we're going to eat the ProjectNode, then we at least need to make // sure we remap any vars it defines as varRefs, and ensure that any // references to them are switched. // </summary> private void EnsureReferencedVarsAreRemoved(List<Node> referencedVars, VarVec outputVars) { foreach (var chi in referencedVars) { var varDefOp = (VarDefOp)chi.Op; var defVar = varDefOp.Var; var refVar = ResolveVarReference(defVar); m_varRemapper.AddMapping(defVar, refVar); outputVars.Clear(defVar); outputVars.Set(refVar); } }
// <summary> // Clear out all information - usually used by a Recompute // </summary> internal virtual void Clear() { m_externalReferences.Clear(); m_hashValue = 0; }