public static FilterSpecPlanPathForge SortRemoveDups(FilterSpecPlanPathForge parameters)
{
if (parameters.Triplets.Length <= 1) {
return parameters;
}
var map = new OrderedListDictionary<FilterOperator, IList<FilterSpecPlanPathTripletForge>>(COMPARATOR_PARAMETERS);
foreach (FilterSpecPlanPathTripletForge parameter in parameters.Triplets) {
if (!map.TryGetValue(parameter.Param.FilterOperator, out var list)) {
list = new List<FilterSpecPlanPathTripletForge>();
map[parameter.Param.FilterOperator] = list;
}
var hasDuplicate = list.Any(existing => Equals(existing.Param.Lookupable, parameter.Param.Lookupable));
if (hasDuplicate) {
continue;
}
list.Add(parameter);
}
var result = new List<FilterSpecPlanPathTripletForge>();
foreach (var entry in map) {
result.AddAll(entry.Value);
}
return new FilterSpecPlanPathForge(
result.ToArray(),
parameters.PathNegate);
}
private static FilterSpecPlanForge BuildNoPlan(
IList<ExprNode> validatedNodes,
FilterSpecCompilerArgs args)
{
var triplet = MakeRemainingNode(validatedNodes, args);
FilterSpecPlanPathTripletForge[] triplets = {triplet};
var path = new FilterSpecPlanPathForge(triplets, null);
FilterSpecPlanPathForge[] paths = {path};
return new FilterSpecPlanForge(paths, null, null, null);
}
internal static FilterSpecPlanForge PlanRemainingNodesBasic(
FilterSpecParaForgeMap overallExpressions,
FilterSpecCompilerArgs args,
int filterServiceMaxFilterWidth)
{
var unassigned = overallExpressions.UnassignedExpressions;
IList<ExprOrNode> orNodes = new List<ExprOrNode>(unassigned.Count);
foreach (var node in unassigned) {
if (node is ExprOrNode) {
orNodes.Add((ExprOrNode) node);
}
}
var expressionsWithoutOr = new FilterSpecParaForgeMap();
expressionsWithoutOr.Add(overallExpressions);
// first dimension: or-node index
// second dimension: or child node index
var orNodesMaps = new FilterSpecParaForgeMap[orNodes.Count][];
var countOr = 0;
var sizeFactorized = 1;
var sizePerOr = new int[orNodes.Count];
foreach (var orNode in orNodes) {
expressionsWithoutOr.RemoveNode(orNode);
orNodesMaps[countOr] = new FilterSpecParaForgeMap[orNode.ChildNodes.Length];
var len = orNode.ChildNodes.Length;
for (var i = 0; i < len; i++) {
var map = new FilterSpecParaForgeMap();
orNodesMaps[countOr][i] = map;
var nodes = Collections.SingletonList(orNode.ChildNodes[i]);
DecomposePopulateConsolidate(map, false, nodes, args);
}
sizePerOr[countOr] = len;
sizeFactorized = sizeFactorized * len;
countOr++;
}
// we become too large
if (sizeFactorized > filterServiceMaxFilterWidth) {
return null;
}
// combine
var result = new FilterSpecPlanPathForge[sizeFactorized];
var count = 0;
foreach (var permutation in CombinationEnumeration.FromZeroBasedRanges(sizePerOr)) {
result[count] = ComputePermutation(expressionsWithoutOr, permutation, orNodesMaps, args);
count++;
}
return new FilterSpecPlanForge(result, null, null, null);
}
public bool EqualsFilter(FilterSpecPlanPathForge other)
{
if (Triplets.Length != other.Triplets.Length) {
return false;
}
for (var i = 0; i < Triplets.Length; i++) {
var mytriplet = Triplets[i];
var othertriplet = other.Triplets[i];
if (!mytriplet.EqualsFilter(othertriplet)) {
return false;
}
}
if (!ExprNodeUtilityCompare.DeepEqualsNullChecked(PathNegate, other.PathNegate, true)) {
return false;
}
return true;
}
