ordering sort of works

Author: normen662

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/QueryPlanConstraint.java

@@ -62,6 +62,10 @@ public QueryPredicate getPredicate() {
         return predicate;
     }
 
+    public boolean isTautology() {
+        return predicate.isTautology();
+    }
+
     @Override
     public boolean equals(final Object o) {
         if (this == o) {

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/AggregateIndexMatchCandidate.java

@@ -215,9 +215,9 @@ public List<MatchedOrderingPart> computeMatchedOrderingParts(@Nonnull final Matc
         final var candidateParameterIds = getOrderingAliases();
         final var normalizedValues = Sets.newHashSetWithExpectedSize(normalizedKeyExpressions.size());
 
-        final var selectHavingResultValue = selectHavingExpression.getResultValue();
-        final var deconstructedValue = Values.deconstructRecord(selectHavingResultValue);
-        final var aliasMap = AliasMap.ofAliases(Iterables.getOnlyElement(selectHavingResultValue.getCorrelatedTo()), Quantifier.current());
+        final var selectHavingResultType = selectHavingExpression.getResultValue().getResultType();
+        final var deconstructedValues =
+                Values.deconstructRecord(QuantifiedObjectValue.of(Quantifier.current(), selectHavingResultType));
 
         // Compute the ordering for this index by collecting the result values of the selectHaving statement
         // associated with each sortParameterId. Note that for most aggregate indexes, the aggregate value is
@@ -248,7 +248,7 @@ public List<MatchedOrderingPart> computeMatchedOrderingParts(@Nonnull final Matc
             }
 
             // Grab the value for this sortParameterID from the selectHaving result columns
-            final var value = deconstructedValue.get(permutedIndex).rebase(aliasMap);
+            final var value = deconstructedValues.get(permutedIndex);
 
             if (normalizedValues.add(value)) {
                 final var matchedOrderingPart =
@@ -286,7 +286,6 @@ public Ordering computeOrderingFromScanComparisons(@Nonnull final ScanComparison
         final int groupingCount = ((GroupingKeyExpression)index.getRootExpression()).getGroupingCount();
 
         if (!isPermuted() && groupingCount == 0) {
-            // TODO this should be something like anything-order.
             return Ordering.empty();
         }
 

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/AggregateMappings.java

@@ -32,7 +32,6 @@
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableBiMap;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Sets;
@@ -43,7 +42,6 @@
 import java.util.Set;
 import java.util.function.Function;
 import java.util.function.Supplier;
-import java.util.stream.Stream;
 
 /**
  * Interface for all kinds of compensation. A compensation is the byproduct of expression DAG matching.
@@ -410,7 +408,7 @@ default ForMatch derived(final boolean isImpossible,
                              @Nonnull final Set<? extends Quantifier> unmatchedQuantifiers,
                              @Nonnull final Set<CorrelationIdentifier> compensatedAliases,
                              @Nonnull final ResultCompensationFunction resultCompensationFunction,
-                             @Nonnull final AggregateMappings aggregateMappings) {
+                             @Nonnull final GroupByMappings groupByMappings) {
         //
         // At least one of these conditions must be true:
         // - it is an impossible compensation (in which case the predicate compensation map may be empty)
@@ -423,7 +421,7 @@ default ForMatch derived(final boolean isImpossible,
                 !predicateCompensationMap.isEmpty() || resultCompensationFunction.isNeeded() || isNeededForFiltering());
 
         return new ForMatch(isImpossible, this, predicateCompensationMap, matchedQuantifiers,
-                unmatchedQuantifiers, compensatedAliases, resultCompensationFunction, aggregateMappings);
+                unmatchedQuantifiers, compensatedAliases, resultCompensationFunction, groupByMappings);
     }
 
     /**
@@ -474,7 +472,7 @@ default boolean isFinalNeeded() {
         ResultCompensationFunction getResultCompensationFunction();
 
         @Nonnull
-        AggregateMappings getAggregateMappings();
+        GroupByMappings getGroupByMappings();
 
         /**
          * Specific implementation of union-ing two compensations both of type {@link WithSelectCompensation}.
@@ -570,7 +568,7 @@ default Compensation union(@Nonnull Compensation otherCompensation) {
                     ImmutableSet.of(),
                     Sets.union(getCompensatedAliases(), otherWithSelectCompensation.getCompensatedAliases()),
                     newResultResultCompensationFunction,
-                    AggregateMappings.empty());
+                    GroupByMappings.empty());
         }
 
         /**
@@ -601,26 +599,40 @@ default Compensation intersect(@Nonnull Compensation otherCompensation) {
                 return Compensation.impossibleCompensation();
             }
 
-            final var newMatchedAggregateMap =
-                    Stream.concat(getAggregateMappings().getMatchedAggregateMap().entrySet().stream(),
-                                    otherWithSelectCompensation.getAggregateMappings().getMatchedAggregateMap().entrySet().stream())
-                            .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey,
-                                    Map.Entry::getValue,
-                                    (l, r) -> l));
-            final var newUnmatchedAggregateMapBuilder =
+            final var newMatchedGroupingsMapBuilder = ImmutableBiMap.<Value, Value>builder();
+            final var matchedGroupingsMap = getGroupByMappings().getMatchedGroupingsMap();
+            newMatchedGroupingsMapBuilder.putAll(matchedGroupingsMap);
+            for (final var entry : otherWithSelectCompensation.getGroupByMappings().getMatchedGroupingsMap().entrySet()) {
+                if (!matchedGroupingsMap.containsKey(entry.getKey())) {
+                    newMatchedGroupingsMapBuilder.put(entry);
+                }
+            }
+
+            final var newMatchedAggregatesMapBuilder = ImmutableBiMap.<Value, Value>builder();
+            final var matchedAggregatesMap = getGroupByMappings().getMatchedAggregatesMap();
+            newMatchedAggregatesMapBuilder.putAll(matchedAggregatesMap);
+            for (final var entry : otherWithSelectCompensation.getGroupByMappings().getMatchedAggregatesMap().entrySet()) {
+                if (!matchedAggregatesMap.containsKey(entry.getKey())) {
+                    newMatchedAggregatesMapBuilder.put(entry);
+                }
+            }
+            final var newMatchedAggregatesMap = newMatchedAggregatesMapBuilder.build();
+            final var newUnmatchedAggregatesMapBuilder =
                     ImmutableBiMap.<CorrelationIdentifier, Value>builder();
-            final var unmatchedAggregateMap = getAggregateMappings().getUnmatchedAggregateMap();
+            final var unmatchedAggregateMap = getGroupByMappings().getUnmatchedAggregatesMap();
             for (final var entry : unmatchedAggregateMap.entrySet()) {
-                if (!newMatchedAggregateMap.containsKey(entry.getValue())) {
-                    newUnmatchedAggregateMapBuilder.put(entry);
+                if (!newMatchedAggregatesMap.containsKey(entry.getValue())) {
+                    newUnmatchedAggregatesMapBuilder.put(entry);
                 }
             }
-            for (final var entry : otherWithSelectCompensation.getAggregateMappings().getUnmatchedAggregateMap().entrySet()) {
-                if (!newMatchedAggregateMap.containsKey(entry.getValue())) {
-                    newUnmatchedAggregateMapBuilder.put(entry);
+            for (final var entry : otherWithSelectCompensation.getGroupByMappings().getUnmatchedAggregatesMap().entrySet()) {
+                if (!newMatchedAggregatesMap.containsKey(entry.getValue()) &&
+                        !unmatchedAggregateMap.inverse().containsKey(entry.getValue())) {
+                    newUnmatchedAggregatesMapBuilder.put(entry);
                 }
             }
-            final var newAggregateMappings = AggregateMappings.of(newMatchedAggregateMap, newUnmatchedAggregateMapBuilder.build());
+            final var newGroupByMappings = GroupByMappings.of(newMatchedGroupingsMapBuilder.build(),
+                    newMatchedAggregatesMap, newUnmatchedAggregatesMapBuilder.build());
 
             final ResultCompensationFunction newResultResultCompensationFunction;
             final var resultCompensationFunction = getResultCompensationFunction();
@@ -633,7 +645,7 @@ default Compensation intersect(@Nonnull Compensation otherCompensation) {
                 Verify.verify(otherResultCompensationFunction.isNeeded());
                 // pick the one from this side -- it does not matter as both candidates have the same shape
                 newResultResultCompensationFunction =
-                        resultCompensationFunction.amend(unmatchedAggregateMap, newMatchedAggregateMap);
+                        resultCompensationFunction.amend(unmatchedAggregateMap, newMatchedAggregatesMap);
             }
 
             final var otherCompensationMap =
@@ -651,7 +663,7 @@ default Compensation intersect(@Nonnull Compensation otherCompensation) {
                     //    either compensation and let the planner figure out which one wins. We just pick one side here.
                     // 2. TODO.
                     combinedPredicateMap.put(entry.getKey(),
-                            entry.getValue().amend(unmatchedAggregateMap, newMatchedAggregateMap));
+                            entry.getValue().amend(unmatchedAggregateMap, newMatchedAggregatesMap));
                 }
             }
 
@@ -685,7 +697,7 @@ default Compensation intersect(@Nonnull Compensation otherCompensation) {
                     intersectedUnmatchedQuantifiers,
                     getCompensatedAliases(), // both compensated aliases must be identical, but too expensive to check
                     newResultResultCompensationFunction,
-                    newAggregateMappings);
+                    newGroupByMappings);
         }
     }
 
@@ -715,7 +727,7 @@ class ForMatch implements WithSelectCompensation {
         @Nonnull
         private final ResultCompensationFunction resultCompensationFunction;
         @Nonnull
-        private final AggregateMappings aggregateMappings;
+        private final GroupByMappings groupByMappings;
 
         @Nonnull
         private final Supplier<Set<Quantifier>> unmatchedForEachQuantifiersSupplier;
@@ -727,7 +739,7 @@ private ForMatch(final boolean isImpossible,
                          @Nonnull final Collection<? extends Quantifier> unmatchedQuantifiers,
                          @Nonnull final Set<CorrelationIdentifier> compensatedAliases,
                          @Nonnull final ResultCompensationFunction resultCompensationFunction,
-                         @Nonnull final AggregateMappings aggregateMappings) {
+                         @Nonnull final GroupByMappings groupByMappings) {
             this.isImpossible = isImpossible;
             this.childCompensation = childCompensation;
             this.predicateCompensationMap = new LinkedIdentityMap<>();
@@ -738,7 +750,7 @@ private ForMatch(final boolean isImpossible,
             this.unmatchedQuantifiers.addAll(unmatchedQuantifiers);
             this.compensatedAliases = ImmutableSet.copyOf(compensatedAliases);
             this.resultCompensationFunction = resultCompensationFunction;
-            this.aggregateMappings = aggregateMappings;
+            this.groupByMappings = groupByMappings;
             this.unmatchedForEachQuantifiersSupplier = Suppliers.memoize(this::computeUnmatchedForEachQuantifiers);
         }
 
@@ -798,8 +810,8 @@ public ResultCompensationFunction getResultCompensationFunction() {
 
         @Nonnull
         @Override
-        public AggregateMappings getAggregateMappings() {
-            return aggregateMappings;
+        public GroupByMappings getGroupByMappings() {
+            return groupByMappings;
         }
 
         /**

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Compensation.java

@@ -0,0 +1,73 @@
+/*
+ * GroupByMappings.java
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2015-2025 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.apple.foundationdb.record.query.plan.cascades;
+
+import com.apple.foundationdb.record.query.plan.cascades.values.Value;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.ImmutableBiMap;
+
+import javax.annotation.Nonnull;
+
+public class GroupByMappings {
+    @Nonnull
+    private final BiMap<Value, Value> matchedGroupingsMap;
+    @Nonnull
+    private final BiMap<Value, Value> matchedAggregatesMap;
+
+    @Nonnull
+    private final BiMap<CorrelationIdentifier, Value> unmatchedAggregatesMap;
+
+    private GroupByMappings(@Nonnull final BiMap<Value, Value> matchedGroupingsMap,
+                            @Nonnull final BiMap<Value, Value> matchedAggregatesMap,
+                            @Nonnull final BiMap<CorrelationIdentifier, Value> unmatchedAggregatesMap) {
+        this.matchedGroupingsMap = matchedGroupingsMap;
+        this.matchedAggregatesMap = matchedAggregatesMap;
+        this.unmatchedAggregatesMap = unmatchedAggregatesMap;
+    }
+
+    @Nonnull
+    public BiMap<Value, Value> getMatchedGroupingsMap() {
+        return matchedGroupingsMap;
+    }
+
+    @Nonnull
+    public BiMap<Value, Value> getMatchedAggregatesMap() {
+        return matchedAggregatesMap;
+    }
+
+    @Nonnull
+    public BiMap<CorrelationIdentifier, Value> getUnmatchedAggregatesMap() {
+        return unmatchedAggregatesMap;
+    }
+
+    public static GroupByMappings empty() {
+        return of(ImmutableBiMap.of(), ImmutableBiMap.of(), ImmutableBiMap.of());
+    }
+
+    @Nonnull
+    public static GroupByMappings of(@Nonnull final BiMap<Value, Value> matchedGroupingsMap,
+                                     @Nonnull final BiMap<Value, Value> matchedAggregateMap,
+                                     @Nonnull final BiMap<CorrelationIdentifier, Value> unmatchedAggregatesMap) {
+        return new GroupByMappings(ImmutableBiMap.copyOf(matchedGroupingsMap),
+                ImmutableBiMap.copyOf(matchedAggregateMap),
+                ImmutableBiMap.copyOf(unmatchedAggregatesMap));
+    }
+}