/// <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;
}
