diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/combinatorics/TopologicalSort.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/combinatorics/TopologicalSort.java
index a61714e859..02c1ce76e3 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/combinatorics/TopologicalSort.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/combinatorics/TopologicalSort.java
@@ -730,6 +730,10 @@ public static <T> Optional<List<T>> anyTopologicalOrderPermutation(@Nonnull fina
      * @return a permutation of the set that is topologically correctly ordered with respect to {@code dependsOnFn}
      */
     public static <T> Optional<List<T>> anyTopologicalOrderPermutation(@Nonnull final PartiallyOrderedSet<T> partiallyOrderedSet) {
+        if (partiallyOrderedSet.getDependencyMap().isEmpty()) {
+            // if there are no dependencies, just return a list copy of the set
+            return Optional.of(ImmutableList.copyOf(partiallyOrderedSet.getSet()));
+        }
         return anyTopologicalOrderPermutation(partiallyOrderedSet.getSet(),
                 () -> new KahnIterable<>(PartiallyOrderedSet.of(partiallyOrderedSet.getSet(), partiallyOrderedSet.getDependencyMap().inverse())));
     }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlanComplexityException.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlanComplexityException.java
index bf6acfb247..dd93bb6d89 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlanComplexityException.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlanComplexityException.java
@@ -23,8 +23,8 @@
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.RecordCoreException;
 import com.apple.foundationdb.record.logging.LogMessageKeys;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.explain.ExplainLevel;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 
 import javax.annotation.Nonnull;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlanner.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlanner.java
index f2420bdf28..f1bcd08a7f 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlanner.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlanner.java
@@ -74,9 +74,7 @@
 import com.apple.foundationdb.record.query.expressions.RecordTypeKeyComparison;
 import com.apple.foundationdb.record.query.plan.cascades.ComparisonRange;
 import com.apple.foundationdb.record.query.plan.cascades.ComparisonRanges;
-import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.ComparisonsProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.FieldWithComparisonCountProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.planning.BooleanNormalizer;
 import com.apple.foundationdb.record.query.plan.planning.FilterSatisfiedMask;
@@ -131,6 +129,9 @@
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.ComparisonsProperty.comparisons;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.FieldWithComparisonCountProperty.fieldWithComparisonCount;
+
 /**
  * The query planner.
  *
@@ -333,7 +334,7 @@ public RecordQueryPlan plan(@Nonnull RecordQuery query, @Nonnull ParameterRelati
 
         if (logger.isTraceEnabled()) {
             logger.trace(KeyValueLogMessage.of("explain of plan",
-                    "explain", PlannerGraphProperty.explain(plan)));
+                    "explain", PlannerGraphVisitor.explain(plan)));
         }
 
         return plan;
@@ -543,7 +544,8 @@ private ScoredPlan planFilter(@Nonnull PlanContext planContext, @Nonnull QueryCo
         final ScoredPlan withInJoin = planFilterWithInJoin(planContext, inExtractor, needOrdering);
         if (withInAsOrUnion != null) {
             if (withInJoin == null || withInAsOrUnion.score > withInJoin.score ||
-                    FieldWithComparisonCountProperty.evaluate(withInAsOrUnion.getPlan()) < FieldWithComparisonCountProperty.evaluate(withInJoin.getPlan())) {
+                    fieldWithComparisonCount().evaluate(withInAsOrUnion.getPlan()) <
+                            fieldWithComparisonCount().evaluate(withInJoin.getPlan())) {
                 return withInAsOrUnion;
             }
         }
@@ -943,7 +945,7 @@ private ScoredPlan computePlanProperties(@Nonnull PlanContext planContext, @Nonn
     }
 
     protected Set<Comparisons.Comparison> computeSargedComparisons(@Nonnull final RecordQueryPlan plan) {
-        return ComparisonsProperty.evaluate(plan);
+        return comparisons().evaluate(plan);
     }
 
     @Nullable
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlannerConfiguration.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlannerConfiguration.java
index 9d1ed9d53c..c5775ae64a 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlannerConfiguration.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/RecordQueryPlannerConfiguration.java
@@ -25,7 +25,7 @@
 import com.apple.foundationdb.record.RecordPlannerConfigurationProto;
 import com.apple.foundationdb.record.query.RecordQuery;
 import com.apple.foundationdb.record.query.plan.cascades.CascadesRule;
-import com.apple.foundationdb.record.query.plan.cascades.PlannerRuleSet;
+import com.apple.foundationdb.record.query.plan.cascades.PlanningRuleSet;
 import com.apple.foundationdb.record.query.plan.cascades.rules.PredicateToLogicalUnionRule;
 import com.apple.foundationdb.record.query.plan.plans.QueryPlan;
 import com.apple.foundationdb.record.query.plan.serialization.PlanSerialization;
@@ -605,11 +605,11 @@ public Builder setDisabledTransformationRules(@Nonnull final Set<Class<? extends
          * for any planning effort.
          * @param disabledTransformationRuleNames a set of rule names identifying (via simple class name)
          *        transformation rules
-         * @param plannerRuleSet a {@link PlannerRuleSet} that is used to resolve the rule name to a rule class
+         * @param planningRuleSet a {@link PlanningRuleSet} that is used to resolve the rule name to a rule class
          * @return this builder
          */
         @Nonnull
-        public Builder setDisabledTransformationRuleNames(@Nonnull final Set<String> disabledTransformationRuleNames, @Nonnull PlannerRuleSet plannerRuleSet) {
+        public Builder setDisabledTransformationRuleNames(@Nonnull final Set<String> disabledTransformationRuleNames, @Nonnull PlanningRuleSet planningRuleSet) {
             protoBuilder.clearDisabledTransformationRules()
                     .addAllDisabledTransformationRules(disabledTransformationRuleNames);
             return this;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesCostModel.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesCostModel.java
index 78c19faf43..fe9497f93c 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesCostModel.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesCostModel.java
@@ -26,15 +26,10 @@
 import com.apple.foundationdb.record.query.plan.QueryPlanner.IndexScanPreference;
 import com.apple.foundationdb.record.query.plan.RecordQueryPlannerConfiguration;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.properties.CardinalitiesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.properties.CardinalitiesProperty.Cardinalities;
 import com.apple.foundationdb.record.query.plan.cascades.properties.CardinalitiesProperty.Cardinality;
-import com.apple.foundationdb.record.query.plan.cascades.properties.ComparisonsProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.FindExpressionProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.ExpressionDepthProperty;
 import com.apple.foundationdb.record.query.plan.cascades.properties.NormalizedResidualPredicateProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.RelationalExpressionDepthProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.TypeFilterCountProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UnmatchedFieldsCountProperty;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryCoveringIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryFetchFromPartialRecordPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryInJoinPlan;
@@ -55,11 +50,18 @@
 import java.util.function.Supplier;
 
 import static com.apple.foundationdb.record.Bindings.Internal.CORRELATION;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.CardinalitiesProperty.cardinalities;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.ComparisonsProperty.comparisons;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.ExpressionDepthProperty.fetchDepth;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.ExpressionDepthProperty.typeFilterDepth;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.TypeFilterCountProperty.typeFilterCount;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UnmatchedFieldsCountProperty.unmatchedFieldsCount;
 
 /**
  * A comparator implementing the current heuristic cost model for the {@link CascadesPlanner}.
  */
 @API(API.Status.EXPERIMENTAL)
+@SuppressWarnings("PMD.TooManyStaticImports")
 public class CascadesCostModel implements Comparator<RelationalExpression> {
     @Nonnull
     private static final Set<Class<? extends RelationalExpression>> interestingPlanClasses =
@@ -89,13 +91,13 @@ public int compare(@Nonnull RelationalExpression a, @Nonnull RelationalExpressio
         }
 
         final Map<Class<? extends RelationalExpression>, Set<RelationalExpression>> planOpsMapA =
-                FindExpressionProperty.evaluate(interestingPlanClasses, a);
+                FindExpressionVisitor.evaluate(interestingPlanClasses, a);
 
         final Map<Class<? extends RelationalExpression>, Set<RelationalExpression>> planOpsMapB =
-                FindExpressionProperty.evaluate(interestingPlanClasses, b);
+                FindExpressionVisitor.evaluate(interestingPlanClasses, b);
 
-        final Cardinalities cardinalitiesA = CardinalitiesProperty.evaluate(a);
-        final Cardinalities cardinalitiesB = CardinalitiesProperty.evaluate(b);
+        final Cardinalities cardinalitiesA = cardinalities().evaluate(a);
+        final Cardinalities cardinalitiesB = cardinalities().evaluate(b);
 
         //
         // Technically, both cardinalities at runtime must be the same. The question is if we can actually
@@ -155,8 +157,8 @@ public int compare(@Nonnull RelationalExpression a, @Nonnull RelationalExpressio
             return inPlanVsOtherOptional.getAsInt();
         }
 
-        final int typeFilterCountA = TypeFilterCountProperty.evaluate(a);
-        final int typeFilterCountB = TypeFilterCountProperty.evaluate(b);
+        final int typeFilterCountA = typeFilterCount().evaluate(a);
+        final int typeFilterCountB = typeFilterCount().evaluate(b);
 
         // special case
         // if one plan is a primary scan with a type filter and the other one is an index scan with the same number of
@@ -174,8 +176,8 @@ public int compare(@Nonnull RelationalExpression a, @Nonnull RelationalExpressio
             return typeFilterCountCompare;
         }
 
-        int typeFilterPositionCompare = Integer.compare(RelationalExpressionDepthProperty.TYPE_FILTER_DEPTH.evaluate(b),
-                RelationalExpressionDepthProperty.TYPE_FILTER_DEPTH.evaluate(a)); // prefer the one with a deeper type filter
+        // prefer the one with a deeper type filter
+        int typeFilterPositionCompare = Integer.compare(typeFilterDepth().evaluate(b), typeFilterDepth().evaluate(a));
         if (typeFilterPositionCompare != 0) {
             return typeFilterPositionCompare;
         }
@@ -193,8 +195,8 @@ public int compare(@Nonnull RelationalExpression a, @Nonnull RelationalExpressio
                 return numFetchesCompare;
             }
 
-            final int fetchDepthB = RelationalExpressionDepthProperty.FETCH_DEPTH.evaluate(b);
-            final int fetchDepthA = RelationalExpressionDepthProperty.FETCH_DEPTH.evaluate(a);
+            final int fetchDepthB = fetchDepth().evaluate(b);
+            final int fetchDepthA = fetchDepth().evaluate(a);
             int fetchPositionCompare = Integer.compare(fetchDepthA, fetchDepthB);
             if (fetchPositionCompare != 0) {
                 return fetchPositionCompare;
@@ -211,14 +213,14 @@ public int compare(@Nonnull RelationalExpression a, @Nonnull RelationalExpressio
             }
         }
 
-        int distinctFilterPositionCompare = Integer.compare(RelationalExpressionDepthProperty.DISTINCT_FILTER_DEPTH.evaluate(b),
-                RelationalExpressionDepthProperty.DISTINCT_FILTER_DEPTH.evaluate(a));
+        int distinctFilterPositionCompare = Integer.compare(ExpressionDepthProperty.distinctDepth().evaluate(b),
+                ExpressionDepthProperty.distinctDepth().evaluate(a));
         if (distinctFilterPositionCompare != 0) {
             return distinctFilterPositionCompare;
         }
 
-        int ufpA = UnmatchedFieldsCountProperty.evaluate(a);
-        int ufpB = UnmatchedFieldsCountProperty.evaluate(b);
+        int ufpA = unmatchedFieldsCount().evaluate(a);
+        int ufpB = unmatchedFieldsCount().evaluate(b);
         if (ufpA != ufpB) {
             return Integer.compare(ufpA, ufpB);
         }
@@ -266,9 +268,9 @@ public int compare(@Nonnull RelationalExpression a, @Nonnull RelationalExpressio
 
     @Nonnull
     private Cardinality maxOfMaxCardinalitiesOfAllDataAccesses(@Nonnull final Map<Class<? extends RelationalExpression>, Set<RelationalExpression>> planOpsMap) {
-        return FindExpressionProperty.slice(planOpsMap, RecordQueryScanPlan.class, RecordQueryPlanWithIndex.class, RecordQueryCoveringIndexPlan.class)
+        return FindExpressionVisitor.slice(planOpsMap, RecordQueryScanPlan.class, RecordQueryPlanWithIndex.class, RecordQueryCoveringIndexPlan.class)
                 .stream()
-                .map(plan -> CardinalitiesProperty.evaluate(plan).getMaxCardinality())
+                .map(plan -> cardinalities().evaluate(plan).getMaxCardinality())
                 .reduce(Cardinality.ofCardinality(0),
                         (l, r) -> {
                             if (l.isUnknown()) {
@@ -314,8 +316,8 @@ private OptionalInt comparePrimaryScanToIndexScan(@Nonnull RelationalExpression
                 isSingularIndexScanWithFetch(planOpsMapIndexScan)) {
 
             if (typeFilterCountPrimaryScan > 0 && typeFilterCountIndexScan == 0) {
-                final var primaryScanComparisons = ComparisonsProperty.evaluate(primaryScan);
-                final var indexScanComparisons = ComparisonsProperty.evaluate(indexScan);
+                final var primaryScanComparisons = comparisons().evaluate(primaryScan);
+                final var indexScanComparisons = comparisons().evaluate(indexScan);
 
                 //
                 // The primary scan side has a type filter in it, the index scan side does not. The primary side
@@ -373,7 +375,7 @@ private OptionalInt compareInOperator(@Nonnull final RelationalExpression leftEx
         
         // If no scan comparison on the in union side uses a comparison to the in-values, then the in union
         // plan is not useful.
-        final Set<Comparisons.Comparison> scanComparisonsSet = ComparisonsProperty.evaluate(leftExpression);
+        final Set<Comparisons.Comparison> scanComparisonsSet = comparisons().evaluate(leftExpression);
 
         final ImmutableSet<CorrelationIdentifier> scanComparisonsCorrelatedTo =
                 scanComparisonsSet
@@ -429,6 +431,6 @@ private static OptionalInt flipFlop(final Supplier<OptionalInt> variantA,
 
     @SafeVarargs
     private static int count(@Nonnull final Map<Class<? extends RelationalExpression>, Set<RelationalExpression>> expressionsMap, @Nonnull final Class<? extends RelationalExpression>... interestingClasses) {
-        return FindExpressionProperty.slice(expressionsMap, interestingClasses).size();
+        return FindExpressionVisitor.slice(expressionsMap, interestingClasses).size();
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesPlanner.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesPlanner.java
index 3afd814791..28ba0774e4 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesPlanner.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesPlanner.java
@@ -30,7 +30,6 @@
 import com.apple.foundationdb.record.query.IndexQueryabilityFilter;
 import com.apple.foundationdb.record.query.ParameterRelationshipGraph;
 import com.apple.foundationdb.record.query.RecordQuery;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.QueryPlanConstraint;
 import com.apple.foundationdb.record.query.plan.QueryPlanInfo;
 import com.apple.foundationdb.record.query.plan.QueryPlanInfoKeys;
@@ -42,11 +41,12 @@
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger;
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger.Location;
 import com.apple.foundationdb.record.query.plan.cascades.debug.RestartException;
-import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlannerBindings;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.plans.QueryPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 import com.google.common.base.Suppliers;
@@ -83,7 +83,7 @@
  * Like many optimization frameworks, Cascades is driven by sets of {@link CascadesRule}s that can be defined for
  * {@link RelationalExpression}s, {@link PartialMatch}es and {@link MatchPartition}s, each of which describes a
  * particular transformation and encapsulates the logic for determining its applicability and applying it. The planner
- * searches through its {@link PlannerRuleSet} to find a matching rule and then executes that rule, creating zero or
+ * searches through its {@link PlanningRuleSet} to find a matching rule and then executes that rule, creating zero or
  * more additional {@code PlannerExpression}s and/or zero or more additional {@link PartialMatch}es. A rule is defined by:
  * </p>
  * <ul>
@@ -206,7 +206,7 @@ public class CascadesPlanner implements QueryPlanner {
     @Nonnull
     private final RecordStoreState recordStoreState;
     @Nonnull
-    private final PlannerRuleSet ruleSet;
+    private final PlanningRuleSet ruleSet;
     @Nonnull
     private Reference currentRoot;
     @Nonnull
@@ -222,7 +222,7 @@ public CascadesPlanner(@Nonnull RecordMetaData metaData, @Nonnull RecordStoreSta
         this(metaData, recordStoreState, defaultPlannerRuleSet());
     }
 
-    public CascadesPlanner(@Nonnull RecordMetaData metaData, @Nonnull RecordStoreState recordStoreState, @Nonnull PlannerRuleSet ruleSet) {
+    public CascadesPlanner(@Nonnull RecordMetaData metaData, @Nonnull RecordStoreState recordStoreState, @Nonnull PlanningRuleSet ruleSet) {
         this.configuration = RecordQueryPlannerConfiguration.builder().build();
         this.metaData = metaData;
         this.recordStoreState = recordStoreState;
@@ -375,7 +375,7 @@ private RecordQueryPlan resultOrFail() {
         if (singleRoot instanceof RecordQueryPlan) {
             if (logger.isDebugEnabled()) {
                 logger.debug(KeyValueLogMessage.of("GML explain of plan",
-                        "explain", PlannerGraphProperty.explain(singleRoot)));
+                        "explain", PlannerGraphVisitor.explain(singleRoot)));
                 logger.debug(KeyValueLogMessage.of("string explain of plan",
                         "explain", ExplainPlanVisitor.toStringForDebugging((RecordQueryPlan)singleRoot)));
             }
@@ -656,7 +656,7 @@ public RelationalExpression getExpression() {
         }
 
         @Nonnull
-        protected PlannerRuleSet getRules() {
+        protected PlanningRuleSet getRules() {
             return ruleSet;
         }
     }
@@ -1125,10 +1125,10 @@ public String toString() {
 
     /**
      * Returns the default set of transformation rules.
-     * @return a {@link PlannerRuleSet} using the default set of transformation rules
+     * @return a {@link PlanningRuleSet} using the default set of transformation rules
      */
     @Nonnull
-    public static PlannerRuleSet defaultPlannerRuleSet() {
-        return PlannerRuleSet.DEFAULT;
+    public static PlanningRuleSet defaultPlannerRuleSet() {
+        return PlanningRuleSet.DEFAULT;
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesRule.java
index 04bc9bdef0..a9ceaf36c8 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/CascadesRule.java
@@ -82,7 +82,7 @@ public CascadesRule(@Nonnull BindingMatcher<T> matcher, Collection<PlannerConstr
      * Returns the class of the operator at the root of the binding expression, if this rule uses a non-trivial binding.
      * Used primarily for indexing rules for more efficient rule search.
      * @return the class of the root of this rule's binding, or <code>Optional.empty()</code> if the rule matches anything
-     * @see PlannerRuleSet
+     * @see PlanningRuleSet
      */
     @Nonnull
     @Override
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPartition.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPartition.java
new file mode 100644
index 0000000000..db4e284c01
--- /dev/null
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPartition.java
@@ -0,0 +1,61 @@
+/*
+ * ExpressionPartition.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.expressions.RelationalExpression;
+import com.google.common.collect.ImmutableMap;
+
+import javax.annotation.Nonnull;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * A partition used for matching holding a set of {@link RelationalExpression}s.
+ * @param <E> type parameter to indicate the type of expression this partition holds.
+ */
+public class ExpressionPartition<E extends RelationalExpression> {
+    @Nonnull
+    private final Map<ExpressionProperty<?>, ?> propertyValuesMap;
+    @Nonnull
+    private final Set<E> expressions;
+
+    public ExpressionPartition(final Map<ExpressionProperty<?>, ?> propertyValuesMap, final Collection<E> expressions) {
+        this.propertyValuesMap = ImmutableMap.copyOf(propertyValuesMap);
+        this.expressions = new LinkedIdentitySet<>(expressions);
+    }
+
+    @Nonnull
+    public Map<ExpressionProperty<?>, ?> getPropertyValuesMap() {
+        return propertyValuesMap;
+    }
+
+    @Nonnull
+    public <A> A getPropertyValue(@Nonnull final ExpressionProperty<A> expressionProperty) {
+        return expressionProperty.narrowAttribute(Objects.requireNonNull(propertyValuesMap.get(expressionProperty)));
+    }
+
+    @Nonnull
+    public Set<E> getExpressions() {
+        return expressions;
+    }
+}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPartitions.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPartitions.java
new file mode 100644
index 0000000000..903f8acd85
--- /dev/null
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPartitions.java
@@ -0,0 +1,111 @@
+/*
+ * ExpressionPartitions.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.expressions.RelationalExpression;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+
+import javax.annotation.Nonnull;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.stream.Collectors;
+
+/**
+ * Helpers for collections of {@link ExpressionPartition}.
+ */
+public class ExpressionPartitions {
+    private ExpressionPartitions() {
+        // do not instantiate
+    }
+
+    @Nonnull
+    public static <E extends RelationalExpression> List<ExpressionPartition<E>> rollUpTo(@Nonnull final Collection<ExpressionPartition<E>> expressionPartitions,
+                                                                                         @Nonnull final ExpressionProperty<?> property) {
+        return rollUpTo(expressionPartitions,
+                ImmutableSet.of(property),
+                ExpressionPartition::new);
+    }
+
+    @Nonnull
+    protected static <E extends RelationalExpression, P extends ExpressionPartition<E>> List<P> rollUpTo(@Nonnull final Collection<P> expressionPartitions,
+                                                                                                         @Nonnull final ExpressionProperty<?> property,
+                                                                                                         @Nonnull final BiFunction<Map<ExpressionProperty<?>, ?>, Collection<E>, P> partitionCreatorFunction) {
+        return rollUpTo(expressionPartitions, ImmutableSet.of(property), partitionCreatorFunction);
+    }
+
+    @Nonnull
+    public static <E extends RelationalExpression> List<ExpressionPartition<E>> rollUpTo(@Nonnull final Collection<ExpressionPartition<E>> expressionPartitions,
+                                                                                         @Nonnull final Set<ExpressionProperty<?>> rollupProperties) {
+        return rollUpTo(expressionPartitions, rollupProperties, ExpressionPartition::new);
+    }
+
+    @Nonnull
+    static <E extends RelationalExpression, P extends ExpressionPartition<E>> List<P> rollUpTo(@Nonnull final Collection<P> planPartitions,
+                                                                                               @Nonnull final Set<ExpressionProperty<?>> rollupProperties,
+                                                                                               @Nonnull final BiFunction<Map<ExpressionProperty<?>, ?>, Collection<E>, P> partitionCreatorFunction) {
+        final Map<Map<ExpressionProperty<?>, ?>, ? extends Set<E>> rolledUpAttributesMap =
+                planPartitions
+                        .stream()
+                        .map(planPartition -> {
+                            final var attributesMap = planPartition.getPropertyValuesMap();
+                            final Map<ExpressionProperty<?>, ?> filteredAttributesMap =
+                                    attributesMap
+                                            .entrySet()
+                                            .stream()
+                                            .filter(attributeEntry -> rollupProperties.contains(attributeEntry.getKey()))
+                                            .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
+
+                            // create a new partition that uses only the rollup attributes
+                            return new ExpressionPartition<>(filteredAttributesMap, planPartition.getExpressions());
+                        })
+                        // group by the filtered attributes rolling up to form new sets of plans
+                        .collect(Collectors.groupingBy(ExpressionPartition::getPropertyValuesMap,
+                                LinkedHashMap::new,
+                                Collectors.flatMapping(planPartition -> planPartition.getExpressions().stream(), LinkedIdentitySet.toLinkedIdentitySet())));
+
+        return toPartitions(rolledUpAttributesMap, partitionCreatorFunction);
+    }
+
+    @Nonnull
+    protected static <E extends RelationalExpression> List<ExpressionPartition<E>> toPartitions(@Nonnull final Map<Map<ExpressionProperty<?>, ?>, ? extends Set<E>> propertiesToExpressionsMap) {
+        return toPartitions(propertiesToExpressionsMap, ExpressionPartition::new);
+    }
+
+    @Nonnull
+    protected static <E extends RelationalExpression, P extends ExpressionPartition<E>> List<P> toPartitions(@Nonnull final Map<Map<ExpressionProperty<?>, ?>, ? extends Set<E>> propertiesToExpressionsMap,
+                                                                                                             @Nonnull final BiFunction<Map<ExpressionProperty<?>, ?>, Collection<E>, P> partitionCreatorFunction) {
+        return propertiesToExpressionsMap
+                .entrySet()
+                .stream()
+                .map(entry -> {
+                    final var attributesMap = entry.getKey();
+                    final var plans = entry.getValue();
+                    return partitionCreatorFunction.apply(attributesMap, plans);
+                })
+                .collect(ImmutableList.toImmutableList());
+    }
+}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPropertiesMap.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPropertiesMap.java
new file mode 100644
index 0000000000..7af64dbd8e
--- /dev/null
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionPropertiesMap.java
@@ -0,0 +1,231 @@
+/*
+ * ExpressionPropertiesMap.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.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
+import com.google.common.base.Verify;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.SetMultimap;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Class to manage properties for expressions of some type {@code E} that extends {@link RelationalExpression}.
+ * A properties map is part of an expression reference ({@link Reference}).
+ * <br>
+ * Properties for expressions managed by this map are computed lazily when a caller attempts to retrieve the value of a
+ * property. The reason for that is twofold. First, we want to avoid unnecessary computation of a property if it is not
+ * retrieved at a later point in time. Second, the basic planner
+ * {@link com.apple.foundationdb.record.query.plan.RecordQueryPlanner} uses a simplified way of creating a dag of
+ * {@link RecordQueryPlan}s that lacks some fundamental information (e.g. no type system) that some properties
+ * computations depend on meaning that these properties cannot be computed if the plan was created by
+ * {@link com.apple.foundationdb.record.query.plan.RecordQueryPlanner}.
+ * In order to still allow that planner to create the same structures as the {@link CascadesPlanner} we need these
+ * property computations to be lazy as {@link com.apple.foundationdb.record.query.plan.RecordQueryPlanner} never
+ * accesses the properties.
+ * @param <E> type parameter to capture the kind of expression property map
+ */
+public class ExpressionPropertiesMap<E extends RelationalExpression> {
+    /**
+     * Class object to do runtime type checks against as this is not Scala.
+     */
+    @Nonnull
+    private final Class<E> expressionClass;
+
+    /**
+     * This set works a bit like an enumeration; it defines the domain of {@link ExpressionProperty}s that are being
+     * maintained by the properties map.
+     */
+    private final Set<ExpressionProperty<?>> trackedExpressionProperties;
+
+    /**
+     * A queue with expressions whose properties have not been computed yet.
+     */
+    @Nonnull
+    private final Deque<E> toBeInsertedExpressions;
+
+    /**
+     * Map from each expression to its associated collection of computed property values.
+     */
+    @Nonnull
+    private final Map<E, Map<ExpressionProperty<?>, ?>> propertiesMap;
+
+    /**
+     * {@link SetMultimap} from a map of computed properties to {@code E}s.
+     */
+    @Nonnull
+    private final SetMultimap<Map<ExpressionProperty<?>, ?>, E> propertyGroupedExpressionsMap;
+
+    public ExpressionPropertiesMap(@Nonnull final Class<E> expressionClass,
+                                   @Nonnull final Set<ExpressionProperty<?>> trackedExpressionProperties,
+                                   @Nonnull final Collection<? extends RelationalExpression> expressions) {
+        this.expressionClass = expressionClass;
+        this.trackedExpressionProperties = ImmutableSet.copyOf(trackedExpressionProperties);
+        this.toBeInsertedExpressions = new ArrayDeque<>();
+        this.propertiesMap = new LinkedIdentityMap<>();
+        this.propertyGroupedExpressionsMap = Multimaps.newSetMultimap(Maps.newLinkedHashMap(), LinkedIdentitySet::new);
+        expressions.forEach(this::add);
+    }
+
+    @Nonnull
+    private E narrow(@Nonnull final RelationalExpression expression) {
+        Verify.verify(expressionClass.isInstance(expression),
+                "unable to cast property value to its declared type");
+        return expressionClass.cast(expression);
+    }
+
+    @Nonnull
+    protected SetMultimap<Map<ExpressionProperty<?>, ?>, E> getPropertyGroupedExpressionsMap() {
+        return propertyGroupedExpressionsMap;
+    }
+
+    /**
+     * Method to compute the properties of the plans residing in the queue of to-be-inserted plans. Plans and their
+     * computed properties are then used to update the internal structures. Every retrieve operation to this class
+     * must call this method to ensure that the internals of this object are up-to-date.
+     */
+    protected void update() {
+        while (!toBeInsertedExpressions.isEmpty()) {
+            final var expression = toBeInsertedExpressions.pop();
+            final var attributeMapBuilder = ImmutableMap.<ExpressionProperty<?>, Object>builder();
+            for (final var expressionProperty : trackedExpressionProperties) {
+                attributeMapBuilder.put(expressionProperty, computePropertyValue(expressionProperty, expression));
+            }
+            final var propertiesForPlanMap = attributeMapBuilder.build();
+            add(expression, propertiesForPlanMap);
+        }
+    }
+
+    /**
+     * Returns the properties currently stored in the properties map for the given expression. Note that
+     * {@link #update()} is called prior to retrieving the properties.
+     * @param expression the expression
+     * @return a map of properties for the given expression, or {@code null} if the expression passed in is
+     *         not stored in the properties map.
+     */
+    @Nullable
+    public Map<ExpressionProperty<?>, ?> getProperties(@Nonnull final RelationalExpression expression) {
+        update();
+        return getCurrentProperties(expression);
+    }
+
+    /**
+     * Returns the properties currently stored in the properties map for the given expression. Note that
+     * {@link #update()} is not called prior to retrieving the properties.
+     * @param expression the expression
+     * @return a map of properties for the given expression, or {@code null} if the expression passed in is
+     *         either not stored in the properties map or not yet stored in the map (it may be in the queue but is
+     *         not yet processed).
+     */
+    @Nullable
+    public Map<ExpressionProperty<?>, ?> getCurrentProperties(@Nonnull final RelationalExpression expression) {
+        return propertiesMap.get(narrow(expression));
+    }
+
+    /**
+     * Method to add a new {@link RelationalExpression} to this properties map. The plan is added to a queue that is
+     * consumed upon read to lazily compute the properties of the plan passed in.
+     * @param expression new expression to be added
+     */
+    public void add(@Nonnull final RelationalExpression expression) {
+        toBeInsertedExpressions.add(narrow(expression));
+    }
+
+    /**
+     * Method to add a new {@link RecordQueryPlan} to this properties map using precomputed properties. That is
+     * useful when the caller retrieved the plan from some other reference.
+     * @param expression new record query plan to be added
+     * @param propertiesForExpressionMap a map containing all managed properties for the expression passed in
+     */
+    public void add(@Nonnull final RelationalExpression expression, @Nonnull final Map<ExpressionProperty<?>, ?> propertiesForExpressionMap) {
+        final E typedExpression = narrow(expression);
+        Verify.verify(!propertiesMap.containsKey(typedExpression));
+        propertiesMap.put(typedExpression, propertiesForExpressionMap);
+        propertyGroupedExpressionsMap.put(propertiesForExpressionMap, typedExpression);
+    }
+
+    @Nonnull
+    private <P> P computePropertyValue(@Nonnull final ExpressionProperty<P> expressionProperty,
+                                       @Nonnull final RelationalExpression expression) {
+        final var propertyVisitor = expressionProperty.createVisitor();
+        return propertyVisitor.visit(expression);
+    }
+
+    public void clear() {
+        toBeInsertedExpressions.clear();
+        propertiesMap.clear();
+        propertyGroupedExpressionsMap.clear();
+    }
+
+    /**
+     * Returns a map from expression to a computed specific property value for a {@link ExpressionProperty}
+     * passed in.
+     * @param <P> the type parameter of the {@link  ExpressionProperty}
+     * @param expressionProperty the property the caller is interested in
+     * @return a new map that holds a key/value for each plan that is currently being managed by this property map
+     *         to its {@link ExpressionProperty}'s value
+     */
+    @Nonnull
+    public <P> Map<E, P> propertyValueForExpressions(@Nonnull final ExpressionProperty<P> expressionProperty) {
+        update();
+        final var resultMap = new LinkedIdentityMap<E, P>();
+        for (final var entry : propertiesMap.entrySet()) {
+            resultMap.put(entry.getKey(), expressionProperty.narrowAttribute(entry.getValue().get(expressionProperty)));
+        }
+
+        return resultMap;
+    }
+
+    @Nonnull
+    public List<ExpressionPartition<E>> toExpressionPartitions() {
+        update();
+        return ExpressionPartitions.toPartitions(Multimaps.asMap(propertyGroupedExpressionsMap));
+    }
+
+    /**
+     * Returns a map from expression to a computed specific property value for a {@link ExpressionProperty}
+     * passed in.
+     * @param <P> the type parameter of the {@link  ExpressionProperty}
+     * @param expressionProperty the property the caller is interested in
+     * @return a new map that holds a key/value for each plan that is currently being managed by this property map
+     *         to its {@link ExpressionProperty}'s value
+     */
+    @Nonnull
+    public <P> Map<RecordQueryPlan, P> propertyValueForPlans(@Nonnull final ExpressionProperty<P> expressionProperty) {
+        throw new UnsupportedOperationException("method cannot provide plans");
+    }
+
+    @Nonnull
+    public List<PlanPartition> toPlanPartitions() {
+        throw new UnsupportedOperationException("method cannot provide plan partitions");
+    }
+}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionProperty.java
index 3576c6f840..0e42e0d190 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/ExpressionProperty.java
@@ -3,7 +3,7 @@
  *
  * This source file is part of the FoundationDB open source project
  *
- * Copyright 2015-2018 Apple Inc. and the FoundationDB project authors
+ * 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.
@@ -20,158 +20,72 @@
 
 package com.apple.foundationdb.record.query.plan.cascades;
 
-import com.apple.foundationdb.annotation.API;
-import com.apple.foundationdb.annotation.SpotBugsSuppressWarnings;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitor;
-import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
-import com.google.common.collect.Lists;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
+import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
+import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlanVisitor;
 
 import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.List;
-import java.util.Objects;
 
 /**
- * An interface for certain Cascades-style properties, which are measurable features of an expression other than the
- * structure of the expression tree. In particular, a {@code ExpressionProperty} is a property that depends on (much of)
- * the contents of the subtree rooted at the expression on which it is evaluated, rather than just a finite depth set
- * of paths as a {@link BindingMatcher} would. For example,
- * the sort order and set of record types produced by a
- * {@link RelationalExpression} could be a
- * {@code ExpressionProperty}.
- *
- * <p>
- * To avoid littering {@link RelationalExpression} classes with methods for various properties, properties are implemented
- * using a variant of the hierarchical visitor pattern over a DAG of {@link RelationalExpression}s, {@link Quantifier}s,
- * and {@link Reference}s.
- * A property can be evaluated against an expression tree by having the visitor traverse a DAG of heterogeneous objects
- * where expressions are said to own quantifiers which range over expression references which then contain expressions
- * again. Shared subgraphs are visited multiple times. If desired, the caller must ensure that a subgraph is not
- * visited more than once.
- * </p>
- *
- * <p>
- * Note that the methods {@link #evaluateAtExpression}, {@link #evaluateAtQuantifier}, and {@link #evaluateAtRef} are handed the
- * results of the visitor evaluated at their owned quantifiers, references, and members respectively. Since most properties
- * are easy to describe as a recursion with depth one, this makes properties easier to read and write.
- * </p>
- *
- * <p>
- * Note that the default implementations provided in this interface walk the entire DAG, i.e. all {@link #shouldVisit}
- * methods return {@code true}. That implies that properties have been computed for sub-structures of the graph when
- * {@code evaluateAtXXX()} is called and therefore are not {@code null}. That means that all such arguments can be
- * assumed to be non-nullable even though parameters are annotated as {@link Nullable}. On the other hand, if the
- * implementor also overrides {@code shouldVisit} to return {@code false}, arguments to {@code evaluateAtXXX} may become
- * nullable or contain {@code null}s if they are collections and should be dealt with gracefully.
- * </p>
- *
- * @param <T> the result type of the property
+ * Base interface to capture properties for expressions.
+ * An instance of this usually class serves as a key in maps much like an enum, but provides strong typing.
+ * In particular, the following holds true for all properties:
+ * <ul>
+ *     <li>
+ *         Properties are singletons (or multitons; enumerated singletons) of implementors of this class.
+ *     </li>
+ *     <li>
+ *         Properties create a {@link RelationalExpressionVisitor} using the method {@link #createVisitor()}}. That
+ *         means that properties use visitors that operate on all kinds of relational expressions (from a Java typing
+ *         standpoint). In reality, as some properties are meaningless for some expressions but not others, the visitor
+ *         may decide to throw an exception for a class it cannot process.
+ *         There are some helpers that can transform e.g. a {@link RecordQueryPlanVisitor} into a
+ *         {@link RelationalExpressionVisitor} which add functionality to throw an exception when a non-plan is visited.
+ *         This does not weaken the usual contracts that these visitor classes have. It just allows for e.g.
+ *         {@link RecordQueryPlanVisitor}s to be used in place of {@link RelationalExpressionVisitor}s.
+ *     </li>
+ *     <li>
+ *         Properties are not dependent on parameters but are computed by only traversing the
+ *         {@link RelationalExpression} DAG. The method {@link #createVisitor()} does not use any parameters.
+ *     </li>
+ *     <li>
+ *         Properties may or may not be used in an {@link ExpressionPropertiesMap}. If the property is maintained in
+ *         such a map for a given reference, the implementor of the visitor may assume that the property values for
+ *         children expressions are also maintained in such a map and therefore accessible though the individual
+ *         child's {@link Reference}. In this way, expensive re-computation of the property value can be avoided.
+ *     </li>
+ * </ul>
+ * @param <P> the type representing the actual property
  */
-@API(API.Status.EXPERIMENTAL)
-public interface ExpressionProperty<T> extends RelationalExpressionVisitor<T> {
-    /**
-     * Return whether the property should visit the subgraph rooted at the given expression.
-     * Called on nodes in the expression graph in visit pre-order of the depth-first traversal of the graph.
-     * That is, as each node is visited for the first time, {@code shouldVisit()} is called on that node.
-     * If {@code shouldVisit()} returns {@code false}, then {@link #evaluateAtExpression(RelationalExpression, List)} will
-     * not be called on the given expression.
-     * @param expression the planner expression to visit
-     * @return {@code true} if the children of {@code expression} should be visited and {@code false} if they should not be visited
-     */
-    @SuppressWarnings("unused")
-    default boolean shouldVisit(@Nonnull RelationalExpression expression) {
-        return true;
-    }
-
-    /**
-     * Return whether the property should visit the given reference and, transitively, the members of the reference.
-     * Called on expression references in the graph in visit pre-order of the depth-first traversal of the graph.
-     * That is, as a reference is visited, {@code shouldVisit()} is called on that reference.
-     * If {@code shouldVisit()} returns {@code false}, then {@link #evaluateAtRef(Reference, List)} will
-     * not be called on the given reference.
-     * @param ref the expression reference to visit
-     * @return {@code true} if the members of {@code ref} should be visited and {@code false} if they should not be visited
-     */
-    @SuppressWarnings("unused")
-    default boolean shouldVisit(@Nonnull Reference ref) {
-        return true;
-    }
-
-    /**
-     * Return whether the property should visit the given quantifier and the references that the quantifier
-     * ranges over.
-     * Called on quantifiers in the graph in visit pre-order of the depth-first traversal of the graph.
-     * That is, as a quantifier is visited, {@code shouldVisit()} is called on that quantifier.
-     * If {@code shouldVisit()} returns {@code false}, then {@link #evaluateAtQuantifier(Quantifier, Object)} will
-     * not be called on the given quantifier.
-     * @param quantifier the quantifier to visit
-     * @return {@code true} if the expression reference {@code quantifier} ranges over should be visited and
-     *         {@code false} if it should not be visited
-     */
-    @SuppressWarnings("unused")
-    default boolean shouldVisit(@Nonnull Quantifier quantifier) {
-        return true;
-    }
-
-    /**
-     * Evaluate the property at the given expression, using the results of evaluating the property at its children.
-     * Called on nodes in the graph in visit post-order of the depth-first traversal of the graph.
-     * That is, as each expression is visited (after all of its children have been visited, if applicable),
-     * {@code evaluateAtExpression()} is called on that expression.
-     * @param expression the cursor to visit
-     * @param childResults the results of the property evaluated at the children of {@code expression}
-     * @return the value of property at the given expression
-     */
-    @Nonnull
-    T evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<T> childResults);
-
+public interface ExpressionProperty<P> {
     /**
-     * Evaluate the property at the given reference, using the results of evaluating the property at its members.
-     * Called on nodes in the graph in visit post-order of the depth-first traversal of the graph.
-     * That is, as each reference is visited (after all of its members have been visited, if applicable),
-     * {@code evaluateAtRef()} is called on that reference.
-     * @param ref the expression reference to visit
-     * @param memberResults the results of the property evaluated at the members of {@code ref}
-     * @return the value of property at the given reference
+     * Method to narrow the type from {@link Object} to the declared type of the attribute. Note that
+     * the caller must guarantee that the narrowing is well-defined and successful.
+     * @param object an object that actually is of dynamic type {@code P}
+     * @return the narrowed object of type {@code P}
      */
     @Nonnull
-    T evaluateAtRef(@Nonnull Reference ref, @Nonnull List<T> memberResults);
-
-    /**
-     * Evaluate the property at the given quantifier, using the result of evaluating the property at the
-     * reference the quantifier ranges over.
-     * Called on quantifiers in the graph in visit post-order of the depth-first traversal of the graph.
-     * That is, as each quantifier is visited (after the expression reference it ranges over has been visited, if applicable),
-     * {@code evaluateAtQuantifier()} is called on that quantifier.
-     * @param quantifier the quantifier to visit
-     * @param rangesOverResult the result of the property evaluated at the {@link Reference} {@code quantifier}
-     *        ranges over
-     * @return the value of property at the given quantifier
-     */
-    @Nonnull
-    @SuppressWarnings("unused")
-    @SpotBugsSuppressWarnings("NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE")
-    default T evaluateAtQuantifier(@Nonnull final Quantifier quantifier, @Nullable final T rangesOverResult) {
-        // since we visit the expression reference under the quantifier, we can insist that rangesOverResult is never null
-        return Objects.requireNonNull(rangesOverResult);
+    @SuppressWarnings("unchecked")
+    default P narrowAttribute(@Nonnull final Object object) {
+        return (P)object;
     }
 
     @Nonnull
-    @Override
-    default T visitDefault(@Nonnull final RelationalExpression relationalExpression) {
-        final var quantifierResults = visitQuantifiers(relationalExpression);
-        return evaluateAtExpression(relationalExpression, quantifierResults);
-    }
+    RelationalExpressionVisitor<P> createVisitor();
 
     @Nonnull
-    default List<T> visitQuantifiers(@Nonnull final RelationalExpression relationalExpression) {
-        final List<? extends Quantifier> quantifiers = relationalExpression.getQuantifiers();
-        final var quantifierResults = Lists.<T>newArrayListWithCapacity(quantifiers.size());
-        for (final Quantifier quantifier : quantifiers) {
-            quantifierResults.add(quantifier.acceptPropertyVisitor(this));
-        }
-
-        return quantifierResults;
+    static <T> RelationalExpressionVisitor<T> toExpressionVisitor(@Nonnull final RecordQueryPlanVisitor<T> planVisitor) {
+        return new RelationalExpressionVisitorWithDefaults<>() {
+            @Nonnull
+            @Override
+            public T visitDefault(@Nonnull final RelationalExpression element) {
+                if (element instanceof RecordQueryPlan) {
+                    return planVisitor.visit((RecordQueryPlan)element);
+                }
+                throw new UnsupportedOperationException("plan visitor does not support visitor interface for ordinary expressions");
+            }
+        };
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/FindExpressionProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/FindExpressionVisitor.java
similarity index 85%
rename from fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/FindExpressionProperty.java
rename to fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/FindExpressionVisitor.java
index ab37c6f08e..4e217fcd2e 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/FindExpressionProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/FindExpressionVisitor.java
@@ -1,9 +1,9 @@
 /*
- * FindExpressionProperty.java
+ * FindExpressionVisitor.java
  *
  * This source file is part of the FoundationDB open source project
  *
- * Copyright 2015-2019 Apple Inc. and the FoundationDB project authors
+ * 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.
@@ -18,13 +18,9 @@
  * limitations under the License.
  */
 
-package com.apple.foundationdb.record.query.plan.cascades.properties;
+package com.apple.foundationdb.record.query.plan.cascades;
 
-import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
-import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.LinkedIdentitySet;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -39,12 +35,12 @@
 import java.util.Set;
 
 /**
- * A property that determines finds all occurrences of expressions of interest in a planner graph.
+ * A visitor that finds all occurrences of expressions of interest in a planner graph.
  */
-public class FindExpressionProperty implements ExpressionProperty<Map<Class<? extends RelationalExpression>, Set<RelationalExpression>>>, RelationalExpressionVisitorWithDefaults<Map<Class<? extends RelationalExpression>, Set<RelationalExpression>>> {
+public class FindExpressionVisitor implements SimpleExpressionVisitor<Map<Class<? extends RelationalExpression>, Set<RelationalExpression>>> {
     private final Set<Class<? extends RelationalExpression>> expressionClasses;
 
-    public FindExpressionProperty(@Nonnull final Set<Class<? extends RelationalExpression>> expressionClasses) {
+    public FindExpressionVisitor(@Nonnull final Set<Class<? extends RelationalExpression>> expressionClasses) {
         this.expressionClasses =
                 ImmutableSet.copyOf(expressionClasses);
     }
@@ -100,7 +96,7 @@ public static Set<? extends RelationalExpression> findExpressions(@Nonnull final
     }
 
     public static Set<? extends RelationalExpression> findExpressions(@Nonnull final Set<Class<? extends RelationalExpression>> expressionClasses, @Nonnull final RelationalExpression expression) {
-        final Map<Class<? extends RelationalExpression>, Set<RelationalExpression>> expressionClassToExpressionsMap = new FindExpressionProperty(expressionClasses).visit(expression);
+        final Map<Class<? extends RelationalExpression>, Set<RelationalExpression>> expressionClassToExpressionsMap = new FindExpressionVisitor(expressionClasses).visit(expression);
         if (expressionClassToExpressionsMap == null) {
             return LinkedIdentitySet.of();
         }
@@ -136,7 +132,8 @@ public static int countExpressions(@Nonnull final Set<Class<? extends Relational
     @Nonnull
     public static Map<Class<? extends RelationalExpression>, Set<RelationalExpression>> evaluate(@Nonnull Set<Class<? extends RelationalExpression>> expressionClasses, @Nonnull RelationalExpression expression) {
         @Nullable final Map<Class<? extends RelationalExpression>, Set<RelationalExpression>> nullableResult =
-                expression.acceptPropertyVisitor(new FindExpressionProperty(expressionClasses));
+                expression.acceptVisitor(new FindExpressionVisitor(expressionClasses));
         return nullableResult == null ? ImmutableMap.of() : nullableResult;
     }
 }
+
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/MetaDataPlanContext.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/MetaDataPlanContext.java
index 3b04816d5d..6cbd34e6d6 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/MetaDataPlanContext.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/MetaDataPlanContext.java
@@ -29,7 +29,6 @@
 import com.apple.foundationdb.record.query.IndexQueryabilityFilter;
 import com.apple.foundationdb.record.query.RecordQuery;
 import com.apple.foundationdb.record.query.plan.RecordQueryPlannerConfiguration;
-import com.apple.foundationdb.record.query.plan.cascades.properties.RecordTypesProperty;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 
@@ -43,6 +42,8 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.RecordTypesProperty.recordTypes;
+
 /**
  * A {@link PlanContext} where the underlying meta-data comes from {@link RecordMetaData} and {@link RecordStoreState}
  * objects, as is generally the case when planning actual queries.
@@ -170,7 +171,7 @@ public static PlanContext forRootReference(@Nonnull final RecordQueryPlannerConf
                                                @Nonnull final Reference rootReference,
                                                @Nonnull final Optional<Collection<String>> allowedIndexesOptional,
                                                @Nonnull final IndexQueryabilityFilter indexQueryabilityFilter) {
-        final var queriedRecordTypeNames = RecordTypesProperty.evaluate(rootReference);
+        final var queriedRecordTypeNames = recordTypes().evaluate(rootReference);
 
         if (queriedRecordTypeNames.isEmpty()) {
             return new MetaDataPlanContext(plannerConfiguration, ImmutableSet.of());
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPartition.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPartition.java
index 9264624da0..69deac673e 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPartition.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPartition.java
@@ -21,83 +21,23 @@
 package com.apple.foundationdb.record.query.plan.cascades;
 
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
 
 import javax.annotation.Nonnull;
 import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 /**
  * A plan partition used for matching.
  */
-public class PlanPartition {
-    private final Map<PlanProperty<?>, ?> attributesMap;
-    private final Set<RecordQueryPlan> plans;
-
-    public PlanPartition(final Map<PlanProperty<?>, ?> attributesMap, final Collection<RecordQueryPlan> plans) {
-        this.attributesMap = ImmutableMap.copyOf(attributesMap);
-        this.plans = new LinkedIdentitySet<>(plans);
-    }
-
-    public Map<PlanProperty<?>, ?> getAttributesMap() {
-        return attributesMap;
-    }
-
-    public <A> A getAttributeValue(@Nonnull final PlanProperty<A> planProperty) {
-        return planProperty.narrowAttribute(Objects.requireNonNull(attributesMap.get(planProperty)));
-    }
-
-    public Set<RecordQueryPlan> getPlans() {
-        return plans;
+public class PlanPartition extends ExpressionPartition<RecordQueryPlan> {
+    public PlanPartition(@Nonnull final Map<ExpressionProperty<?>, ?> propertyValuesMap,
+                         @Nonnull final Collection<RecordQueryPlan> plans) {
+        super(propertyValuesMap, plans);
     }
 
     @Nonnull
-    public static List<PlanPartition> rollUpTo(@Nonnull Collection<PlanPartition> planPartitions, @Nonnull final PlanProperty<?> rollupAttributes) {
-        return rollUpTo(planPartitions, ImmutableSet.of(rollupAttributes));
-    }
-
-    @Nonnull
-    public static List<PlanPartition> rollUpTo(@Nonnull Collection<PlanPartition> planPartitions, @Nonnull final Set<PlanProperty<?>> rollupAttributes) {
-        final Map<Map<PlanProperty<?>, ?>, ? extends Set<RecordQueryPlan>> rolledUpAttributesMap =
-                planPartitions
-                        .stream()
-                        .map(planPartition -> {
-                            final var attributesMap = planPartition.getAttributesMap();
-                            final Map<PlanProperty<?>, ?> filteredAttributesMap =
-                                    attributesMap
-                                            .entrySet()
-                                            .stream()
-                                            .filter(attributeEntry -> rollupAttributes.contains(attributeEntry.getKey()))
-                                            .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
-
-                            // create a new partition that uses only the rollup attributes
-                            return new PlanPartition(filteredAttributesMap, planPartition.getPlans());
-                        })
-                        // group by the filtered attributes rolling up to form new sets of plans
-                        .collect(Collectors.groupingBy(PlanPartition::getAttributesMap,
-                                LinkedHashMap::new,
-                                Collectors.flatMapping(planPartition -> planPartition.getPlans().stream(), LinkedIdentitySet.toLinkedIdentitySet())));
-
-        return toPlanPartitions(rolledUpAttributesMap);
-    }
-
-    @Nonnull
-    public static List<PlanPartition> toPlanPartitions(@Nonnull Map<Map<PlanProperty<?>, ?>, ? extends Set<RecordQueryPlan>> attributesToPlansMap) {
-        return attributesToPlansMap
-                .entrySet()
-                .stream()
-                .map(entry -> {
-                    final var attributesMap = entry.getKey();
-                    final var plans = entry.getValue();
-                    return new PlanPartition(attributesMap, plans);
-                })
-                .collect(ImmutableList.toImmutableList());
+    public Set<RecordQueryPlan> getPlans() {
+        return getExpressions();
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPartitions.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPartitions.java
new file mode 100644
index 0000000000..61c39fd89b
--- /dev/null
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPartitions.java
@@ -0,0 +1,55 @@
+/*
+ * PlanPartitions.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.plans.RecordQueryPlan;
+import com.google.common.collect.ImmutableSet;
+
+import javax.annotation.Nonnull;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Plan partition helpers.
+ */
+public class PlanPartitions {
+
+    private PlanPartitions() {
+        // do not instantiate
+    }
+
+    @Nonnull
+    public static List<PlanPartition> rollUpTo(@Nonnull Collection<PlanPartition> planPartitions, @Nonnull final ExpressionProperty<?> rollupAttributes) {
+        return rollUpTo(planPartitions, ImmutableSet.of(rollupAttributes));
+    }
+
+    @Nonnull
+    public static List<PlanPartition> rollUpTo(@Nonnull Collection<PlanPartition> planPartitions, @Nonnull final Set<ExpressionProperty<?>> rollupAttributes) {
+        return ExpressionPartitions.rollUpTo(planPartitions, rollupAttributes, PlanPartition::new);
+    }
+
+    @Nonnull
+    public static List<PlanPartition> toPartitions(@Nonnull Map<Map<ExpressionProperty<?>, ?>, ? extends Set<RecordQueryPlan>> attributesToPlansMap) {
+        return ExpressionPartitions.toPartitions(attributesToPlansMap, PlanPartition::new);
+    }
+}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPropertiesMap.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPropertiesMap.java
new file mode 100644
index 0000000000..0856717590
--- /dev/null
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanPropertiesMap.java
@@ -0,0 +1,79 @@
+/*
+ * PlanPropertiesMap.java
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2015-2022 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.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.OrderingProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.PrimaryKeyProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
+import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.Sets;
+
+import javax.annotation.Nonnull;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * An {@link ExpressionPropertiesMap} for properties that only apply to {@link RecordQueryPlan}s.
+ * @see ExpressionPropertiesMap
+ */
+public class PlanPropertiesMap extends ExpressionPropertiesMap<RecordQueryPlan> {
+    /**
+     * This set works a bit like an enumeration; it defines the domain of {@link ExpressionProperty}s that are being maintained
+     * by the properties map.
+     */
+    private static final Set<ExpressionProperty<?>> expressionProperties =
+            ImmutableSet.<ExpressionProperty<?>>builder()
+                    .add(OrderingProperty.ordering())
+                    .add(DistinctRecordsProperty.distinctRecords())
+                    .add(StoredRecordProperty.storedRecord())
+                    .add(PrimaryKeyProperty.primaryKey())
+                    .build();
+
+    public PlanPropertiesMap(@Nonnull Collection<? extends RelationalExpression> plans) {
+        super(RecordQueryPlan.class, expressionProperties, plans);
+    }
+
+    @Nonnull
+    @Override
+    public <P> Map<RecordQueryPlan, P> propertyValueForPlans(@Nonnull final ExpressionProperty<P> expressionProperty) {
+        return propertyValueForExpressions(expressionProperty);
+    }
+
+    @Nonnull
+    @Override
+    public List<PlanPartition> toPlanPartitions() {
+        update();
+        return PlanPartitions.toPartitions(Multimaps.asMap(getPropertyGroupedExpressionsMap()));
+    }
+
+    @Nonnull
+    public static Set<ExpressionProperty<?>> allAttributesExcept(@Nonnull final ExpressionProperty<?>... exceptAttributes) {
+        final var exceptAttributesSet = ImmutableSet.copyOf(Arrays.asList(exceptAttributes));
+        return ImmutableSet.copyOf(Sets.difference(expressionProperties, exceptAttributesSet));
+    }
+}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanProperty.java
deleted file mode 100644
index 48d83dd99d..0000000000
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanProperty.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * PlanProperty.java
- *
- * This source file is part of the FoundationDB open source project
- *
- * Copyright 2015-2021 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.plans.RecordQueryPlanVisitor;
-
-import javax.annotation.Nonnull;
-
-/**
- * Base interface to capture attributes for plans.
- * An instance of this usually class serves as a key in maps much like an enum, but provides strong typing.
- * @param <A> the type representing the actual property
- */
-public interface PlanProperty<A> {
-    /**
-     * Method to narrow the type from {@link Object} to the declared type of the attribute. Note that
-     * the caller must guarantee that the narrowing is well-defined and successful.
-     * @param object an object that actually is of dynamic type {@code A}
-     * @return the narrowed object of type {@code A}
-     */
-    @Nonnull
-    @SuppressWarnings("unchecked")
-    default A narrowAttribute(@Nonnull final Object object) {
-        return (A)object;
-    }
-
-    @Nonnull
-    RecordQueryPlanVisitor<A> createVisitor();
-}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlannerRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlannerRule.java
index 3a327c448c..ca368a5133 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlannerRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlannerRule.java
@@ -41,7 +41,7 @@ public interface PlannerRule<R, C extends PlannerRuleCall<R>, T> {
      * Returns the class of the operator at the root of the binding expression, if this rule uses a non-trivial binding.
      * Used primarily for indexing rules for more efficient rule search.
      * @return the class of the root of this rule's binding, or <code>Optional.empty()</code> if the rule matches anything
-     * @see PlannerRuleSet
+     * @see PlanningRuleSet
      */
     @Nonnull
     Optional<Class<?>> getRootOperator();
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlannerRuleSet.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanningRuleSet.java
similarity index 98%
rename from fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlannerRuleSet.java
rename to fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanningRuleSet.java
index ab5a5ee58a..f79f78ac58 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlannerRuleSet.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PlanningRuleSet.java
@@ -1,5 +1,5 @@
 /*
- * PlannerRuleSet.java
+ * PlanningRuleSet.java
  *
  * This source file is part of the FoundationDB open source project
  *
@@ -109,7 +109,7 @@
  */
 @API(API.Status.EXPERIMENTAL)
 @SuppressWarnings("java:S1452")
-public class PlannerRuleSet {
+public class PlanningRuleSet {
     private static final List<CascadesRule<? extends RelationalExpression>> NORMALIZATION_RULES = ImmutableList.of(
             new NormalizePredicatesRule()
     );
@@ -205,7 +205,7 @@ public class PlannerRuleSet {
                     .addAll(IMPLEMENTATION_RULES)
                     .build();
 
-    public static final PlannerRuleSet DEFAULT = new PlannerRuleSet(ALL_EXPRESSION_RULES);
+    public static final PlanningRuleSet DEFAULT = new PlanningRuleSet(ALL_EXPRESSION_RULES);
 
     @Nonnull
     private final Multimap<Class<?>, CascadesRule<? extends RelationalExpression>> ruleIndex;
@@ -215,7 +215,7 @@ public class PlannerRuleSet {
 
     @VisibleForTesting
     @SpotBugsSuppressWarnings("NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE")
-    PlannerRuleSet(@Nonnull List<CascadesRule<? extends RelationalExpression>> rules) {
+    PlanningRuleSet(@Nonnull List<CascadesRule<? extends RelationalExpression>> rules) {
         this.ruleIndex =
                 MultimapBuilder
                         .hashKeys()
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PropertiesMap.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PropertiesMap.java
deleted file mode 100644
index 7484603817..0000000000
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/PropertiesMap.java
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- * PropertiesMap.java
- *
- * This source file is part of the FoundationDB open source project
- *
- * Copyright 2015-2022 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.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.OrderingProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.PrimaryKeyProperty;
-import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
-import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
-import com.google.common.base.Verify;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.SetMultimap;
-import com.google.common.collect.Sets;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.ArrayDeque;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Deque;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Class to manage properties for plans. A properties map is part of an expression reference ({@link Reference}).
- * <br>
- * Properties for plans managed by this map are computed lazily when a caller attempts to retrieve the value of a property.
- * The reason for that is twofold. First, we want to avoid unnecessary computation of a property if it is not retrieved
- * at a later point in time. Second, the basic planner {@link RecordQueryPlan} uses a simplified way of creating a dag of
- * {@link RecordQueryPlan}s that lacks some fundamental information (e.g. no type system) that some properties computations
- * depend on meaning that these properties cannot be computed if the plan was created by {@link RecordQueryPlan}.
- * In order to still allow that planner to create the same structures as the {@link CascadesPlanner} we need these property
- * computations to be lazy as {@link RecordQueryPlan} never accesses the properties afterwards.
- */
-public class PropertiesMap {
-    /**
-     * This set works a bit like an enumeration; it defines the domain of {@link PlanProperty}s that are being maintained
-     * by the properties map.
-     */
-    private static final Set<PlanProperty<?>> planProperties =
-            ImmutableSet.<PlanProperty<?>>builder()
-                    .add(OrderingProperty.ORDERING)
-                    .add(DistinctRecordsProperty.DISTINCT_RECORDS)
-                    .add(StoredRecordProperty.STORED_RECORD)
-                    .add(PrimaryKeyProperty.PRIMARY_KEY)
-                    .build();
-
-    /**
-     * A queue with plans whose properties have not been computed yet.
-     */
-    @Nonnull
-    private final Deque<RecordQueryPlan> toBeInsertedPlans;
-
-    /**
-     * Map from {@link RecordQueryPlan} to a map of {@link PlanProperty} to a computed property value.
-     */
-    @Nonnull
-    private final Map<RecordQueryPlan, Map<PlanProperty<?>, ?>> planPropertiesMap;
-
-    /**
-     * {@link SetMultimap} from a map of computed properties to a set of {@link RecordQueryPlan}.
-     */
-    @Nonnull
-    private final SetMultimap<Map<PlanProperty<?>, ?>, RecordQueryPlan> attributeGroupedPlansMap;
-
-    public PropertiesMap(@Nonnull Collection<? extends RelationalExpression> relationalExpressions) {
-        this.toBeInsertedPlans = new ArrayDeque<>();
-        this.planPropertiesMap = new LinkedIdentityMap<>();
-        this.attributeGroupedPlansMap = Multimaps.newSetMultimap(Maps.newLinkedHashMap(), LinkedIdentitySet::new);
-        relationalExpressions
-                .stream()
-                .filter(relationalExpression -> relationalExpression instanceof RecordQueryPlan)
-                .map(relationalExpression -> (RecordQueryPlan)relationalExpression)
-                .forEach(this::add);
-    }
-
-    /**
-     * Method to compute the properties of the plans residing in the queue of to-be-inserted plans. Plans and their
-     * computed properties are then used to update the internal structures. Every retrieve operation to this class
-     * must call this method to ensure that the internals of this object are up-to-date.
-     */
-    private void update() {
-        while (!toBeInsertedPlans.isEmpty()) {
-            final var recordQueryPlan = toBeInsertedPlans.pop();
-            final var attributeMapBuilder = ImmutableMap.<PlanProperty<?>, Object>builder();
-            for (final var planProperty : planProperties) {
-                attributeMapBuilder.put(planProperty, computePropertyValue(planProperty, recordQueryPlan));
-            }
-            final var propertiesForPlanMap = attributeMapBuilder.build();
-            add(recordQueryPlan, propertiesForPlanMap);
-        }
-    }
-
-    /**
-     * Returns the properties currently stored in the properties map for the given plan. Note that
-     * {@link #update()} is not called prior to retrieving the properties.
-     * @param recordQueryPlan the plan
-     * @return a map of properties for the given plan, or {@code null} if the {@link  RecordQueryPlan} passed in is
-     *         either stored in the properties map.
-     */
-    @Nullable
-    public Map<PlanProperty<?>, ?> getPropertiesForPlan(@Nonnull final RecordQueryPlan recordQueryPlan) {
-        update();
-        return getCurrentPropertiesForPlan(recordQueryPlan);
-    }
-
-    /**
-     * Returns the properties currently stored in the properties map for the given plan. Note that
-     * {@link #update()} is not called prior to retrieving the properties.
-     * @param recordQueryPlan the plan
-     * @return a map of properties for the given plan, or {@code null} if the {@link  RecordQueryPlan} passed in is
-     *         either not stored in the properties map or not yet stored in the map (it may be in the queue but is
-     *         not yet processed).
-     */
-    @Nullable
-    public Map<PlanProperty<?>, ?> getCurrentPropertiesForPlan(@Nonnull final RecordQueryPlan recordQueryPlan) {
-        return planPropertiesMap.get(recordQueryPlan);
-    }
-
-    /**
-     * Method to add a new {@link RecordQueryPlan} to this properties map. The plan is added to a queue that is
-     * consumed upon read to lazily compute the properties of the plan passed in.
-     * @param recordQueryPlan new record query plan to be added
-     */
-    public void add(@Nonnull final RecordQueryPlan recordQueryPlan) {
-        toBeInsertedPlans.add(recordQueryPlan);
-    }
-
-    /**
-     * Method to add a new {@link RecordQueryPlan} to this properties map using precomputed properties. That is
-     * useful when the caller retrieved the plan from some other reference.
-     * @param recordQueryPlan new record query plan to be added
-     * @param propertiesForPlanMap a map containing all managed properties for the {@link RecordQueryPlan} passed in
-     */
-    public void add(@Nonnull final RecordQueryPlan recordQueryPlan, @Nonnull final Map<PlanProperty<?>, ?> propertiesForPlanMap) {
-        Verify.verify(!planPropertiesMap.containsKey(recordQueryPlan));
-        planPropertiesMap.put(recordQueryPlan, propertiesForPlanMap);
-        attributeGroupedPlansMap.put(propertiesForPlanMap, recordQueryPlan);
-    }
-
-    @Nonnull
-    private <P> P computePropertyValue(@Nonnull final PlanProperty<P> planProperty,
-                                       @Nonnull final RecordQueryPlan recordQueryPlan) {
-        final var propertyVisitor = planProperty.createVisitor();
-        return propertyVisitor.visit(recordQueryPlan);
-    }
-
-    public void clear() {
-        toBeInsertedPlans.clear();
-        planPropertiesMap.clear();
-        attributeGroupedPlansMap.clear();
-    }
-
-    /**
-     * Returns a map from {@link RecordQueryPlan} to a computed specific property value for a {@link PlanProperty}
-     * passed in.
-     * @param <P> the type parameter of the {@link  PlanProperty}
-     * @param planProperty the property the caller is interested in
-     * @return a new map that holds a key/value for each plan that is currently being managed by this property map
-     *         to its {@link PlanProperty}'s value
-     */
-    @Nonnull
-    public <P> Map<RecordQueryPlan, P> getPlannerAttributeForAllPlans(@Nonnull final PlanProperty<P> planProperty) {
-        update();
-        final var resultMap = new LinkedIdentityMap<RecordQueryPlan, P>();
-        for (final var entry : planPropertiesMap.entrySet()) {
-            resultMap.put(entry.getKey(), planProperty.narrowAttribute(entry.getValue().get(planProperty)));
-        }
-
-        return resultMap;
-    }
-
-    @SuppressWarnings("UnstableApiUsage")
-    @Nonnull
-    public List<PlanPartition> getPlanPartitions() {
-        update();
-        return PlanPartition.toPlanPartitions(Multimaps.asMap(attributeGroupedPlansMap));
-    }
-
-    @Nonnull
-    public static Set<PlanProperty<?>> allAttributesExcept(final PlanProperty<?>... exceptAttributes) {
-        final var exceptAttributesSet = ImmutableSet.copyOf(Arrays.asList(exceptAttributes));
-        return ImmutableSet.copyOf(Sets.difference(planProperties, exceptAttributesSet));
-    }
-}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Quantifier.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Quantifier.java
index 56fe5333f6..14c6183404 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Quantifier.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Quantifier.java
@@ -615,14 +615,14 @@ public CorrelationIdentifier getAlias() {
 
     /**
      * Allow the computation of {@link ExpressionProperty}s across the quantifiers in the data flow graph.
-     * @param visitor the planner property that is being computed
-     * @param <U> the type of the property being computed
+     * @param visitor the visitor that is being accepted
+     * @param <U> the type the visitor computes
      * @return the property
      */
     @Nullable
-    public <U> U acceptPropertyVisitor(@Nonnull ExpressionProperty<U> visitor) {
+    public <U> U acceptVisitor(@Nonnull SimpleExpressionVisitor<U> visitor) {
         if (visitor.shouldVisit(this)) {
-            return visitor.evaluateAtQuantifier(this, getRangesOver().acceptPropertyVisitor(visitor));
+            return visitor.evaluateAtQuantifier(this, getRangesOver().acceptVisitor(visitor));
         }
         return null;
     }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Reference.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Reference.java
index acdf45f796..cb34fd3a3e 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Reference.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/Reference.java
@@ -23,7 +23,7 @@
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.RecordCoreException;
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger;
-import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionWithChildren;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
@@ -77,17 +77,20 @@ public class Reference implements Correlated<Reference>, Typed {
     private final ConstraintsMap constraintsMap;
 
     @Nonnull
-    private final PropertiesMap propertiesMap;
+    private final ExpressionPropertiesMap<? extends RelationalExpression> propertiesMap;
 
     private Reference() {
         this(new LinkedIdentitySet<>());
     }
 
-    private Reference(@Nonnull LinkedIdentitySet<RelationalExpression> members) {
+    private Reference(@Nonnull final LinkedIdentitySet<RelationalExpression> members) {
         this.members = members;
         this.partialMatchMap = LinkedHashMultimap.create();
         this.constraintsMap = new ConstraintsMap();
-        this.propertiesMap = new PropertiesMap(members);
+        // TODO create based on the (yet) non-existing planner stage
+        this.propertiesMap = new PlanPropertiesMap(members.stream()
+                .filter(m -> m instanceof RecordQueryPlan)
+                .collect(Collectors.toList()));
         // Call debugger hook for this new reference.
         Debugger.registerReference(this);
     }
@@ -136,9 +139,9 @@ public synchronized void replace(@Nonnull RelationalExpression newValue) {
      * @param newValue new value to replace existing members
      */
     public void pruneWith(@Nonnull RelationalExpression newValue) {
-        final Map<PlanProperty<?>, ?> propertiesForPlan;
+        final Map<ExpressionProperty<?>, ?> propertiesForPlan;
         if (newValue instanceof RecordQueryPlan) {
-            propertiesForPlan = propertiesMap.getCurrentPropertiesForPlan((RecordQueryPlan)newValue);
+            propertiesForPlan = propertiesMap.getCurrentProperties(newValue);
         } else {
             propertiesForPlan = null;
         }
@@ -157,7 +160,7 @@ public void pruneWith(@Nonnull RelationalExpression newValue) {
     public boolean insertFrom(@Nonnull final RelationalExpression newValue, @Nonnull final Reference otherRef) {
         if (newValue instanceof RecordQueryPlan) {
             final var propertiesForPlan =
-                    Objects.requireNonNull(otherRef.propertiesMap.getPropertiesForPlan((RecordQueryPlan)newValue));
+                    Objects.requireNonNull(otherRef.propertiesMap.getProperties(newValue));
 
             return insert(newValue, propertiesForPlan);
         }
@@ -184,7 +187,7 @@ public boolean insert(@Nonnull final RelationalExpression newValue) {
      * @return {@code true} if and only if the new expression was successfully inserted into this reference, {@code false}
      *         otherwise.
      */
-    private boolean insert(@Nonnull final RelationalExpression newValue, @Nullable final Map<PlanProperty<?>, ?> precomputedPropertiesMap) {
+    private boolean insert(@Nonnull final RelationalExpression newValue, @Nullable final Map<ExpressionProperty<?>, ?> precomputedPropertiesMap) {
         Debugger.withDebugger(debugger -> debugger.onEvent(Debugger.InsertIntoMemoEvent.begin()));
         try {
             final boolean containsInMemo = containsInMemo(newValue);
@@ -225,7 +228,7 @@ public void insertUnchecked(@Nonnull final RelationalExpression newValue) {
      * @param precomputedPropertiesMap if not {@code null}, a map of precomputed properties for a {@link RecordQueryPlan}
      *        that will be inserted into this reference verbatim, otherwise it will be computed
      */
-    public void insertUnchecked(@Nonnull final RelationalExpression newValue, @Nullable final Map<PlanProperty<?>, ?> precomputedPropertiesMap) {
+    public void insertUnchecked(@Nonnull final RelationalExpression newValue, @Nullable final Map<ExpressionProperty<?>, ?> precomputedPropertiesMap) {
         // Call debugger hook to potentially register this new expression.
         Debugger.registerExpression(newValue);
 
@@ -385,27 +388,27 @@ public Reference referenceFromMembers(@Nonnull Collection<? extends RelationalEx
     }
 
     @Nonnull
-    public <A> Map<RecordQueryPlan, A> getPlannerAttributeForMembers(@Nonnull final PlanProperty<A> planProperty) {
-        return propertiesMap.getPlannerAttributeForAllPlans(planProperty);
+    public <A> Map<RecordQueryPlan, A> getProperty(@Nonnull final ExpressionProperty<A> expressionProperty) {
+        return propertiesMap.propertyValueForPlans(expressionProperty);
     }
 
     @Nonnull
-    public List<PlanPartition> getPlanPartitions() {
-        return propertiesMap.getPlanPartitions();
+    public List<PlanPartition> toPlanPartitions() {
+        return propertiesMap.toPlanPartitions();
     }
 
     @Nullable
-    public <U> U acceptPropertyVisitor(@Nonnull ExpressionProperty<U> property) {
-        if (property.shouldVisit(this)) {
+    public <U> U acceptVisitor(@Nonnull SimpleExpressionVisitor<U> simpleExpressionVisitor) {
+        if (simpleExpressionVisitor.shouldVisit(this)) {
             final List<U> memberResults = new ArrayList<>(members.size());
             for (RelationalExpression member : members) {
-                final U result = property.shouldVisit(member) ? property.visit(member) : null;
+                final U result = simpleExpressionVisitor.shouldVisit(member) ? simpleExpressionVisitor.visit(member) : null;
                 if (result == null) {
                     return null;
                 }
                 memberResults.add(result);
             }
-            return property.evaluateAtRef(this, memberResults);
+            return simpleExpressionVisitor.evaluateAtRef(this, memberResults);
         }
         return null;
     }
@@ -522,7 +525,7 @@ public boolean addPartialMatchForCandidate(final MatchCandidate candidate, final
      */
     @Nonnull
     public String show(final boolean renderSingleGroups) {
-        return PlannerGraphProperty.show(renderSingleGroups, this);
+        return PlannerGraphVisitor.show(renderSingleGroups, this);
     }
 
     public static boolean isMemoizedExpression(@Nonnull final RelationalExpression expression,
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/References.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/References.java
index acf6d3553c..1979d2ee86 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/References.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/References.java
@@ -25,7 +25,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionWithChildren;
-import com.apple.foundationdb.record.query.plan.cascades.properties.ReferencesAndDependenciesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableList;
@@ -36,6 +35,8 @@
 import java.util.Objects;
 import java.util.Set;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.ReferencesAndDependenciesProperty.referencesAndDependencies;
+
 /**
  * Utility methods for {@link Reference}s.
  */
@@ -51,7 +52,7 @@ public static List<? extends Reference> translateCorrelations(@Nonnull final Lis
             return ImmutableList.of();
         }
 
-        final var partialOrder = ReferencesAndDependenciesProperty.evaluate(refs);
+        final var partialOrder = referencesAndDependencies().evaluate(refs);
 
         final var references =
                 TopologicalSort.anyTopologicalOrderPermutation(partialOrder)
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/SimpleExpressionVisitor.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/SimpleExpressionVisitor.java
new file mode 100644
index 0000000000..6ef74d2157
--- /dev/null
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/SimpleExpressionVisitor.java
@@ -0,0 +1,169 @@
+/*
+ * SimpleExpressionVisitor.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.annotation.API;
+import com.apple.foundationdb.annotation.SpotBugsSuppressWarnings;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
+import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
+import com.google.common.collect.Lists;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * An interface for implementors to compute some Cascades-style properties as well as other arbitrary results based on
+ * an expression dag. In particular, a {@code SimpleExpressionVisitor} computes a property that depends on (much of) the
+ * contents of the subtree rooted at the expression on which it is evaluated, rather than just a finite depth set of
+ * paths as a {@link BindingMatcher} would.
+ * <br>
+ * To avoid littering {@link RelationalExpression} classes with methods for various interesting properties, we instead
+ * compute those properties using a variant of the hierarchical visitor pattern over a DAG of
+ * {@link RelationalExpression}s, {@link Quantifier}s, and {@link Reference}s.
+ * <br>
+ * A property can be computed against an expression tree by having the visitor traverse a DAG of heterogeneous objects
+ * where expressions are said to own quantifiers which range over expression references which then contain expressions
+ * again. Shared sub-graphs are visited multiple times. If desired, the caller must ensure that a subgraph is not
+ * visited more than once.
+ * <br>
+ * Note that the methods {@link #evaluateAtExpression}, {@link #evaluateAtQuantifier}, and {@link #evaluateAtRef} are
+ * handed the results of the visitor evaluated at their owned quantifiers, references, and members respectively.
+ * <br>
+ * Note that the default implementations provided in this interface walk the entire DAG, i.e. all {@link #shouldVisit}
+ * methods return {@code true}. That implies that properties have been computed for sub-structures of the graph when
+ * {@code evaluateAtXXX()} is called and therefore are not {@code null}. That means that all such arguments can be
+ * assumed to be non-nullable even though parameters are annotated as {@link Nullable}. On the other hand, if the
+ * implementor also overrides {@code shouldVisit} to return {@code false}, arguments to {@code evaluateAtXXX} may become
+ * nullable or contain {@code null}s if they are collections and should be dealt with gracefully.
+ *
+ * @param <T> the result type of the result that is computed by this visitor
+ */
+@API(API.Status.EXPERIMENTAL)
+public interface SimpleExpressionVisitor<T> extends RelationalExpressionVisitorWithDefaults<T> {
+    /**
+     * Return whether the visitor should visit the subgraph rooted at the given expression.
+     * Called on nodes in the expression graph in visit pre-order of the depth-first traversal of the graph.
+     * That is, as each node is visited for the first time, {@code shouldVisit()} is called on that node.
+     * If {@code shouldVisit()} returns {@code false}, then {@link #evaluateAtExpression(RelationalExpression, List)}
+     * will not be called on the given expression.
+     * @param expression the planner expression to visit
+     * @return {@code true} if the children of {@code expression} should be visited and {@code false} if they should not
+     *         be visited
+     */
+    @SuppressWarnings("unused")
+    default boolean shouldVisit(@Nonnull RelationalExpression expression) {
+        return true;
+    }
+
+    /**
+     * Return whether the visitor should visit the given reference and, transitively, the members of the reference.
+     * Called on expression references in the graph in visit pre-order of the depth-first traversal of the graph.
+     * That is, as a reference is visited, {@code shouldVisit()} is called on that reference.
+     * If {@code shouldVisit()} returns {@code false}, then {@link #evaluateAtRef(Reference, List)} will
+     * not be called on the given reference.
+     * @param ref the expression reference to visit
+     * @return {@code true} if the members of {@code ref} should be visited and {@code false} if they should not be
+     *         visited
+     */
+    @SuppressWarnings("unused")
+    default boolean shouldVisit(@Nonnull Reference ref) {
+        return true;
+    }
+
+    /**
+     * Return whether the visitor should visit the given quantifier and the references that the quantifier
+     * ranges over.
+     * Called on quantifiers in the graph in visit pre-order of the depth-first traversal of the graph.
+     * That is, as a quantifier is visited, {@code shouldVisit()} is called on that quantifier.
+     * If {@code shouldVisit()} returns {@code false}, then {@link #evaluateAtQuantifier(Quantifier, Object)} will
+     * not be called on the given quantifier.
+     * @param quantifier the quantifier to visit
+     * @return {@code true} if the expression reference {@code quantifier} ranges over should be visited and
+     *         {@code false} if it should not be visited
+     */
+    @SuppressWarnings("unused")
+    default boolean shouldVisit(@Nonnull Quantifier quantifier) {
+        return true;
+    }
+
+    /**
+     * Visits the given expression to evaluate a result, using the results of visiting its children.
+     * Called on nodes in the graph in visit post-order of the depth-first traversal of the graph.
+     * That is, as each expression is visited (after all of its children have been visited, if applicable),
+     * {@code evaluateAtExpression()} is called on that expression.
+     * @param expression the cursor to visit
+     * @param childResults the results for the children of {@code expression}
+     * @return the evaluated result the given expression
+     */
+    @Nonnull
+    T evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<T> childResults);
+
+    /**
+     * Visits the given reference to evaluate a result, using the results of visiting its members.
+     * Called on nodes in the graph in visit post-order of the depth-first traversal of the graph.
+     * That is, as each reference is visited (after all of its members have been visited, if applicable),
+     * {@code evaluateAtRef()} is called on that reference.
+     * @param ref the expression reference to visit
+     * @param memberResults the results of the property evaluated at the members of {@code ref}
+     * @return the evaluated result at the given reference
+     */
+    @Nonnull
+    T evaluateAtRef(@Nonnull Reference ref, @Nonnull List<T> memberResults);
+
+    /**
+     * Visits the given quantifier, using the result of visiting the reference the quantifier ranges
+     * over. Called on quantifiers in the graph in visit post-order of the depth-first traversal of the graph.
+     * That is, as each quantifier is visited (after the expression reference it ranges over has been visited,
+     * if applicable), {@code evaluateAtQuantifier()} is called on that quantifier.
+     * @param quantifier the quantifier to visit
+     * @param rangesOverResult the result evaluated at the {@link Reference} {@code quantifier}
+     *        ranges over
+     * @return the evaluated result at the given quantifier
+     */
+    @Nonnull
+    @SuppressWarnings("unused")
+    @SpotBugsSuppressWarnings("NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE")
+    default T evaluateAtQuantifier(@Nonnull final Quantifier quantifier, @Nullable T rangesOverResult) {
+        // since we visit the expression reference under the quantifier, we can insist that rangesOverResult is never
+        // null
+        return Objects.requireNonNull(rangesOverResult);
+    }
+
+    @Nonnull
+    @Override
+    default T visitDefault(@Nonnull final RelationalExpression relationalExpression) {
+        final var quantifierResults = visitQuantifiers(relationalExpression);
+        return evaluateAtExpression(relationalExpression, quantifierResults);
+    }
+
+    @Nonnull
+    default List<T> visitQuantifiers(@Nonnull final RelationalExpression relationalExpression) {
+        final List<? extends Quantifier> quantifiers = relationalExpression.getQuantifiers();
+        final var quantifierResults = Lists.<T>newArrayListWithCapacity(quantifiers.size());
+        for (final Quantifier quantifier : quantifiers) {
+            quantifierResults.add(quantifier.acceptVisitor(this));
+        }
+        return quantifierResults;
+    }
+}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/AbstractPlannerGraph.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/AbstractPlannerGraph.java
index e442e3ad1e..9f62dbbdbc 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/AbstractPlannerGraph.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/AbstractPlannerGraph.java
@@ -42,7 +42,7 @@
 import java.util.function.Supplier;
 
 /**
- * The planner graph class. Objects of this class are computed by {@link PlannerGraphProperty},
+ * The planner graph class. Objects of this class are produced by {@link PlannerGraphVisitor},
  * i.e., they get computed by walking a {@link RelationalExpression} DAG.
  *
  * Once computed, the property is immutable.
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/explain/ExplainPlanVisitor.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/ExplainPlanVisitor.java
similarity index 96%
rename from fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/explain/ExplainPlanVisitor.java
rename to fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/ExplainPlanVisitor.java
index d2ec7c1066..0edb72c532 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/explain/ExplainPlanVisitor.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/ExplainPlanVisitor.java
@@ -18,7 +18,7 @@
  * limitations under the License.
  */
 
-package com.apple.foundationdb.record.query.plan.explain;
+package com.apple.foundationdb.record.query.plan.cascades.explain;
 
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.Bindings;
@@ -28,6 +28,14 @@
 import com.apple.foundationdb.record.query.plan.TextScan;
 import com.apple.foundationdb.record.query.plan.bitmap.ComposedBitmapIndexQueryPlan;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
+import com.apple.foundationdb.record.query.plan.explain.DefaultExplainFormatter;
+import com.apple.foundationdb.record.query.plan.explain.DefaultExplainSymbolMap;
+import com.apple.foundationdb.record.query.plan.explain.ExplainFormatter;
+import com.apple.foundationdb.record.query.plan.explain.ExplainLevel;
+import com.apple.foundationdb.record.query.plan.explain.ExplainSelfContainedSymbolMap;
+import com.apple.foundationdb.record.query.plan.explain.ExplainSymbolMap;
+import com.apple.foundationdb.record.query.plan.explain.ExplainTokens;
+import com.apple.foundationdb.record.query.plan.explain.PrettyExplainFormatter;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryAggregateIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryComparatorPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryCoveringIndexPlan;
@@ -142,6 +150,7 @@ public class ExplainPlanVisitor extends ExplainTokens implements RecordQueryPlan
 
     public ExplainPlanVisitor(final int maxSize) {
         this.maxSize = maxSize;
+        this.done = false;
     }
 
     /**
@@ -398,8 +407,8 @@ public ExplainTokens visitRecursiveUnionPlan(@Nonnull final RecordQueryRecursive
                 .addSequence(() -> new ExplainTokens().addCommaAndWhiteSpace(),
                         new ExplainTokens().addAliasDefinition(recursiveUnionPlan.getTempTableScanAlias()),
                         new ExplainTokens().addAliasDefinition(recursiveUnionPlan.getTempTableInsertAlias())
-                .addWhitespace().addOpeningBrace().addLinebreakOrWhitespace()
-                .addKeyword("INITIAL").addWhitespace().addOpeningBrace().addLinebreakOrWhitespace());
+                                .addWhitespace().addOpeningBrace().addLinebreakOrWhitespace()
+                                .addKeyword("INITIAL").addWhitespace().addOpeningBrace().addLinebreakOrWhitespace());
         visit(recursiveUnionPlan.getChildren().get(0)).addWhitespace().addClosingBrace().addLinebreakOrWhitespace();
         addKeyword("RECURSIVE").addWhitespace().addWhitespace().addOpeningBrace().addLinebreakOrWhitespace();
         return visit(recursiveUnionPlan.getChildren().get(1)).addWhitespace().addClosingBrace()
@@ -684,11 +693,6 @@ public static ExplainTokens indexDetails(@Nonnull final RecordQueryIndexPlan ind
         return resultExplainTokens;
     }
 
-    @Nonnull
-    public static String prettyExplain(@Nonnull final RecordQueryPlan plan) {
-        return prettyExplain(plan, ExplainLevel.ALL_DETAILS);
-    }
-
     @Nonnull
     public static String prettyExplain(@Nonnull final RecordQueryPlan plan, final int explainLevel) {
         final var visitor = new ExplainPlanVisitor(Integer.MAX_VALUE);
@@ -709,7 +713,7 @@ public static String toStringForDebugging(@Nonnull final RecordQueryPlan plan, f
         final var visitor = new ExplainPlanVisitor(maxSize);
         final var explainTokens = visitor.visit(plan);
         return explainTokens.render(explainLevel,
-                        new DefaultExplainFormatter(DefaultExplainSymbolMap::new), maxSize).toString();
+                new DefaultExplainFormatter(DefaultExplainSymbolMap::new), maxSize).toString();
     }
 
     @Nonnull
@@ -739,4 +743,9 @@ public static String toStringForExternalExplain(@Nonnull final RecordQueryPlan p
         return explainTokens.render(level, new DefaultExplainFormatter(ExplainSelfContainedSymbolMap::new), maxSize)
                 .toString();
     }
+
+    @Nonnull
+    public static String prettyExplain(@Nonnull final RecordQueryPlan plan) {
+        return ExplainPlanVisitor.prettyExplain(plan, ExplainLevel.ALL_DETAILS);
+    }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/ExplainPlannerGraphRewritable.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/ExplainPlannerGraphRewritable.java
index c7e2975366..4685c01520 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/ExplainPlannerGraphRewritable.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/ExplainPlannerGraphRewritable.java
@@ -28,9 +28,9 @@
 /**
  * Interface to allow {@link RelationalExpression}s to rewrite their own
  * explain graph representation.
- *
+ * <br>
  * This particular class allows {@link RelationalExpression}s to specify
- * how a {@link PlannerGraph} is modified when we compute the {@link PlannerGraphProperty} when explaining a plan
+ * how a {@link PlannerGraph} is modified when we use the {@link PlannerGraphVisitor} when explaining a plan
  * to an end-user.
  */
 public interface ExplainPlannerGraphRewritable {
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/InternalPlannerGraphRewritable.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/InternalPlannerGraphRewritable.java
index 3a24e3b440..3ebb334c4a 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/InternalPlannerGraphRewritable.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/InternalPlannerGraphRewritable.java
@@ -28,9 +28,9 @@
 /**
  * Interface to allow {@link RelationalExpression}s to rewrite their own
  * internal graph representation. Please see {@link PlannerGraphRewritable} for a more comprehensive explanation.
- *
+ * <br>
  * This particular class allows {@link RelationalExpression}s to specify
- * how a {@link PlannerGraph} is modified when we compute the {@link PlannerGraphProperty} for developers working
+ * how a {@link PlannerGraph} is modified when we use the {@link PlannerGraphVisitor} for developers working
  * on the query planner.
  * @see PlannerGraphRewritable for a more comprehensive explanation of graph rewriting.
  */
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphRewritable.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphRewritable.java
index f216382318..2cefbcbca0 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphRewritable.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphRewritable.java
@@ -31,7 +31,7 @@
  *
  * This interface allows a {@link RelationalExpression} to create/modify
  * low level planner graph structures while a planner graph is created through an expression walk in
- * {@link PlannerGraphProperty}. Such a rewrite can be useful if the standard representation is confusing, misleading,
+ * {@link PlannerGraphVisitor}. Such a rewrite can be useful if the standard representation is confusing, misleading,
  * or just too complicated. For instance, {@link com.apple.foundationdb.record.query.plan.plans.RecordQueryPlanWithIndex}
  * additionally creates a separate node underneath the actual plan operator to show the index as a record producer.
  * The nature of the rewrite is highly operator-specific, therefore, the rewrite is not part of the visitor or some
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphVisitor.java
similarity index 95%
rename from fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphProperty.java
rename to fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphVisitor.java
index 7f522cba77..94ae491cb4 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/explain/PlannerGraphVisitor.java
@@ -1,9 +1,9 @@
 /*
- * PlannerGraphProperty.java
+ * PlannerGraphVisitor.java
  *
  * This source file is part of the FoundationDB open source project
  *
- * Copyright 2015-2020 Apple Inc. and the FoundationDB project authors
+ * 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.
@@ -20,11 +20,11 @@
 
 package com.apple.foundationdb.record.query.plan.cascades.explain;
 
-import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
-import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.Traversal;
 import com.apple.foundationdb.record.query.plan.cascades.MatchCandidate;
 import com.apple.foundationdb.record.query.plan.cascades.PartialMatch;
+import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
+import com.apple.foundationdb.record.query.plan.cascades.Traversal;
 import com.apple.foundationdb.record.query.plan.cascades.debug.BrowserHelper;
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger;
 import com.apple.foundationdb.record.query.plan.cascades.explain.GraphExporter.Cluster;
@@ -33,7 +33,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph.Node;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph.PartialMatchEdge;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Throwables;
@@ -64,7 +63,7 @@
  * Class to hold a graph for explain, optimization, and rewrite purposes.
  */
 @SuppressWarnings({"UnstableApiUsage"})
-public class PlannerGraphProperty implements ExpressionProperty<PlannerGraph>, RelationalExpressionVisitorWithDefaults<PlannerGraph> {
+public class PlannerGraphVisitor implements SimpleExpressionVisitor<PlannerGraph> {
 
     public static final int EMPTY_FLAGS                = 0x0000;
 
@@ -140,7 +139,7 @@ public static String show(final boolean renderSingleGroups, @Nonnull final Refer
     @Nonnull
     public static String show(final int flags, @Nonnull final RelationalExpression relationalExpression) {
         final PlannerGraph plannerGraph =
-                Objects.requireNonNull(relationalExpression.acceptPropertyVisitor(new PlannerGraphProperty(flags)));
+                Objects.requireNonNull(relationalExpression.acceptVisitor(new PlannerGraphVisitor(flags)));
         final String dotString = exportToDot(plannerGraph);
         return show(dotString);
     }
@@ -155,7 +154,7 @@ public static String show(final int flags, @Nonnull final RelationalExpression r
     @Nonnull
     public static String show(final int flags, @Nonnull final Reference rootReference) {
         final PlannerGraph plannerGraph =
-                Objects.requireNonNull(rootReference.acceptPropertyVisitor(new PlannerGraphProperty(flags)));
+                Objects.requireNonNull(rootReference.acceptVisitor(new PlannerGraphVisitor(flags)));
         final String dotString = exportToDot(plannerGraph);
         return show(dotString);
     }
@@ -173,13 +172,13 @@ public static String show(final boolean renderSingleGroups,
                               @Nonnull final Reference queryPlanRootReference,
                               @Nonnull final Set<MatchCandidate> matchCandidates) {
         final PlannerGraph queryPlannerGraph =
-                Objects.requireNonNull(queryPlanRootReference.acceptPropertyVisitor(forInternalShow(renderSingleGroups, true)));
+                Objects.requireNonNull(queryPlanRootReference.acceptVisitor(forInternalShow(renderSingleGroups, true)));
 
         final PlannerGraph.InternalPlannerGraphBuilder graphBuilder = queryPlannerGraph.derived();
 
         final Map<MatchCandidate, PlannerGraph> matchCandidateMap = matchCandidates.stream()
                 .collect(ImmutableMap.toImmutableMap(Function.identity(), matchCandidate -> Objects.requireNonNull(
-                        matchCandidate.getTraversal().getRootReference().acceptPropertyVisitor(forInternalShow(renderSingleGroups)))));
+                        matchCandidate.getTraversal().getRootReference().acceptVisitor(forInternalShow(renderSingleGroups)))));
 
         matchCandidateMap.forEach((matchCandidate, matchCandidateGraph) -> graphBuilder.addGraph(matchCandidateGraph));
 
@@ -262,7 +261,7 @@ public static String exportToDot(@Nonnull final AbstractPlannerGraph<Node, Edge>
                 (network, nodes) -> {
                     final ImmutableList.Builder<Cluster<Node, Edge>> clusterBuilder = ImmutableList.builder();
                     clusterBuilder.addAll(clustersForGroups(plannerGraph.getNetwork(), queryPlannerNodes));
-                    clusterBuilder.addAll(clusteringFunction.apply(PlannerGraphProperty::clustersForGroups));
+                    clusterBuilder.addAll(clusteringFunction.apply(PlannerGraphVisitor::clustersForGroups));
                     return clusterBuilder.build();
                 });
         // export as string
@@ -354,7 +353,7 @@ public static String explain(@Nonnull final RelationalExpression relationalExpre
                                  @Nonnull final Map<String, Attribute> additionalDescriptionMap) {
         try {
             final PlannerGraph plannerGraph =
-                    Objects.requireNonNull(relationalExpression.acceptPropertyVisitor(forExplain()));
+                    Objects.requireNonNull(relationalExpression.acceptVisitor(forExplain()));
             return exportToGml(plannerGraph, additionalDescriptionMap);
         } catch (final Exception ex) {
             Throwables.throwIfUnchecked(ex);
@@ -403,16 +402,16 @@ private static GraphExporter<Node, Edge> createGmlExporter(@Nonnull final Map<St
                 ImmutableMap.of("infos", Attribute.gml(infoMap)));
     }
 
-    public static PlannerGraphProperty forExplain() {
-        return new PlannerGraphProperty(FOR_EXPLAIN);
+    public static PlannerGraphVisitor forExplain() {
+        return new PlannerGraphVisitor(FOR_EXPLAIN);
     }
 
-    public static PlannerGraphProperty forInternalShow(final boolean renderSingleGroups) {
+    public static PlannerGraphVisitor forInternalShow(final boolean renderSingleGroups) {
         return forInternalShow(renderSingleGroups, false);
     }
 
-    public static PlannerGraphProperty forInternalShow(final boolean renderSingleGroups, final boolean removePlans) {
-        return new PlannerGraphProperty((renderSingleGroups ? RENDER_SINGLE_GROUPS : 0) |
+    public static PlannerGraphVisitor forInternalShow(final boolean renderSingleGroups, final boolean removePlans) {
+        return new PlannerGraphVisitor((renderSingleGroups ? RENDER_SINGLE_GROUPS : 0) |
                                         (removePlans ? REMOVE_PLANS : 0));
     }
 
@@ -424,7 +423,7 @@ public static PlannerGraphProperty forInternalShow(final boolean renderSingleGro
      *
      * @param flags for options
      */
-    private PlannerGraphProperty(final int flags) {
+    private PlannerGraphVisitor(final int flags) {
         Preconditions.checkArgument(validateFlags(flags));
         this.flags = flags;
     }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/expressions/RelationalExpression.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/expressions/RelationalExpression.java
index b99fbed728..24abaf294b 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/expressions/RelationalExpression.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/expressions/RelationalExpression.java
@@ -46,8 +46,9 @@
 import com.apple.foundationdb.record.query.plan.cascades.Quantifiers;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.ScalarTranslationVisitor;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.ValueEquivalence;
-import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.matching.graph.BoundMatch;
 import com.apple.foundationdb.record.query.plan.cascades.matching.graph.MatchFunction;
 import com.apple.foundationdb.record.query.plan.cascades.matching.graph.MatchPredicate;
@@ -829,16 +830,16 @@ default int semanticHashCode() {
     }
 
     /**
-     * Apply the given property visitor to this planner expression and its children. Returns {@code null} if
-     * {@link ExpressionProperty#shouldVisit(RelationalExpression)} called on this expression returns {@code false}.
-     * @param visitor a {@link ExpressionProperty} visitor to evaluate
+     * Apply the given visitor to this planner expression and its children. Returns {@code null} if
+     * {@link SimpleExpressionVisitor#shouldVisit(RelationalExpression)} called on this expression returns {@code false}.
+     * @param simpleExpressionVisitor a {@link ExpressionProperty} visitor to evaluate
      * @param <U> the type of the evaluated property
      * @return the result of evaluating the property on the subtree rooted at this expression
      */
     @Nullable
-    default <U> U acceptPropertyVisitor(@Nonnull ExpressionProperty<U> visitor) {
-        if (visitor.shouldVisit(this)) {
-            return visitor.visit(this);
+    default <U> U acceptVisitor(@Nonnull SimpleExpressionVisitor<U> simpleExpressionVisitor) {
+        if (simpleExpressionVisitor.shouldVisit(this)) {
+            return simpleExpressionVisitor.visit(this);
         }
         return null;
     }
@@ -852,6 +853,6 @@ default <U> U acceptPropertyVisitor(@Nonnull ExpressionProperty<U> visitor) {
      */
     @Nonnull
     default String show(final boolean renderSingleGroups) {
-        return PlannerGraphProperty.show(renderSingleGroups, this);
+        return PlannerGraphVisitor.show(renderSingleGroups, this);
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/matching/structure/PlanPartitionMatchers.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/matching/structure/PlanPartitionMatchers.java
new file mode 100644
index 0000000000..0e333c4562
--- /dev/null
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/matching/structure/PlanPartitionMatchers.java
@@ -0,0 +1,93 @@
+/*
+ * PlanPartitionMatchers.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.matching.structure;
+
+import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
+import com.apple.foundationdb.record.query.plan.cascades.PlanPartition;
+import com.apple.foundationdb.record.query.plan.cascades.PlanPartitions;
+import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
+import javax.annotation.Nonnull;
+import java.util.Collection;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.TypedMatcher.typed;
+
+public class PlanPartitionMatchers {
+    private PlanPartitionMatchers() {
+        // do not instantiate
+    }
+
+    @Nonnull
+    @SuppressWarnings("unchecked")
+    public static <R extends Reference> BindingMatcher<R> planPartitions(@Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream) {
+        return TypedMatcherWithExtractAndDownstream.typedWithDownstream((Class<R>)(Class<?>)Reference.class,
+                Extractor.of(Reference::toPlanPartitions, name -> "planPartitions(" + name + ")"),
+                downstream);
+    }
+
+    @Nonnull
+    @SuppressWarnings("unchecked")
+    public static BindingMatcher<Collection<PlanPartition>> filterPartition(@Nonnull final Predicate<PlanPartition> predicate,
+                                                                            @Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream) {
+        return TypedMatcherWithExtractAndDownstream.typedWithDownstream((Class<Collection<PlanPartition>>)(Class<?>)Collection.class,
+                Extractor.of(planPartitions ->
+                        planPartitions.stream()
+                                .filter(predicate)
+                                .collect(ImmutableList.toImmutableList()),
+                        name -> "filtered planPartitions(" + name + ")"),
+                downstream);
+    }
+
+    @Nonnull
+    public static BindingMatcher<Collection<PlanPartition>> rollUpPartitions(@Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream) {
+        return rollUpPartitionsTo(downstream, ImmutableSet.of());
+    }
+
+    @Nonnull
+    public static BindingMatcher<Collection<PlanPartition>> rollUpPartitionsTo(@Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream,
+                                                                               @Nonnull final ExpressionProperty<?> interestingProperty) {
+        return rollUpPartitionsTo(downstream, ImmutableSet.of(interestingProperty));
+    }
+
+    @Nonnull
+    @SuppressWarnings("unchecked")
+    public static BindingMatcher<Collection<PlanPartition>> rollUpPartitionsTo(@Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream,
+                                                                               @Nonnull final Set<ExpressionProperty<?>> interestingProperties) {
+        return TypedMatcherWithExtractAndDownstream.typedWithDownstream((Class<Collection<PlanPartition>>)(Class<?>)Collection.class,
+                Extractor.of(partitions -> PlanPartitions.rollUpTo(partitions, interestingProperties),
+                        name -> "rolled up planPartitions(" + name + ")"),
+                downstream);
+    }
+
+    @Nonnull
+    public static BindingMatcher<PlanPartition> anyPlanPartition() {
+        return typed(PlanPartition.class);
+    }
+
+    @Nonnull
+    public static BindingMatcher<PlanPartition> planPartitionWhere(@Nonnull Predicate<PlanPartition> predicate) {
+        return TypedMatcherWithPredicate.typedMatcherWithPredicate(PlanPartition.class, predicate);
+    }
+}
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/matching/structure/ReferenceMatchers.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/matching/structure/ReferenceMatchers.java
index 5bad5aee6f..0ac85f1036 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/matching/structure/ReferenceMatchers.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/matching/structure/ReferenceMatchers.java
@@ -22,17 +22,10 @@
 
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.PlanPartition;
-import com.apple.foundationdb.record.query.plan.cascades.PlanProperty;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
 
 import javax.annotation.Nonnull;
-import java.util.Collection;
-import java.util.Set;
-import java.util.function.Predicate;
 
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.MultiMatcher.all;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.TypedMatcher.typed;
@@ -73,46 +66,4 @@ public static <R extends Reference, E extends RelationalExpression> BindingMatch
                 Extractor.of(Reference::getMembers, name -> "members(" + name + ")"),
                 downstream);
     }
-
-    @Nonnull
-    @SuppressWarnings("unchecked")
-    public static <R extends Reference> BindingMatcher<R> planPartitions(@Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream) {
-        return TypedMatcherWithExtractAndDownstream.typedWithDownstream((Class<R>)(Class<?>)Reference.class,
-                Extractor.of(Reference::getPlanPartitions, name -> "planPartitions(" + name + ")"),
-                downstream);
-    }
-
-    @Nonnull
-    @SuppressWarnings("unchecked")
-    public static BindingMatcher<Collection<PlanPartition>> where(@Nonnull final Predicate<PlanPartition> predicate,
-                                                                  @Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream) {
-        return TypedMatcherWithExtractAndDownstream.typedWithDownstream((Class<Collection<PlanPartition>>)(Class<?>)Collection.class,
-                Extractor.of(planPartitions -> planPartitions.stream().filter(predicate).collect(ImmutableList.toImmutableList()), name -> "filtered planPartitions(" + name + ")"),
-                downstream);
-    }
-
-    public static BindingMatcher<Collection<PlanPartition>> rollUp(@Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream) {
-        return rollUpTo(downstream, ImmutableSet.of());
-    }
-
-    public static BindingMatcher<Collection<PlanPartition>> rollUpTo(@Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream, @Nonnull final PlanProperty<?> interestingAttribute) {
-        return rollUpTo(downstream, ImmutableSet.of(interestingAttribute));
-    }
-
-    @SuppressWarnings("unchecked")
-    public static BindingMatcher<Collection<PlanPartition>> rollUpTo(@Nonnull final BindingMatcher<? extends Iterable<? extends PlanPartition>> downstream, @Nonnull final Set<PlanProperty<?>> interestingAttributes) {
-        return TypedMatcherWithExtractAndDownstream.typedWithDownstream((Class<Collection<PlanPartition>>)(Class<?>)Collection.class,
-                Extractor.of(planPartitions -> PlanPartition.rollUpTo(planPartitions, interestingAttributes), name -> "rolled up planPartitions(" + name + ")"),
-                downstream);
-    }
-
-    @Nonnull
-    public static BindingMatcher<PlanPartition> anyPlanPartition() {
-        return typed(PlanPartition.class);
-    }
-
-    @Nonnull
-    public static BindingMatcher<PlanPartition> planPartitionWhere(@Nonnull Predicate<PlanPartition> predicate) {
-        return TypedMatcherWithPredicate.typedMatcherWithPredicate(PlanPartition.class, predicate);
-    }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/predicates/CompatibleTypeEvolutionPredicate.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/predicates/CompatibleTypeEvolutionPredicate.java
index 8896be18d1..49e9470f2d 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/predicates/CompatibleTypeEvolutionPredicate.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/predicates/CompatibleTypeEvolutionPredicate.java
@@ -37,18 +37,17 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.BooleanWithConstraint;
-import com.apple.foundationdb.record.query.plan.cascades.values.FirstOrDefaultStreamingValue;
-import com.apple.foundationdb.record.query.plan.explain.ExplainTokens;
-import com.apple.foundationdb.record.query.plan.explain.ExplainTokensWithPrecedence;
 import com.apple.foundationdb.record.query.plan.cascades.ValueEquivalence;
-import com.apple.foundationdb.record.query.plan.cascades.properties.DerivationsProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.FieldValue;
+import com.apple.foundationdb.record.query.plan.cascades.values.FirstOrDefaultStreamingValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.FirstOrDefaultValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.LeafValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.RecordConstructorValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
+import com.apple.foundationdb.record.query.plan.explain.ExplainTokens;
+import com.apple.foundationdb.record.query.plan.explain.ExplainTokensWithPrecedence;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 import com.apple.foundationdb.record.util.TrieNode;
 import com.google.auto.service.AutoService;
@@ -67,6 +66,8 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.DerivationsProperty.derivations;
+
 /**
  * A predicate to be used as part of a {@link com.apple.foundationdb.record.query.plan.QueryPlanConstraint}
  * which can determine if a given plan can be executed under the types currently defined in the schema.
@@ -363,7 +364,7 @@ public static boolean isAccessCompatibleWithCurrentType(@Nonnull final FieldAcce
 
     @Nonnull
     public static CompatibleTypeEvolutionPredicate fromPlan(@Nonnull final RecordQueryPlan plannedPlan) {
-        final var derivations = DerivationsProperty.evaluateDerivations(plannedPlan);
+        final var derivations = derivations().evaluate(plannedPlan);
         final var simplifiedLocalValues = derivations.simplifyLocalValues();
         final var fieldAccesses = CompatibleTypeEvolutionPredicate.computeFieldAccesses(simplifiedLocalValues);
         return new CompatibleTypeEvolutionPredicate(fieldAccesses);
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/CardinalitiesProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/CardinalitiesProperty.java
index 8c835f70d3..05e8db1dc1 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/CardinalitiesProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/CardinalitiesProperty.java
@@ -26,8 +26,8 @@
 import com.apple.foundationdb.record.query.plan.bitmap.ComposedBitmapIndexQueryPlan;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
-import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
+import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.ValueIndexScanMatchCandidate;
 import com.apple.foundationdb.record.query.plan.cascades.WithPrimaryKeyMatchCandidate;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.DeleteExpression;
@@ -35,9 +35,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.FullUnorderedScanExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.GroupByExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.InsertExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RecursiveUnionExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.TableFunctionExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.TempTableInsertExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalDistinctExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalFilterExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalIntersectionExpression;
@@ -48,8 +45,12 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalUniqueExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.MatchableSortExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.PrimaryScanExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RecursiveUnionExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.SelectExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.TableFunctionExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.TempTableInsertExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.TempTableScanExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.UpdateExpression;
 import com.apple.foundationdb.record.query.plan.cascades.values.LiteralValue;
@@ -75,20 +76,18 @@
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryInValuesJoinPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryInsertPlan;
-import com.apple.foundationdb.record.query.plan.plans.RecordQueryRecursiveUnionPlan;
-import com.apple.foundationdb.record.query.plan.plans.RecordQueryTableFunctionPlan;
-import com.apple.foundationdb.record.query.plan.plans.TempTableScanPlan;
-import com.apple.foundationdb.record.query.plan.plans.TempTableInsertPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIntersectionOnKeyExpressionPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIntersectionOnValuesPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryLoadByKeysPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryMapPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPredicatesFilterPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryRangePlan;
+import com.apple.foundationdb.record.query.plan.plans.RecordQueryRecursiveUnionPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryScanPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryScoreForRankPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQuerySelectorPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryStreamingAggregationPlan;
+import com.apple.foundationdb.record.query.plan.plans.RecordQueryTableFunctionPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryTextIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryTypeFilterPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryUnionOnKeyExpressionPlan;
@@ -97,6 +96,8 @@
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryUnorderedPrimaryKeyDistinctPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryUnorderedUnionPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryUpdatePlan;
+import com.apple.foundationdb.record.query.plan.plans.TempTableInsertPlan;
+import com.apple.foundationdb.record.query.plan.plans.TempTableScanPlan;
 import com.apple.foundationdb.record.query.plan.sorting.RecordQueryDamPlan;
 import com.apple.foundationdb.record.query.plan.sorting.RecordQuerySortPlan;
 import com.google.common.base.Preconditions;
@@ -106,9 +107,7 @@
 import com.google.common.collect.Lists;
 
 import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
 import java.util.List;
-import java.util.Objects;
 import java.util.OptionalLong;
 
 /**
@@ -120,732 +119,737 @@
  * constrained from the data flow graph given to the property.
  */
 public class CardinalitiesProperty implements ExpressionProperty<CardinalitiesProperty.Cardinalities> {
+    private static final CardinalitiesProperty CARDINALITIES = new CardinalitiesProperty();
 
-    private static final CardinalitiesProperty INSTANCE = new CardinalitiesProperty();
-
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryUpdatePlan(@Nonnull final RecordQueryUpdatePlan updatePlan) {
-        return fromChild(updatePlan);
+    private CardinalitiesProperty() {
+        // prevent outside instantiation
     }
 
     @Nonnull
     @Override
-    public Cardinalities visitRecordQueryPredicatesFilterPlan(@Nonnull final RecordQueryPredicatesFilterPlan predicatesFilterPlan) {
-        final var cardinalitiesFromChild = fromChild(predicatesFilterPlan);
-        return new Cardinalities(Cardinality.ofCardinality(0L), cardinalitiesFromChild.getMaxCardinality());
+    public RelationalExpressionVisitor<Cardinalities> createVisitor() {
+        return new CardinalitiesVisitor();
     }
 
-    @Nonnull
     @Override
-    public Cardinalities visitRecordQueryLoadByKeysPlan(@Nonnull final RecordQueryLoadByKeysPlan element) {
-        final var keysSource = element.getKeysSource();
-        if (keysSource.maxCardinality() == QueryPlan.UNKNOWN_MAX_CARDINALITY) {
-            return Cardinalities.unknownCardinalities;
-        }
-
-        return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(keysSource.maxCardinality()));
+    public String toString() {
+        return getClass().getSimpleName();
     }
 
     @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryInValuesJoinPlan(@Nonnull final RecordQueryInValuesJoinPlan inValuesJoinPlan) {
-        final var childCardinalities = fromChild(inValuesJoinPlan);
-        final var valuesSize = inValuesJoinPlan.getInListValues().size();
-        return  new Cardinalities(
-                Cardinality.ofCardinality(valuesSize).times(childCardinalities.getMinCardinality()),
-                Cardinality.ofCardinality(valuesSize).times(childCardinalities.getMaxCardinality()));
+    public Cardinalities evaluate(@Nonnull Reference ref) {
+        return evaluate(ref.get());
     }
 
     @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryAggregateIndexPlan(@Nonnull final RecordQueryAggregateIndexPlan aggregateIndexPlan) {
-        final var groupingValueMaybe = aggregateIndexPlan.getGroupingValueMaybe();
-        if (groupingValueMaybe.isEmpty()) {
-            return new Cardinalities(Cardinality.ofCardinality(1L), Cardinality.ofCardinality(1L));
-        }
-        final var groupingValue = groupingValueMaybe.get();
-        final var indexScanPlan = aggregateIndexPlan.getIndexPlan();
-        final var matchCandidateOptional = indexScanPlan.getMatchCandidateMaybe();
-        if (matchCandidateOptional.isEmpty()) {
-            return Cardinalities.unknownMaxCardinality();
-        }
-        final var ordering = matchCandidateOptional.get()
-                .computeOrderingFromScanComparisons(
-                        indexScanPlan.getScanComparisons(),
-                        indexScanPlan.isReverse(),
-                        false);
-        if (ordering.getEqualityBoundValues().contains(groupingValue)) {
-            return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
-        } else {
-            return Cardinalities.unknownMaxCardinality();
-        }
+    public Cardinalities evaluate(@Nonnull final RelationalExpression expression) {
+        return createVisitor().visit(expression);
     }
 
     @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryCoveringIndexPlan(@Nonnull final RecordQueryCoveringIndexPlan coveringIndexPlan) {
-        if (!(coveringIndexPlan.getIndexPlan() instanceof RecordQueryIndexPlan)) {
-            return Cardinalities.unknownMaxCardinality();
-        }
-        return visitRecordQueryIndexPlan((RecordQueryIndexPlan)coveringIndexPlan.getIndexPlan());
+    public static CardinalitiesProperty cardinalities() {
+        return CARDINALITIES;
     }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryDeletePlan(@Nonnull final RecordQueryDeletePlan deletePlan) {
-        return fromChild(deletePlan);
-    }
+    /**
+     * Visitor implementation.
+     */
+    public static class CardinalitiesVisitor implements RelationalExpressionVisitor<Cardinalities> {
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryUpdatePlan(@Nonnull final RecordQueryUpdatePlan updatePlan) {
+            return fromChild(updatePlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryMapPlan(@Nonnull final RecordQueryMapPlan mapPlan) {
-        return fromChild(mapPlan);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryPredicatesFilterPlan(@Nonnull final RecordQueryPredicatesFilterPlan predicatesFilterPlan) {
+            final var cardinalitiesFromChild = fromChild(predicatesFilterPlan);
+            return new Cardinalities(Cardinality.ofCardinality(0L), cardinalitiesFromChild.getMaxCardinality());
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryComparatorPlan(@Nonnull final RecordQueryComparatorPlan comparatorPlan) {
-        return weakenCardinalities(fromChildren(comparatorPlan));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryLoadByKeysPlan(@Nonnull final RecordQueryLoadByKeysPlan element) {
+            final var keysSource = element.getKeysSource();
+            if (keysSource.maxCardinality() == QueryPlan.UNKNOWN_MAX_CARDINALITY) {
+                return Cardinalities.unknownCardinalities;
+            }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryUnorderedDistinctPlan(@Nonnull final RecordQueryUnorderedDistinctPlan unorderedDistinctPlan) {
-        return fromChild(unorderedDistinctPlan);
-    }
+            return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(keysSource.maxCardinality()));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryIntersectionOnKeyExpressionPlan(@Nonnull final RecordQueryIntersectionOnKeyExpressionPlan intersectionOnKeyExpressionPlan) {
-        return intersectCardinalities(fromChildren(intersectionOnKeyExpressionPlan));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryInValuesJoinPlan(@Nonnull final RecordQueryInValuesJoinPlan inValuesJoinPlan) {
+            final var childCardinalities = fromChild(inValuesJoinPlan);
+            final var valuesSize = inValuesJoinPlan.getInListValues().size();
+            return new Cardinalities(
+                    Cardinality.ofCardinality(valuesSize).times(childCardinalities.getMinCardinality()),
+                    Cardinality.ofCardinality(valuesSize).times(childCardinalities.getMaxCardinality()));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQuerySelectorPlan(@Nonnull final RecordQuerySelectorPlan selectorPlan) {
-        return weakenCardinalities(fromChildren(selectorPlan));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryAggregateIndexPlan(@Nonnull final RecordQueryAggregateIndexPlan aggregateIndexPlan) {
+            final var groupingValueMaybe = aggregateIndexPlan.getGroupingValueMaybe();
+            if (groupingValueMaybe.isEmpty()) {
+                return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+            }
+            final var groupingValue = groupingValueMaybe.get();
+            final var indexScanPlan = aggregateIndexPlan.getIndexPlan();
+            final var matchCandidateOptional = indexScanPlan.getMatchCandidateMaybe();
+            if (matchCandidateOptional.isEmpty()) {
+                return Cardinalities.unknownMaxCardinality();
+            }
+            final var ordering = matchCandidateOptional.get()
+                    .computeOrderingFromScanComparisons(
+                            indexScanPlan.getScanComparisons(),
+                            indexScanPlan.isReverse(),
+                            false);
+            if (ordering.getEqualityBoundValues().contains(groupingValue)) {
+                return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+            } else {
+                return Cardinalities.unknownMaxCardinality();
+            }
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryRangePlan(@Nonnull final RecordQueryRangePlan rangePlan) {
-        final var limitValue = rangePlan.getExclusiveLimitValue();
-        if (limitValue instanceof LiteralValue) {
-            final var limit = (int)Verify.verifyNotNull(limitValue.evalWithoutStore(EvaluationContext.EMPTY));
-            return new Cardinalities(Cardinality.ofCardinality(limit), Cardinality.ofCardinality(limit));
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryCoveringIndexPlan(@Nonnull final RecordQueryCoveringIndexPlan coveringIndexPlan) {
+            if (!(coveringIndexPlan.getIndexPlan() instanceof RecordQueryIndexPlan)) {
+                return Cardinalities.unknownMaxCardinality();
+            }
+            return visitRecordQueryIndexPlan((RecordQueryIndexPlan)coveringIndexPlan.getIndexPlan());
         }
-        return Cardinalities.unknownMaxCardinality();
-    }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryExplodePlan(@Nonnull final RecordQueryExplodePlan element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryDeletePlan(@Nonnull final RecordQueryDeletePlan deletePlan) {
+            return fromChild(deletePlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryInsertPlan(@Nonnull final RecordQueryInsertPlan insertPlan) {
-        return fromChild(insertPlan);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryMapPlan(@Nonnull final RecordQueryMapPlan mapPlan) {
+            return fromChild(mapPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryTableFunctionPlan(@Nonnull final RecordQueryTableFunctionPlan element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryComparatorPlan(@Nonnull final RecordQueryComparatorPlan comparatorPlan) {
+            return weakenCardinalities(fromChildren(comparatorPlan));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitTempTableInsertPlan(@Nonnull final TempTableInsertPlan tempTableInsertPlan) {
-        return fromChild(tempTableInsertPlan);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryUnorderedDistinctPlan(@Nonnull final RecordQueryUnorderedDistinctPlan unorderedDistinctPlan) {
+            return fromChild(unorderedDistinctPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryIntersectionOnValuesPlan(@Nonnull final RecordQueryIntersectionOnValuesPlan intersectionOnValuesPlan) {
-        return weakenCardinalities(fromChildren(intersectionOnValuesPlan));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryIntersectionOnKeyExpressionPlan(@Nonnull final RecordQueryIntersectionOnKeyExpressionPlan intersectionOnKeyExpressionPlan) {
+            return intersectCardinalities(fromChildren(intersectionOnKeyExpressionPlan));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryScoreForRankPlan(@Nonnull final RecordQueryScoreForRankPlan scoreForRankPlan) {
-        return fromChild(scoreForRankPlan);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQuerySelectorPlan(@Nonnull final RecordQuerySelectorPlan selectorPlan) {
+            return weakenCardinalities(fromChildren(selectorPlan));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryIndexPlan(@Nonnull final RecordQueryIndexPlan indexPlan) {
-        final var matchCandidateOptional = indexPlan.getMatchCandidateMaybe();
-        if (matchCandidateOptional.isEmpty()) {
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryRangePlan(@Nonnull final RecordQueryRangePlan rangePlan) {
+            final var limitValue = rangePlan.getExclusiveLimitValue();
+            if (limitValue instanceof LiteralValue) {
+                final var limit = (int)Verify.verifyNotNull(limitValue.evalWithoutStore(EvaluationContext.EMPTY));
+                return new Cardinalities(Cardinality.ofCardinality(limit), Cardinality.ofCardinality(limit));
+            }
             return Cardinalities.unknownMaxCardinality();
         }
-        final var matchCandidate = matchCandidateOptional.get();
-
-        final var ordering =
-                matchCandidate.computeOrderingFromScanComparisons(indexPlan.getScanComparisons(),
-                        indexPlan.isReverse(),
-                        false);
-        final var equalityBoundValues = ordering.getEqualityBoundValues();
 
-        // try to see if the primary key is bound by equalities
-        if (matchCandidate instanceof WithPrimaryKeyMatchCandidate) {
-            final var primaryKeyValuesOptional = ((WithPrimaryKeyMatchCandidate)matchCandidate).getPrimaryKeyValuesMaybe();
-            if (primaryKeyValuesOptional.isPresent()) {
-                final var primaryKeyValues = primaryKeyValuesOptional.get();
-                if (equalityBoundValues.containsAll(primaryKeyValues)) {
-                    return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
-                }
-            }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryExplodePlan(@Nonnull final RecordQueryExplodePlan element) {
+            return Cardinalities.unknownMaxCardinality();
         }
 
-        if (matchCandidate.isUnique() && matchCandidate instanceof ValueIndexScanMatchCandidate) {
-            // unique index
-            final var valueIndexScanMatchCandidate = (ValueIndexScanMatchCandidate)matchCandidate;
-            final var translationMap = AliasMap.ofAliases(valueIndexScanMatchCandidate.getBaseAlias(), Quantifier.current());
-            final var keyValues =
-                    valueIndexScanMatchCandidate.getIndexKeyValues()
-                            .stream()
-                            .limit(matchCandidate.getColumnSize())
-                            .map(keyValue -> keyValue.rebase(translationMap))
-                            .collect(ImmutableList.toImmutableList());
-            if (equalityBoundValues.containsAll(keyValues)) {
-                return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
-            }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryInsertPlan(@Nonnull final RecordQueryInsertPlan insertPlan) {
+            return fromChild(insertPlan);
         }
 
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryTableFunctionPlan(@Nonnull final RecordQueryTableFunctionPlan element) {
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryFirstOrDefaultPlan(@Nonnull final RecordQueryFirstOrDefaultPlan element) {
-        return new Cardinalities(Cardinality.ofCardinality(1L), Cardinality.ofCardinality(1L));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitTempTableInsertPlan(@Nonnull final TempTableInsertPlan tempTableInsertPlan) {
+            return fromChild(tempTableInsertPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryDefaultOnEmptyPlan(@Nonnull final RecordQueryDefaultOnEmptyPlan defaultOnEmptyPlan) {
-        final var cardinalitiesFromChild = fromChild(defaultOnEmptyPlan);
-        return new Cardinalities(Cardinality.ofCardinality(1), cardinalitiesFromChild.maxCardinality);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryIntersectionOnValuesPlan(@Nonnull final RecordQueryIntersectionOnValuesPlan intersectionOnValuesPlan) {
+            return weakenCardinalities(fromChildren(intersectionOnValuesPlan));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryUnionOnKeyExpressionPlan(@Nonnull final RecordQueryUnionOnKeyExpressionPlan unionOnKeyExpressionPlan) {
-        return unionCardinalities(fromChildren(unionOnKeyExpressionPlan));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryScoreForRankPlan(@Nonnull final RecordQueryScoreForRankPlan scoreForRankPlan) {
+            return fromChild(scoreForRankPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryFilterPlan(@Nonnull final RecordQueryFilterPlan filterPlan) {
-        final var cardinalitiesFromChild = fromChild(filterPlan);
-        return new Cardinalities(Cardinality.ofCardinality(0L), cardinalitiesFromChild.getMaxCardinality());
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryIndexPlan(@Nonnull final RecordQueryIndexPlan indexPlan) {
+            final var matchCandidateOptional = indexPlan.getMatchCandidateMaybe();
+            if (matchCandidateOptional.isEmpty()) {
+                return Cardinalities.unknownMaxCardinality();
+            }
+            final var matchCandidate = matchCandidateOptional.get();
+
+            final var ordering =
+                    matchCandidate.computeOrderingFromScanComparisons(indexPlan.getScanComparisons(),
+                            indexPlan.isReverse(),
+                            false);
+            final var equalityBoundValues = ordering.getEqualityBoundValues();
+
+            // try to see if the primary key is bound by equalities
+            if (matchCandidate instanceof WithPrimaryKeyMatchCandidate) {
+                final var primaryKeyValuesOptional = ((WithPrimaryKeyMatchCandidate)matchCandidate).getPrimaryKeyValuesMaybe();
+                if (primaryKeyValuesOptional.isPresent()) {
+                    final var primaryKeyValues = primaryKeyValuesOptional.get();
+                    if (equalityBoundValues.containsAll(primaryKeyValues)) {
+                        return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+                    }
+                }
+            }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryUnorderedPrimaryKeyDistinctPlan(@Nonnull final RecordQueryUnorderedPrimaryKeyDistinctPlan unorderedPrimaryKeyDistinctPlan) {
-        final var cardinalitiesFromChild = fromChild(unorderedPrimaryKeyDistinctPlan);
-        if (!cardinalitiesFromChild.getMinCardinality().isUnknown()) {
-            if (cardinalitiesFromChild.getMinCardinality().getCardinality() >= 1L) {
-                return new Cardinalities(Cardinality.ofCardinality(1L), cardinalitiesFromChild.getMaxCardinality());
+            if (matchCandidate.isUnique() && matchCandidate instanceof ValueIndexScanMatchCandidate) {
+                // unique index
+                final var valueIndexScanMatchCandidate = (ValueIndexScanMatchCandidate)matchCandidate;
+                final var translationMap = AliasMap.ofAliases(valueIndexScanMatchCandidate.getBaseAlias(), Quantifier.current());
+                final var keyValues =
+                        valueIndexScanMatchCandidate.getIndexKeyValues()
+                                .stream()
+                                .limit(matchCandidate.getColumnSize())
+                                .map(keyValue -> keyValue.rebase(translationMap))
+                                .collect(ImmutableList.toImmutableList());
+                if (equalityBoundValues.containsAll(keyValues)) {
+                    return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+                }
             }
-            // the case where min-cardinality == 0L is to fall through
+
+            return Cardinalities.unknownMaxCardinality();
         }
-        return cardinalitiesFromChild;
-    }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryTextIndexPlan(@Nonnull final RecordQueryTextIndexPlan element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryFirstOrDefaultPlan(@Nonnull final RecordQueryFirstOrDefaultPlan element) {
+            return new Cardinalities(Cardinality.ofCardinality(1L), Cardinality.ofCardinality(1L));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryFetchFromPartialRecordPlan(@Nonnull final RecordQueryFetchFromPartialRecordPlan fetchFromPartialRecordPlan) {
-        return fromChild(fetchFromPartialRecordPlan);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryDefaultOnEmptyPlan(@Nonnull final RecordQueryDefaultOnEmptyPlan defaultOnEmptyPlan) {
+            final var cardinalitiesFromChild = fromChild(defaultOnEmptyPlan);
+            return new Cardinalities(Cardinality.ofCardinality(1), cardinalitiesFromChild.maxCardinality);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryTypeFilterPlan(@Nonnull final RecordQueryTypeFilterPlan typeFilterPlan) {
-        return fromChild(typeFilterPlan);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryUnionOnKeyExpressionPlan(@Nonnull final RecordQueryUnionOnKeyExpressionPlan unionOnKeyExpressionPlan) {
+            return unionCardinalities(fromChildren(unionOnKeyExpressionPlan));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryInUnionOnKeyExpressionPlan(@Nonnull final RecordQueryInUnionOnKeyExpressionPlan inUnionOnKeyExpressionPlan) {
-        return visitRecordQueryInUnionPlan(inUnionOnKeyExpressionPlan);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryFilterPlan(@Nonnull final RecordQueryFilterPlan filterPlan) {
+            final var cardinalitiesFromChild = fromChild(filterPlan);
+            return new Cardinalities(Cardinality.ofCardinality(0L), cardinalitiesFromChild.getMaxCardinality());
+        }
 
-    @Nonnull
-    public Cardinalities visitRecordQueryInUnionPlan(@Nonnull final RecordQueryInUnionPlan inUnionPlan) {
-        final var inSources = inUnionPlan.getInSources();
-
-        final var inSourcesCardinalitiesOptional =
-                inSources.stream()
-                        .map(inSource -> {
-                            if (inSource instanceof InParameterSource || inSource instanceof InComparandSource) {
-                                return Cardinalities.unknownMaxCardinality();
-                            } else {
-                                Verify.verify(inSource instanceof InValuesSource);
-                                final var inValuesSource = (InValuesSource)inSource;
-                                final var size = inValuesSource.getValues().size();
-                                return new Cardinalities(Cardinality.ofCardinality(size), Cardinality.ofCardinality(size));
-                            }
-                        })
-                        .reduce(Cardinalities::times);
-
-        Verify.verify(inSourcesCardinalitiesOptional.isPresent());
-        final var inSourcesCardinalities = inSourcesCardinalitiesOptional.get();
-        final var childCardinalities = fromChild(inUnionPlan);
-
-        return inSourcesCardinalities.times(childCardinalities);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryUnorderedPrimaryKeyDistinctPlan(@Nonnull final RecordQueryUnorderedPrimaryKeyDistinctPlan unorderedPrimaryKeyDistinctPlan) {
+            final var cardinalitiesFromChild = fromChild(unorderedPrimaryKeyDistinctPlan);
+            if (!cardinalitiesFromChild.getMinCardinality().isUnknown()) {
+                if (cardinalitiesFromChild.getMinCardinality().getCardinality() >= 1L) {
+                    return new Cardinalities(Cardinality.ofCardinality(1L), cardinalitiesFromChild.getMaxCardinality());
+                }
+                // the case where min-cardinality == 0L is to fall through
+            }
+            return cardinalitiesFromChild;
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryInParameterJoinPlan(@Nonnull final RecordQueryInParameterJoinPlan element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryTextIndexPlan(@Nonnull final RecordQueryTextIndexPlan element) {
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryInComparandJoinPlan(@Nonnull final RecordQueryInComparandJoinPlan element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryFetchFromPartialRecordPlan(@Nonnull final RecordQueryFetchFromPartialRecordPlan fetchFromPartialRecordPlan) {
+            return fromChild(fetchFromPartialRecordPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryRecursiveUnionPlan(@Nonnull final RecordQueryRecursiveUnionPlan element) {
-        final var initialStateCardinality = fromChild(element.getChildren().get(0));
-        // this can be improved by imposing an assertion on the cardinality of the recursive leg; if the recursive leg
-        // has a known minimum cardinality of x | x > 0 then this query is infinitely recursive, so we should probably
-        // throw.
-        return new Cardinalities(initialStateCardinality.minCardinality, Cardinality.unknownCardinality);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryTypeFilterPlan(@Nonnull final RecordQueryTypeFilterPlan typeFilterPlan) {
+            return fromChild(typeFilterPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryFlatMapPlan(@Nonnull final RecordQueryFlatMapPlan flatMapPlan) {
-        final var fromChildren = fromChildren(flatMapPlan);
-        final var outerCardinalities = fromChildren.get(0);
-        final var innerCardinalities = fromChildren.get(1);
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryInUnionOnKeyExpressionPlan(@Nonnull final RecordQueryInUnionOnKeyExpressionPlan inUnionOnKeyExpressionPlan) {
+            return visitRecordQueryInUnionPlan(inUnionOnKeyExpressionPlan);
+        }
 
-        return outerCardinalities.times(innerCardinalities);
-    }
+        @Nonnull
+        public Cardinalities visitRecordQueryInUnionPlan(@Nonnull final RecordQueryInUnionPlan inUnionPlan) {
+            final var inSources = inUnionPlan.getInSources();
+
+            final var inSourcesCardinalitiesOptional =
+                    inSources.stream()
+                            .map(inSource -> {
+                                if (inSource instanceof InParameterSource || inSource instanceof InComparandSource) {
+                                    return Cardinalities.unknownMaxCardinality();
+                                } else {
+                                    Verify.verify(inSource instanceof InValuesSource);
+                                    final var inValuesSource = (InValuesSource)inSource;
+                                    final var size = inValuesSource.getValues().size();
+                                    return new Cardinalities(Cardinality.ofCardinality(size), Cardinality.ofCardinality(size));
+                                }
+                            })
+                            .reduce(Cardinalities::times);
+
+            Verify.verify(inSourcesCardinalitiesOptional.isPresent());
+            final var inSourcesCardinalities = inSourcesCardinalitiesOptional.get();
+            final var childCardinalities = fromChild(inUnionPlan);
+
+            return inSourcesCardinalities.times(childCardinalities);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryStreamingAggregationPlan(@Nonnull final RecordQueryStreamingAggregationPlan element) {
-        // if we do not have any grouping value, we will apply the aggregation(s) over the entire child result set
-        // and return a single row comprising the aggregation(s) result
-        if (element.getGroupingValue() == null) {
-            return new Cardinalities(Cardinality.ofCardinality(1L), Cardinality.ofCardinality(1L));
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryInParameterJoinPlan(@Nonnull final RecordQueryInParameterJoinPlan element) {
+            return Cardinalities.unknownMaxCardinality();
         }
-        // if the grouping value is constant, the cardinality ranges between 0 and 1.
-        if (element.getGroupingValue().isConstant()) {
-            return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryInComparandJoinPlan(@Nonnull final RecordQueryInComparandJoinPlan element) {
+            return Cardinalities.unknownMaxCardinality();
         }
-        return Cardinalities.unknownMaxCardinality();
-    }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryUnionOnValuesPlan(@Nonnull final RecordQueryUnionOnValuesPlan unionOnValuesPlan) {
-        return unionCardinalities(fromChildren(unionOnValuesPlan));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryRecursiveUnionPlan(@Nonnull final RecordQueryRecursiveUnionPlan element) {
+            final var initialStateCardinality = fromChild(element.getChildren().get(0));
+            // this can be improved by imposing an assertion on the cardinality of the recursive leg; if the recursive leg
+            // has a known minimum cardinality of x | x > 0 then this query is infinitely recursive, so we should probably
+            // throw.
+            return new Cardinalities(initialStateCardinality.minCardinality, Cardinality.unknownCardinality);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryUnorderedUnionPlan(@Nonnull final RecordQueryUnorderedUnionPlan unorderedUnionPlan) {
-        return unionCardinalities(fromChildren(unorderedUnionPlan));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryFlatMapPlan(@Nonnull final RecordQueryFlatMapPlan flatMapPlan) {
+            final var fromChildren = fromChildren(flatMapPlan);
+            final var outerCardinalities = fromChildren.get(0);
+            final var innerCardinalities = fromChildren.get(1);
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryScanPlan(@Nonnull final RecordQueryScanPlan scanPlan) {
-        final var matchCandidateOptional = scanPlan.getMatchCandidateMaybe();
-        if (matchCandidateOptional.isEmpty()) {
-            return Cardinalities.unknownMaxCardinality();
+            return outerCardinalities.times(innerCardinalities);
         }
 
-        final var matchCandidate = matchCandidateOptional.get();
-        final var primaryKeyValuesOptional = matchCandidate.getPrimaryKeyValuesMaybe();
-        if (primaryKeyValuesOptional.isEmpty()) {
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryStreamingAggregationPlan(@Nonnull final RecordQueryStreamingAggregationPlan element) {
+            // if we do not have any grouping value, we will apply the aggregation(s) over the entire child result set
+            // and return a single row comprising the aggregation(s) result
+            if (element.getGroupingValue() == null) {
+                return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+            }
+            // if the grouping value is constant, the cardinality ranges between 0 and 1.
+            if (element.getGroupingValue().isConstant()) {
+                return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+            }
             return Cardinalities.unknownMaxCardinality();
         }
-        final var primaryKeyValues = primaryKeyValuesOptional.get();
 
-        final var ordering =
-                matchCandidate.computeOrderingFromScanComparisons(scanPlan.getScanComparisons(),
-                        scanPlan.isReverse(),
-                        false);
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryUnionOnValuesPlan(@Nonnull final RecordQueryUnionOnValuesPlan unionOnValuesPlan) {
+            return unionCardinalities(fromChildren(unionOnValuesPlan));
+        }
 
-        final var equalityBoundValues = ordering.getEqualityBoundValues();
-        if (equalityBoundValues.containsAll(primaryKeyValues)) {
-            return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryUnorderedUnionPlan(@Nonnull final RecordQueryUnorderedUnionPlan unorderedUnionPlan) {
+            return unionCardinalities(fromChildren(unorderedUnionPlan));
         }
 
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryScanPlan(@Nonnull final RecordQueryScanPlan scanPlan) {
+            final var matchCandidateOptional = scanPlan.getMatchCandidateMaybe();
+            if (matchCandidateOptional.isEmpty()) {
+                return Cardinalities.unknownMaxCardinality();
+            }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryInUnionOnValuesPlan(@Nonnull final RecordQueryInUnionOnValuesPlan inUnionOnValuesPlan) {
-        return visitRecordQueryInUnionPlan(inUnionOnValuesPlan);
-    }
+            final var matchCandidate = matchCandidateOptional.get();
+            final var primaryKeyValuesOptional = matchCandidate.getPrimaryKeyValuesMaybe();
+            if (primaryKeyValuesOptional.isEmpty()) {
+                return Cardinalities.unknownMaxCardinality();
+            }
+            final var primaryKeyValues = primaryKeyValuesOptional.get();
 
-    @Nonnull
-    @Override
-    public Cardinalities visitComposedBitmapIndexQueryPlan(@Nonnull final ComposedBitmapIndexQueryPlan element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+            final var ordering =
+                    matchCandidate.computeOrderingFromScanComparisons(scanPlan.getScanComparisons(),
+                            scanPlan.isReverse(),
+                            false);
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQueryDamPlan(@Nonnull final RecordQueryDamPlan damPlan) {
-        return fromChild(damPlan);
-    }
+            final var equalityBoundValues = ordering.getEqualityBoundValues();
+            if (equalityBoundValues.containsAll(primaryKeyValues)) {
+                return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+            }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitMatchableSortExpression(@Nonnull final MatchableSortExpression matchableSortExpression) {
-        return fromChild(matchableSortExpression);
-    }
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitInsertExpression(@Nonnull final InsertExpression insertExpression) {
-        return fromChild(insertExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryInUnionOnValuesPlan(@Nonnull final RecordQueryInUnionOnValuesPlan inUnionOnValuesPlan) {
+            return visitRecordQueryInUnionPlan(inUnionOnValuesPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitTempTableInsertExpression(@Nonnull final TempTableInsertExpression tempTableInsertExpression) {
-        return fromChild(tempTableInsertExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitComposedBitmapIndexQueryPlan(@Nonnull final ComposedBitmapIndexQueryPlan element) {
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitPrimaryScanExpression(@Nonnull final PrimaryScanExpression element) {
-        // TODO do better
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQueryDamPlan(@Nonnull final RecordQueryDamPlan damPlan) {
+            return fromChild(damPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecursiveUnionExpression(@Nonnull final RecursiveUnionExpression element) {
-        final var initialStateCardinality = fromQuantifier(element.getQuantifiers().get(0));
-        return new Cardinalities(initialStateCardinality.minCardinality, Cardinality.unknownCardinality);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitMatchableSortExpression(@Nonnull final MatchableSortExpression matchableSortExpression) {
+            return fromChild(matchableSortExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitLogicalSortExpression(@Nonnull final LogicalSortExpression logicalSortExpression) {
-        return fromChild(logicalSortExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitInsertExpression(@Nonnull final InsertExpression insertExpression) {
+            return fromChild(insertExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitLogicalTypeFilterExpression(@Nonnull final LogicalTypeFilterExpression logicalTypeFilterExpression) {
-        return fromChild(logicalTypeFilterExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitTempTableInsertExpression(@Nonnull final TempTableInsertExpression tempTableInsertExpression) {
+            return fromChild(tempTableInsertExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitLogicalUnionExpression(@Nonnull final LogicalUnionExpression logicalUnionExpression) {
-        return unionCardinalities(fromChildren(logicalUnionExpression));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitPrimaryScanExpression(@Nonnull final PrimaryScanExpression element) {
+            // TODO do better
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitLogicalIntersectionExpression(@Nonnull final LogicalIntersectionExpression logicalIntersectionExpression) {
-        return intersectCardinalities(fromChildren(logicalIntersectionExpression));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecursiveUnionExpression(@Nonnull final RecursiveUnionExpression element) {
+            final var initialStateCardinality = fromQuantifier(element.getQuantifiers().get(0));
+            return new Cardinalities(initialStateCardinality.minCardinality, Cardinality.unknownCardinality);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitTableFunctionExpression(@Nonnull final TableFunctionExpression element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitLogicalSortExpression(@Nonnull final LogicalSortExpression logicalSortExpression) {
+            return fromChild(logicalSortExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitLogicalUniqueExpression(@Nonnull final LogicalUniqueExpression logicalUniqueExpression) {
-        return fromChild(logicalUniqueExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitLogicalTypeFilterExpression(@Nonnull final LogicalTypeFilterExpression logicalTypeFilterExpression) {
+            return fromChild(logicalTypeFilterExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitLogicalProjectionExpression(@Nonnull final LogicalProjectionExpression logicalProjectionExpression) {
-        return fromChild(logicalProjectionExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitLogicalUnionExpression(@Nonnull final LogicalUnionExpression logicalUnionExpression) {
+            return unionCardinalities(fromChildren(logicalUnionExpression));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitSelectExpression(@Nonnull final SelectExpression selectExpression) {
-        return fromChildren(selectExpression)
-                .stream()
-                .reduce(Cardinalities::times)
-                .orElseThrow(() -> new RecordCoreException("must have at least one quantifier"));
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitLogicalIntersectionExpression(@Nonnull final LogicalIntersectionExpression logicalIntersectionExpression) {
+            return intersectCardinalities(fromChildren(logicalIntersectionExpression));
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitExplodeExpression(@Nonnull final ExplodeExpression element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitTableFunctionExpression(@Nonnull final TableFunctionExpression element) {
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitFullUnorderedScanExpression(@Nonnull final FullUnorderedScanExpression element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitLogicalUniqueExpression(@Nonnull final LogicalUniqueExpression logicalUniqueExpression) {
+            return fromChild(logicalUniqueExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitTempTableScanExpression(@Nonnull final TempTableScanExpression element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitLogicalProjectionExpression(@Nonnull final LogicalProjectionExpression logicalProjectionExpression) {
+            return fromChild(logicalProjectionExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitGroupByExpression(@Nonnull final GroupByExpression element) {
-        // if we do not have any grouping value, we will apply the aggregation(s) over the entire child result set
-        // and return a single row comprising the aggregation(s) result
-        if (element.getGroupingValue() == null) {
-            return new Cardinalities(Cardinality.ofCardinality(1L), Cardinality.ofCardinality(1L));
+        @Nonnull
+        @Override
+        public Cardinalities visitSelectExpression(@Nonnull final SelectExpression selectExpression) {
+            return fromChildren(selectExpression)
+                    .stream()
+                    .reduce(Cardinalities::times)
+                    .orElseThrow(() -> new RecordCoreException("must have at least one quantifier"));
         }
-        // if the grouping value is constant, the cardinality ranges between 0 and 1.
-        if (element.getGroupingValue().isConstant()) {
-            return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+
+        @Nonnull
+        @Override
+        public Cardinalities visitExplodeExpression(@Nonnull final ExplodeExpression element) {
+            return Cardinalities.unknownMaxCardinality();
         }
-        return Cardinalities.unknownMaxCardinality();
-    }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitUpdateExpression(@Nonnull final UpdateExpression updateExpression) {
-        return fromChild(updateExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitFullUnorderedScanExpression(@Nonnull final FullUnorderedScanExpression element) {
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitLogicalDistinctExpression(@Nonnull final LogicalDistinctExpression logicalDistinctExpression) {
-        return fromChild(logicalDistinctExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitTempTableScanExpression(@Nonnull final TempTableScanExpression element) {
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitLogicalFilterExpression(@Nonnull final LogicalFilterExpression logicalFilterExpression) {
-        return fromChild(logicalFilterExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitGroupByExpression(@Nonnull final GroupByExpression element) {
+            // if we do not have any grouping value, we will apply the aggregation(s) over the entire child result set
+            // and return a single row comprising the aggregation(s) result
+            if (element.getGroupingValue() == null) {
+                return new Cardinalities(Cardinality.ofCardinality(1L), Cardinality.ofCardinality(1L));
+            }
+            // if the grouping value is constant, the cardinality ranges between 0 and 1.
+            if (element.getGroupingValue().isConstant()) {
+                return new Cardinalities(Cardinality.ofCardinality(0L), Cardinality.ofCardinality(1L));
+            }
+            return Cardinalities.unknownMaxCardinality();
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitDeleteExpression(@Nonnull final DeleteExpression deleteExpression) {
-        return fromChild(deleteExpression);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitUpdateExpression(@Nonnull final UpdateExpression updateExpression) {
+            return fromChild(updateExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitRecordQuerySortPlan(@Nonnull final RecordQuerySortPlan querySortPlan) {
-        return fromChild(querySortPlan);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitLogicalDistinctExpression(@Nonnull final LogicalDistinctExpression logicalDistinctExpression) {
+            return fromChild(logicalDistinctExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities visitTempTableScanPlan(@Nonnull final TempTableScanPlan element) {
-        return Cardinalities.unknownMaxCardinality();
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitLogicalFilterExpression(@Nonnull final LogicalFilterExpression logicalFilterExpression) {
+            return fromChild(logicalFilterExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Cardinalities> childResults) {
-        throw new RecordCoreException("unsupported method call. property should instead override visit for expression");
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitDeleteExpression(@Nonnull final DeleteExpression deleteExpression) {
+            return fromChild(deleteExpression);
+        }
 
-    @Nonnull
-    @Override
-    public Cardinalities evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Cardinalities> memberResults) {
-        return intersectCardinalities(memberResults);
-    }
+        @Nonnull
+        @Override
+        public Cardinalities visitRecordQuerySortPlan(@Nonnull final RecordQuerySortPlan querySortPlan) {
+            return fromChild(querySortPlan);
+        }
 
-    @Nonnull
-    private Cardinalities intersectCardinalities(@Nonnull Iterable<Cardinalities> cardinalitiesIterable) {
-        //
-        // Merge all cardinalities in the iterable.
-        // If the cardinality in one member is unknown but not in the other, we'll take the more constraining one
-        //
-        var minCardinality = Cardinality.unknownCardinality();
-        var maxCardinality = Cardinality.unknownCardinality();
-        for (final var cardinalities : cardinalitiesIterable) {
-            if (minCardinality.isUnknown()) {
-                minCardinality = cardinalities.getMinCardinality();
-            } else {
-                if (!cardinalities.getMinCardinality().isUnknown()) {
-                    minCardinality = Cardinality.ofCardinality(0);
+        @Nonnull
+        @Override
+        public Cardinalities visitTempTableScanPlan(@Nonnull final TempTableScanPlan element) {
+            return Cardinalities.unknownMaxCardinality();
+        }
+
+        @Nonnull
+        private Cardinalities intersectCardinalities(@Nonnull Iterable<Cardinalities> cardinalitiesIterable) {
+            //
+            // Merge all cardinalities in the iterable.
+            // If the cardinality in one member is unknown but not in the other, we'll take the more constraining one
+            //
+            var minCardinality = Cardinality.unknownCardinality();
+            var maxCardinality = Cardinality.unknownCardinality();
+            for (final var cardinalities : cardinalitiesIterable) {
+                if (minCardinality.isUnknown()) {
+                    minCardinality = cardinalities.getMinCardinality();
                 } else {
-                    minCardinality = Cardinality.unknownCardinality();
+                    if (!cardinalities.getMinCardinality().isUnknown()) {
+                        minCardinality = Cardinality.ofCardinality(0);
+                    } else {
+                        minCardinality = Cardinality.unknownCardinality();
+                    }
                 }
-            }
 
-            if (maxCardinality.isUnknown()) {
-                maxCardinality = cardinalities.getMaxCardinality();
-            } else {
-                if (!cardinalities.getMaxCardinality().isUnknown()) {
-                    maxCardinality = Cardinality.ofCardinality(Math.min(maxCardinality.getCardinality(), cardinalities.getMaxCardinality().getCardinality()));
+                if (maxCardinality.isUnknown()) {
+                    maxCardinality = cardinalities.getMaxCardinality();
                 } else {
-                    maxCardinality = Cardinality.unknownCardinality();
+                    if (!cardinalities.getMaxCardinality().isUnknown()) {
+                        maxCardinality = Cardinality.ofCardinality(Math.min(maxCardinality.getCardinality(), cardinalities.getMaxCardinality().getCardinality()));
+                    } else {
+                        maxCardinality = Cardinality.unknownCardinality();
+                    }
                 }
             }
-        }
-
-        return new Cardinalities(minCardinality, maxCardinality);
-    }
 
-    @Nonnull
-    private Cardinalities unionCardinalities(@Nonnull Iterable<Cardinalities> cardinalitiesIterable) {
-        //
-        // Merge all cardinalities in the iterable.
-        //
-        final var iterator = cardinalitiesIterable.iterator();
-
-        if (!iterator.hasNext()) {
-            return Cardinalities.unknownMaxCardinality();
+            return new Cardinalities(minCardinality, maxCardinality);
         }
 
-        var cardinalities = iterator.next();
+        @Nonnull
+        private Cardinalities unionCardinalities(@Nonnull Iterable<Cardinalities> cardinalitiesIterable) {
+            //
+            // Merge all cardinalities in the iterable.
+            //
+            final var iterator = cardinalitiesIterable.iterator();
+
+            if (!iterator.hasNext()) {
+                return Cardinalities.unknownMaxCardinality();
+            }
 
-        var minCardinality = cardinalities.getMinCardinality();
-        var maxCardinality = cardinalities.getMaxCardinality();
-        while (iterator.hasNext()) {
-            cardinalities = iterator.next();
+            var cardinalities = iterator.next();
 
-            if (!minCardinality.isUnknown()) {
-                final var currentMinCardinality = cardinalities.getMinCardinality();
-                if (currentMinCardinality.isUnknown()) {
-                    minCardinality = Cardinality.unknownCardinality();
-                } else {
-                    minCardinality = Cardinality.ofCardinality(minCardinality.getCardinality() + currentMinCardinality.getCardinality());
+            var minCardinality = cardinalities.getMinCardinality();
+            var maxCardinality = cardinalities.getMaxCardinality();
+            while (iterator.hasNext()) {
+                cardinalities = iterator.next();
+
+                if (!minCardinality.isUnknown()) {
+                    final var currentMinCardinality = cardinalities.getMinCardinality();
+                    if (currentMinCardinality.isUnknown()) {
+                        minCardinality = Cardinality.unknownCardinality();
+                    } else {
+                        minCardinality = Cardinality.ofCardinality(minCardinality.getCardinality() + currentMinCardinality.getCardinality());
+                    }
                 }
-            }
 
-            if (!maxCardinality.isUnknown()) {
-                final var currentMaxCardinality = cardinalities.getMaxCardinality();
-                if (currentMaxCardinality.isUnknown()) {
-                    maxCardinality = Cardinality.unknownCardinality();
-                } else {
-                    maxCardinality = Cardinality.ofCardinality(maxCardinality.getCardinality() + currentMaxCardinality.getCardinality());
+                if (!maxCardinality.isUnknown()) {
+                    final var currentMaxCardinality = cardinalities.getMaxCardinality();
+                    if (currentMaxCardinality.isUnknown()) {
+                        maxCardinality = Cardinality.unknownCardinality();
+                    } else {
+                        maxCardinality = Cardinality.ofCardinality(maxCardinality.getCardinality() + currentMaxCardinality.getCardinality());
+                    }
                 }
             }
-        }
 
-        return new Cardinalities(minCardinality, maxCardinality);
-    }
-
-    @Nonnull
-    private Cardinalities weakenCardinalities(@Nonnull Iterable<Cardinalities> cardinalitiesIterable) {
-        //
-        // Merge all cardinalities in the iterable.
-        // If the cardinality in one member is unknown but not in the other, we'll take the less constraining one
-        //
-        final var iterator = cardinalitiesIterable.iterator();
-
-        if (!iterator.hasNext()) {
-            return Cardinalities.unknownMaxCardinality();
+            return new Cardinalities(minCardinality, maxCardinality);
         }
 
-        var cardinalities = iterator.next();
+        @Nonnull
+        private Cardinalities weakenCardinalities(@Nonnull Iterable<Cardinalities> cardinalitiesIterable) {
+            //
+            // Merge all cardinalities in the iterable.
+            // If the cardinality in one member is unknown but not in the other, we'll take the less constraining one
+            //
+            final var iterator = cardinalitiesIterable.iterator();
+
+            if (!iterator.hasNext()) {
+                return Cardinalities.unknownMaxCardinality();
+            }
 
-        var minCardinality = cardinalities.getMinCardinality();
-        var maxCardinality = cardinalities.getMaxCardinality();
-        while (iterator.hasNext()) {
-            cardinalities = iterator.next();
+            var cardinalities = iterator.next();
 
-            if (!minCardinality.isUnknown()) {
-                final var currentMinCardinality = cardinalities.getMinCardinality();
-                if (currentMinCardinality.isUnknown() ||
-                        minCardinality.getCardinality() > currentMinCardinality.getCardinality()) {
-                    minCardinality = currentMinCardinality;
+            var minCardinality = cardinalities.getMinCardinality();
+            var maxCardinality = cardinalities.getMaxCardinality();
+            while (iterator.hasNext()) {
+                cardinalities = iterator.next();
+
+                if (!minCardinality.isUnknown()) {
+                    final var currentMinCardinality = cardinalities.getMinCardinality();
+                    if (currentMinCardinality.isUnknown() ||
+                            minCardinality.getCardinality() > currentMinCardinality.getCardinality()) {
+                        minCardinality = currentMinCardinality;
+                    }
                 }
-            }
 
-            if (!maxCardinality.isUnknown()) {
-                final var currentMaxCardinality = cardinalities.getMaxCardinality();
-                if (currentMaxCardinality.isUnknown() ||
-                        maxCardinality.getCardinality() < currentMaxCardinality.getCardinality()) {
-                    maxCardinality = currentMaxCardinality;
+                if (!maxCardinality.isUnknown()) {
+                    final var currentMaxCardinality = cardinalities.getMaxCardinality();
+                    if (currentMaxCardinality.isUnknown() ||
+                            maxCardinality.getCardinality() < currentMaxCardinality.getCardinality()) {
+                        maxCardinality = currentMaxCardinality;
+                    }
                 }
             }
-        }
-
-        return new Cardinalities(minCardinality, maxCardinality);
-    }
 
-    @Nonnull
-    private  Cardinalities fromChild(@Nonnull final RelationalExpression relationalExpression) {
-        Verify.verify(relationalExpression.getQuantifiers().size() == 1);
-        return Iterables.getOnlyElement(fromChildren(relationalExpression));
-    }
+            return new Cardinalities(minCardinality, maxCardinality);
+        }
 
-    @Nonnull
-    private List<Cardinalities> fromChildren(@Nonnull final RelationalExpression relationalExpression) {
-        return fromQuantifiers(relationalExpression.getQuantifiers());
-    }
+        @Nonnull
+        private Cardinalities fromChild(@Nonnull final RelationalExpression relationalExpression) {
+            Verify.verify(relationalExpression.getQuantifiers().size() == 1);
+            return Iterables.getOnlyElement(fromChildren(relationalExpression));
+        }
 
-    @Nonnull
-    private List<Cardinalities> fromQuantifiers(@Nonnull final List<? extends Quantifier> quantifiers) {
-        final var quantifierResults = Lists.<Cardinalities>newArrayListWithCapacity(quantifiers.size());
-        for (final Quantifier quantifier : quantifiers) {
-            quantifierResults.add(fromQuantifier(quantifier));
+        @Nonnull
+        private List<Cardinalities> fromChildren(@Nonnull final RelationalExpression relationalExpression) {
+            return fromQuantifiers(relationalExpression.getQuantifiers());
         }
 
-        return quantifierResults;
-    }
+        @Nonnull
+        private List<Cardinalities> fromQuantifiers(@Nonnull final List<? extends Quantifier> quantifiers) {
+            final var quantifierResults = Lists.<Cardinalities>newArrayListWithCapacity(quantifiers.size());
+            for (final Quantifier quantifier : quantifiers) {
+                quantifierResults.add(fromQuantifier(quantifier));
+            }
 
-    @Nonnull
-    private Cardinalities fromQuantifier(@Nonnull final Quantifier quantifier) {
-        if (quantifier instanceof Quantifier.Existential) {
-            return new Cardinalities(Cardinality.ofCardinality(1L), Cardinality.ofCardinality(1L));
+            return quantifierResults;
         }
 
-        @Nullable final var nullableResult =
-                quantifier.acceptPropertyVisitor(this);
-        return Objects.requireNonNull(nullableResult);
-    }
+        @Nonnull
+        private Cardinalities fromQuantifier(@Nonnull final Quantifier quantifier) {
+            if (quantifier instanceof Quantifier.Existential) {
+                return new Cardinalities(Cardinality.ofCardinality(1L), Cardinality.ofCardinality(1L));
+            }
 
-    @Nonnull
-    public static Cardinalities evaluate(@Nonnull RelationalExpression expression) {
-        Cardinalities result = expression.acceptPropertyVisitor(INSTANCE);
-        if (result == null) {
-            return Cardinalities.unknownMaxCardinality();
+            return visit(quantifier.getRangesOver().get());
         }
-        return result;
-    }
 
-    @Nonnull
-    public static Cardinalities evaluate(@Nonnull Quantifier quantifier) {
-        return new CardinalitiesProperty().fromQuantifier(quantifier);
-    }
-
-    @Nonnull
-    public static Cardinalities evaluate(@Nonnull Reference ref) {
-        @Nullable final var nullableResult =
-                ref.acceptPropertyVisitor(new CardinalitiesProperty());
-        return Objects.requireNonNull(nullableResult);
+        @Nonnull
+        @Override
+        public Cardinalities visitDefault(@Nonnull final RelationalExpression element) {
+            throw new RecordCoreException("not implemented");
+        }
     }
 
-
     /**
      *  Class to capture both minimum and maximum cardinality of an expression. Also contains some helpers to combine
      *  cardinality information.
      */
-    @SpotBugsSuppressWarnings(value = "SING_SINGLETON_HAS_NONPRIVATE_CONSTRUCTOR", justification = "False positive as this is not a singleton class")
+    @SpotBugsSuppressWarnings(value = "SING_SINGLETON_HAS_NONPRIVATE_CONSTRUCTOR",
+            justification = "False positive as this is not a singleton class")
     public static class Cardinalities {
         private static final Cardinalities unknownCardinalities = new Cardinalities(Cardinality.unknownCardinality(), Cardinality.unknownCardinality());
 
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ComparisonsProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ComparisonsProperty.java
index 3b6b028b07..1bb65e6aab 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ComparisonsProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ComparisonsProperty.java
@@ -25,8 +25,8 @@
 import com.apple.foundationdb.record.query.plan.ScanComparisons;
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryCoveringIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIntersectionOnKeyExpressionPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIntersectionOnValuesPlan;
@@ -41,107 +41,138 @@
 
 import javax.annotation.Nonnull;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 
 /**
- * A property for collecting all {@link ScanComparisons} for the sub tree the property is evaluated on.
+ * A property for collecting all {@link ScanComparisons} for the subtree the property is evaluated on.
  */
 @API(API.Status.EXPERIMENTAL)
-public class ComparisonsProperty implements ExpressionProperty<Set<Comparisons.Comparison>>, RelationalExpressionVisitorWithDefaults<Set<Comparisons.Comparison>> {
-    @Nonnull
-    @Override
-    public Set<Comparisons.Comparison> evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Set<Comparisons.Comparison>> childResults) {
-        final ImmutableSet.Builder<Comparisons.Comparison> resultBuilder = ImmutableSet.builder();
-        for (final var childResult : childResults) {
-            if (childResult != null) {
-                resultBuilder.addAll(childResult);
-            }
-        }
+public class ComparisonsProperty implements ExpressionProperty<Set<Comparisons.Comparison>> {
+    private static final ComparisonsProperty COMPARISONS = new ComparisonsProperty();
 
-        if (expression instanceof RecordQueryCoveringIndexPlan) {
-            expression = ((RecordQueryCoveringIndexPlan)expression).getIndexPlan();
-        }
+    private ComparisonsProperty() {
+        // prevent outside instantiation
+    }
 
-        if (expression instanceof RecordQueryPlanWithComparisons) {
-            final var planWithComparisons = (RecordQueryPlanWithComparisons)expression;
-            if (planWithComparisons.hasComparisons()) {
-                resultBuilder.addAll(planWithComparisons.getComparisons());
-            }
-        }
+    @Nonnull
+    @Override
+    public ComparisonsVisitor createVisitor() {
+        return new ComparisonsVisitor();
+    }
 
-        return resultBuilder.build();
+    @Override
+    public String toString() {
+        return getClass().getSimpleName();
     }
 
     @Nonnull
-    @Override
-    public Set<Comparisons.Comparison> visitRecordQueryIntersectionOnKeyExpressionPlan(@Nonnull final RecordQueryIntersectionOnKeyExpressionPlan intersectionOnKeyExpressionPlan) {
-        return visitRecordQueryIntersectionPlan(intersectionOnKeyExpressionPlan);
+    public Set<Comparisons.Comparison> evaluate(@Nonnull final Reference reference) {
+        return Objects.requireNonNull(reference.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    @Override
-    public Set<Comparisons.Comparison> visitRecordQueryIntersectionOnValuesPlan(@Nonnull final RecordQueryIntersectionOnValuesPlan intersectionOnValuesPlan) {
-        return visitRecordQueryIntersectionPlan(intersectionOnValuesPlan);
+    public Set<Comparisons.Comparison> evaluate(@Nonnull final RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    private Set<Comparisons.Comparison> visitRecordQueryIntersectionPlan(@Nonnull final RecordQueryIntersectionPlan intersectionPlan) {
-        //TODO revisit this logic if we ever implement skipping intersections
-        final var comparisonsFromQuantifiers = visitQuantifiers(intersectionPlan);
-        Verify.verify(!comparisonsFromQuantifiers.isEmpty());
+    public static ComparisonsProperty comparisons() {
+        return COMPARISONS;
+    }
 
-        if (comparisonsFromQuantifiers.size() == 1) {
-            return Iterables.getOnlyElement(comparisonsFromQuantifiers);
+    /**
+     * Visitor implementation.
+     */
+    public static class ComparisonsVisitor implements SimpleExpressionVisitor<Set<Comparisons.Comparison>> {
+        @Nonnull
+        @Override
+        public Set<Comparisons.Comparison> evaluateAtExpression(@Nonnull RelationalExpression expression,
+                                                                @Nonnull final List<Set<Comparisons.Comparison>> childResults) {
+            final ImmutableSet.Builder<Comparisons.Comparison> resultBuilder = ImmutableSet.builder();
+            for (final var childResult : childResults) {
+                if (childResult != null) {
+                    resultBuilder.addAll(childResult);
+                }
+            }
+
+            if (expression instanceof RecordQueryCoveringIndexPlan) {
+                expression = ((RecordQueryCoveringIndexPlan)expression).getIndexPlan();
+            }
+
+            if (expression instanceof RecordQueryPlanWithComparisons) {
+                final var planWithComparisons = (RecordQueryPlanWithComparisons)expression;
+                if (planWithComparisons.hasComparisons()) {
+                    resultBuilder.addAll(planWithComparisons.getComparisons());
+                }
+            }
+
+            return resultBuilder.build();
         }
 
-        final var it = comparisonsFromQuantifiers.iterator();
-        final var intersected = Sets.newHashSet(it.next());
-        while (it.hasNext()) {
-            intersected.retainAll(it.next());
+        @Nonnull
+        @Override
+        public Set<Comparisons.Comparison> visitRecordQueryIntersectionOnKeyExpressionPlan(@Nonnull final RecordQueryIntersectionOnKeyExpressionPlan intersectionOnKeyExpressionPlan) {
+            return visitRecordQueryIntersectionPlan(intersectionOnKeyExpressionPlan);
         }
-        return intersected;
-    }
 
-    @Nonnull
-    @Override
-    public Set<Comparisons.Comparison> visitRecordQueryScoreForRankPlan(@Nonnull final RecordQueryScoreForRankPlan scoreForRankPlan) {
-        final var ranks = scoreForRankPlan.getRanks();
-        return ranks.stream()
-                .flatMap(rank -> rank.getComparisons().stream())
-                .collect(ImmutableSet.toImmutableSet());
-    }
+        @Nonnull
+        @Override
+        public Set<Comparisons.Comparison> visitRecordQueryIntersectionOnValuesPlan(@Nonnull final RecordQueryIntersectionOnValuesPlan intersectionOnValuesPlan) {
+            return visitRecordQueryIntersectionPlan(intersectionOnValuesPlan);
+        }
 
-    @Nonnull
-    @Override
-    public Set<Comparisons.Comparison> visitRecordQueryTextIndexPlan(@Nonnull final RecordQueryTextIndexPlan textIndexPlan) {
-        final ImmutableSet.Builder<Comparisons.Comparison> resultBuilder = ImmutableSet.builder();
-        final var scanComparisons = textIndexPlan.getTextScan().getGroupingComparisons();
-        if (scanComparisons != null) {
-            resultBuilder.addAll(scanComparisons.getEqualityComparisons())
-                    .addAll(scanComparisons.getInequalityComparisons());
+        @Nonnull
+        private Set<Comparisons.Comparison> visitRecordQueryIntersectionPlan(@Nonnull final RecordQueryIntersectionPlan intersectionPlan) {
+            //TODO revisit this logic if we ever implement skipping intersections
+            final var comparisonsFromQuantifiers = visitQuantifiers(intersectionPlan);
+            Verify.verify(!comparisonsFromQuantifiers.isEmpty());
+
+            if (comparisonsFromQuantifiers.size() == 1) {
+                return Iterables.getOnlyElement(comparisonsFromQuantifiers);
+            }
+
+            final var it = comparisonsFromQuantifiers.iterator();
+            final var intersected = Sets.newHashSet(it.next());
+            while (it.hasNext()) {
+                intersected.retainAll(it.next());
+            }
+            return intersected;
         }
 
-        resultBuilder.add(textIndexPlan.getTextScan().getTextComparison());
-        return resultBuilder.build();
-    }
+        @Nonnull
+        @Override
+        public Set<Comparisons.Comparison> visitRecordQueryScoreForRankPlan(@Nonnull final RecordQueryScoreForRankPlan scoreForRankPlan) {
+            final var ranks = scoreForRankPlan.getRanks();
+            return ranks.stream()
+                    .flatMap(rank -> rank.getComparisons().stream())
+                    .collect(ImmutableSet.toImmutableSet());
+        }
 
-    @Nonnull
-    @Override
-    public Set<Comparisons.Comparison> evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Set<Comparisons.Comparison>> memberResults) {
-        final var resultBuilder = ImmutableSet.<Comparisons.Comparison>builder();
-        for (final var memberResult : memberResults) {
-            if (memberResult != null) {
-                resultBuilder.addAll(memberResult);
+        @Nonnull
+        @Override
+        public Set<Comparisons.Comparison> visitRecordQueryTextIndexPlan(@Nonnull final RecordQueryTextIndexPlan textIndexPlan) {
+            final ImmutableSet.Builder<Comparisons.Comparison> resultBuilder = ImmutableSet.builder();
+            final var scanComparisons = textIndexPlan.getTextScan().getGroupingComparisons();
+            if (scanComparisons != null) {
+                resultBuilder.addAll(scanComparisons.getEqualityComparisons())
+                        .addAll(scanComparisons.getInequalityComparisons());
             }
+
+            resultBuilder.add(textIndexPlan.getTextScan().getTextComparison());
+            return resultBuilder.build();
         }
-        return resultBuilder.build();
-    }
 
-    public static Set<Comparisons.Comparison> evaluate(@Nonnull RelationalExpression expression) {
-        final var result = expression.acceptPropertyVisitor(new ComparisonsProperty());
-        if (result == null) {
-            return ImmutableSet.of();
+        @Nonnull
+        @Override
+        public Set<Comparisons.Comparison> evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Set<Comparisons.Comparison>> memberResults) {
+            final var resultBuilder = ImmutableSet.<Comparisons.Comparison>builder();
+            for (final var memberResult : memberResults) {
+                if (memberResult != null) {
+                    resultBuilder.addAll(memberResult);
+                }
+            }
+            return resultBuilder.build();
         }
-        return result;
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/DerivationsProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/DerivationsProperty.java
index 92b7493ea2..648330ebc8 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/DerivationsProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/DerivationsProperty.java
@@ -26,9 +26,10 @@
 import com.apple.foundationdb.record.query.expressions.Comparisons;
 import com.apple.foundationdb.record.query.plan.bitmap.ComposedBitmapIndexQueryPlan;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
+import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.PlanProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.FirstOrDefaultStreamingValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.apple.foundationdb.record.query.plan.cascades.TreeLike;
@@ -108,13 +109,17 @@
  * In particular, a {@link Value}-tree that somewhere appears in a plan as part of a {@link QueryPredicate}, or other
  * expression, is guaranteed to be part of a derivation which is not correlated.
  */
-public class DerivationsProperty implements PlanProperty<DerivationsProperty.Derivations> {
-    public static final DerivationsProperty DERIVATIONS = new DerivationsProperty();
+public class DerivationsProperty implements ExpressionProperty<DerivationsProperty.Derivations> {
+    private static final DerivationsProperty DERIVATIONS = new DerivationsProperty();
+
+    private DerivationsProperty() {
+        // prevent outside instantiation
+    }
 
     @Nonnull
     @Override
-    public RecordQueryPlanVisitor<Derivations> createVisitor() {
-        return new DerivationsVisitor();
+    public RelationalExpressionVisitor<Derivations> createVisitor() {
+        return ExpressionProperty.toExpressionVisitor(new DerivationsVisitor());
     }
 
     @Override
@@ -122,6 +127,21 @@ public String toString() {
         return getClass().getSimpleName();
     }
 
+    @Nonnull
+    public Derivations evaluate(@Nonnull final Reference reference) {
+        return evaluate(reference.getAsPlan());
+    }
+
+    @Nonnull
+    public Derivations evaluate(@Nonnull final RecordQueryPlan recordQueryPlan) {
+        return createVisitor().visit(recordQueryPlan);
+    }
+
+    @Nonnull
+    public static DerivationsProperty derivations() {
+        return DERIVATIONS;
+    }
+
     /**
      * A visitor that determines the derivations of a {@link RecordQueryPlan}.
      */
@@ -793,11 +813,6 @@ private Derivations evaluateForReference(@Nonnull Reference reference) {
         }
     }
 
-    @Nonnull
-    public static Derivations evaluateDerivations(@Nonnull RecordQueryPlan recordQueryPlan) {
-        return DERIVATIONS.createVisitor().visit(recordQueryPlan);
-    }
-
     /**
      * Cases class to capture the derivations that are being collected by the visitor.
      */
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/DistinctRecordsProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/DistinctRecordsProperty.java
index 3a62e651cb..9b1fcce9ba 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/DistinctRecordsProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/DistinctRecordsProperty.java
@@ -23,10 +23,11 @@
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.RecordCoreException;
 import com.apple.foundationdb.record.query.plan.bitmap.ComposedBitmapIndexQueryPlan;
+import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.PlanProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.QuantifiedObjectValue;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryAggregateIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryComparatorPlan;
@@ -81,13 +82,17 @@
 /**
  * An attribute used to indicate if a plan produces distinct records.
  */
-public class DistinctRecordsProperty implements PlanProperty<Boolean> {
-    public static final PlanProperty<Boolean> DISTINCT_RECORDS = new DistinctRecordsProperty();
+public class DistinctRecordsProperty implements ExpressionProperty<Boolean> {
+    private static final DistinctRecordsProperty DISTINCT_RECORDS = new DistinctRecordsProperty();
+
+    private DistinctRecordsProperty() {
+        // prevent outside instantiation
+    }
 
     @Nonnull
     @Override
-    public RecordQueryPlanVisitor<Boolean> createVisitor() {
-        return new DistinctRecordsVisitor();
+    public RelationalExpressionVisitor<Boolean> createVisitor() {
+        return ExpressionProperty.toExpressionVisitor(new DistinctRecordsVisitor());
     }
 
     @Override
@@ -95,6 +100,19 @@ public String toString() {
         return getClass().getSimpleName();
     }
 
+    public boolean evaluate(@Nonnull final Reference reference) {
+        return evaluate(reference.getAsPlan());
+    }
+
+    public boolean evaluate(@Nonnull final RecordQueryPlan recordQueryPlan) {
+        return createVisitor().visit(recordQueryPlan);
+    }
+
+    @Nonnull
+    public static DistinctRecordsProperty distinctRecords() {
+        return DISTINCT_RECORDS;
+    }
+
     /**
      * A visitor that determines whether the expression may produce distinct records.
      */
@@ -406,16 +424,11 @@ private List<Boolean> distinctRecordsFromChildren(@Nonnull final RelationalExpre
 
         private boolean evaluateForReference(@Nonnull Reference reference) {
             final var memberDistinctRecordsCollection =
-                    reference.getPlannerAttributeForMembers(DISTINCT_RECORDS).values();
+                    reference.getProperty(DISTINCT_RECORDS).values();
 
             return memberDistinctRecordsCollection
                     .stream()
                     .allMatch(d -> d);
         }
-
-        public static boolean evaluate(@Nonnull RecordQueryPlan recordQueryPlan) {
-            // Won't actually be null for relational planner expressions.
-            return new DistinctRecordsVisitor().visit(recordQueryPlan);
-        }
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/RelationalExpressionDepthProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ExpressionDepthProperty.java
similarity index 51%
rename from fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/RelationalExpressionDepthProperty.java
rename to fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ExpressionDepthProperty.java
index 3f93feb4da..4c81ada998 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/RelationalExpressionDepthProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ExpressionDepthProperty.java
@@ -1,5 +1,5 @@
 /*
- * RelationalExpressionDepthProperty.java
+ * ExpressionDepthProperty.java
  *
  * This source file is part of the FoundationDB open source project
  *
@@ -22,19 +22,20 @@
 
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalDistinctExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalTypeFilterExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryFetchFromPartialRecordPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlanWithIndex;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryTypeFilterPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryUnorderedPrimaryKeyDistinctPlan;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalDistinctExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalTypeFilterExpression;
 import com.google.common.collect.ImmutableSet;
 
 import javax.annotation.Nonnull;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 
 /**
@@ -42,46 +43,80 @@
  * planner expression: that is, the smallest integer such that one of those types is exactly that many relational
  * planner expressions away from the root expression.
  */
-public class RelationalExpressionDepthProperty implements ExpressionProperty<Integer>, RelationalExpressionVisitorWithDefaults<Integer> {
-    public static final RelationalExpressionDepthProperty TYPE_FILTER_DEPTH = new RelationalExpressionDepthProperty(
+public class ExpressionDepthProperty implements ExpressionProperty<Integer> {
+    private static final ExpressionDepthProperty TYPE_FILTER_DEPTH = new ExpressionDepthProperty(
             ImmutableSet.of(LogicalTypeFilterExpression.class, RecordQueryTypeFilterPlan.class));
-    public static final RelationalExpressionDepthProperty DISTINCT_FILTER_DEPTH = new RelationalExpressionDepthProperty(
+    private static final ExpressionDepthProperty DISTINCT_DEPTH = new ExpressionDepthProperty(
             ImmutableSet.of(LogicalDistinctExpression.class, RecordQueryUnorderedPrimaryKeyDistinctPlan.class));
-    public static final RelationalExpressionDepthProperty FETCH_DEPTH = new RelationalExpressionDepthProperty(
+    private static final ExpressionDepthProperty FETCH_DEPTH = new ExpressionDepthProperty(
             ImmutableSet.of(RecordQueryFetchFromPartialRecordPlan.class, RecordQueryPlanWithIndex.class));
 
     @Nonnull
     private final Set<Class<? extends RelationalExpression>> types;
 
-    public RelationalExpressionDepthProperty(@Nonnull Set<Class<? extends RelationalExpression>> types) {
-        this.types = types;
+    private ExpressionDepthProperty(@Nonnull Set<Class<? extends RelationalExpression>> types) {
+        this.types = ImmutableSet.copyOf(types);
     }
 
     @Nonnull
     @Override
-    public Integer evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Integer> childResults) {
-        for (Class<? extends RelationalExpression> type : types) {
-            if (type.isInstance(expression)) {
-                return 0;
-            }
-        }
+    public ExpressionDepthVisitor createVisitor() {
+        return new ExpressionDepthVisitor(types);
+    }
 
-        int min = Integer.MAX_VALUE;
-        for (Integer result : childResults) {
-            if (result != null && result < min) {
-                min = result;
-            }
-        }
-        return min == Integer.MAX_VALUE ? Integer.MAX_VALUE : min + 1;
+    public int evaluate(@Nonnull final Reference reference) {
+        return Objects.requireNonNull(reference.acceptVisitor(createVisitor()));
+    }
+
+    public int evaluate(@Nonnull final RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    @Override
-    public Integer evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Integer> memberResults) {
-        return Collections.min(memberResults);
+    public static ExpressionDepthProperty typeFilterDepth() {
+        return TYPE_FILTER_DEPTH;
     }
 
-    public int evaluate(@Nonnull RelationalExpression expression) {
-        return expression.acceptPropertyVisitor(this);
+    @Nonnull
+    public static ExpressionDepthProperty distinctDepth() {
+        return DISTINCT_DEPTH;
+    }
+
+    @Nonnull
+    public static ExpressionDepthProperty fetchDepth() {
+        return FETCH_DEPTH;
+    }
+
+    public static class ExpressionDepthVisitor implements SimpleExpressionVisitor<Integer> {
+        @Nonnull
+        private final Set<Class<? extends RelationalExpression>> types;
+
+        public ExpressionDepthVisitor(@Nonnull Set<Class<? extends RelationalExpression>> types) {
+            this.types = ImmutableSet.copyOf(types);
+        }
+
+        @Nonnull
+        @Override
+        public Integer evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Integer> childResults) {
+            for (Class<? extends RelationalExpression> type : types) {
+                if (type.isInstance(expression)) {
+                    return 0;
+                }
+            }
+
+            int min = Integer.MAX_VALUE;
+            for (Integer result : childResults) {
+                if (result != null && result < min) {
+                    min = result;
+                }
+            }
+            return min == Integer.MAX_VALUE ? Integer.MAX_VALUE : min + 1;
+        }
+
+        @Nonnull
+        @Override
+        public Integer evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Integer> memberResults) {
+            return Collections.min(memberResults);
+        }
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/FieldWithComparisonCountProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/FieldWithComparisonCountProperty.java
index 172155b9ee..ae90471ac2 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/FieldWithComparisonCountProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/FieldWithComparisonCountProperty.java
@@ -26,14 +26,15 @@
 import com.apple.foundationdb.record.query.expressions.ComponentWithSingleChild;
 import com.apple.foundationdb.record.query.expressions.FieldWithComparison;
 import com.apple.foundationdb.record.query.expressions.QueryComponent;
-import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
-import com.apple.foundationdb.record.query.plan.plans.RecordQueryFilterPlan;
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
+import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.plans.RecordQueryFilterPlan;
 
 import javax.annotation.Nonnull;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * A property that counts the number of {@link FieldWithComparison}s that appear in a planner expression tree.
@@ -41,63 +42,77 @@
  * indexes.
  */
 @API(API.Status.EXPERIMENTAL)
-public class FieldWithComparisonCountProperty implements ExpressionProperty<Integer>, RelationalExpressionVisitorWithDefaults<Integer> {
-    private static final FieldWithComparisonCountProperty INSTANCE = new FieldWithComparisonCountProperty();
+public class FieldWithComparisonCountProperty implements ExpressionProperty<Integer> {
+    private static final FieldWithComparisonCountProperty FIELD_WITH_COMPARISON_COUNT =
+            new FieldWithComparisonCountProperty();
+
+    private FieldWithComparisonCountProperty() {
+        // prevent outside instantiation
+    }
 
     @Nonnull
     @Override
-    public Integer evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Integer> childResults) {
-        int total = 0;
-        if (expression instanceof RecordQueryFilterPlan) {
-            QueryComponent filter = ((RecordQueryFilterPlan)expression).getConjunctedFilter();
-            total = getFieldWithComparisonCount(filter);
-        }
+    public FieldWithComparisonCountVisitor createVisitor() {
+        return new FieldWithComparisonCountVisitor();
+    }
 
-        for (Integer childCount : childResults) {
-            if (childCount != null) {
-                total += childCount;
-            }
-        }
-        return total;
+    public int evaluate(@Nonnull final Reference ref) {
+        return Objects.requireNonNull(ref.acceptVisitor(createVisitor()));
     }
 
-    private static int getFieldWithComparisonCount(@Nonnull QueryComponent component) {
-        if (component instanceof FieldWithComparison)  {
-            return 1;
-        } else if (component instanceof ComponentWithNoChildren) {
-            return 0;
-        } else if (component instanceof ComponentWithSingleChild) {
-            return getFieldWithComparisonCount(((ComponentWithSingleChild)component).getChild());
-        } else if (component instanceof ComponentWithChildren) {
-            return ((ComponentWithChildren)component).getChildren().stream()
-                    .mapToInt(FieldWithComparisonCountProperty::getFieldWithComparisonCount)
-                    .sum();
-        } else {
-            throw new UnsupportedOperationException();
-        }
+    public int evaluate(@Nonnull final RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    @Override
-    public Integer evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Integer> memberResults) {
-        int min = Integer.MAX_VALUE;
-        for (int memberResult : memberResults) {
-            if (memberResult < min) {
-                min = memberResult;
+    public static FieldWithComparisonCountProperty fieldWithComparisonCount() {
+        return FIELD_WITH_COMPARISON_COUNT;
+    }
+
+    public static class FieldWithComparisonCountVisitor implements SimpleExpressionVisitor<Integer> {
+        @Nonnull
+        @Override
+        public Integer evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Integer> childResults) {
+            int total = 0;
+            if (expression instanceof RecordQueryFilterPlan) {
+                QueryComponent filter = ((RecordQueryFilterPlan)expression).getConjunctedFilter();
+                total = getFieldWithComparisonCount(filter);
+            }
+
+            for (Integer childCount : childResults) {
+                if (childCount != null) {
+                    total += childCount;
+                }
             }
+            return total;
         }
-        return min;
-    }
 
-    public static int evaluate(Reference ref) {
-        return ref.acceptPropertyVisitor(INSTANCE);
-    }
+        @Nonnull
+        @Override
+        public Integer evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Integer> memberResults) {
+            int min = Integer.MAX_VALUE;
+            for (int memberResult : memberResults) {
+                if (memberResult < min) {
+                    min = memberResult;
+                }
+            }
+            return min;
+        }
 
-    public static int evaluate(@Nonnull RelationalExpression expression) {
-        Integer result = expression.acceptPropertyVisitor(INSTANCE);
-        if (result == null) {
-            return Integer.MAX_VALUE;
+        private static int getFieldWithComparisonCount(@Nonnull QueryComponent component) {
+            if (component instanceof FieldWithComparison) {
+                return 1;
+            } else if (component instanceof ComponentWithNoChildren) {
+                return 0;
+            } else if (component instanceof ComponentWithSingleChild) {
+                return getFieldWithComparisonCount(((ComponentWithSingleChild)component).getChild());
+            } else if (component instanceof ComponentWithChildren) {
+                return ((ComponentWithChildren)component).getChildren().stream()
+                        .mapToInt(FieldWithComparisonCountVisitor::getFieldWithComparisonCount)
+                        .sum();
+            } else {
+                throw new UnsupportedOperationException();
+            }
         }
-        return result;
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/NormalizedResidualPredicateProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/NormalizedResidualPredicateProperty.java
index 2721bb5a72..ccf4565ec3 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/NormalizedResidualPredicateProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/NormalizedResidualPredicateProperty.java
@@ -23,8 +23,8 @@
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionWithPredicates;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.AndPredicate;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.OrPredicate;
@@ -49,59 +49,38 @@
  * filter factor. Note that such a number can always be computed without actually materializing the CNF.
  */
 @API(API.Status.EXPERIMENTAL)
-public class NormalizedResidualPredicateProperty implements ExpressionProperty<QueryPredicate>, RelationalExpressionVisitorWithDefaults<QueryPredicate> {
+public class NormalizedResidualPredicateProperty implements ExpressionProperty<QueryPredicate> {
     @Nonnull
-    private static final NormalizedResidualPredicateProperty INSTANCE = new NormalizedResidualPredicateProperty();
+    private static final NormalizedResidualPredicateProperty NORMALIZED_RESIDUAL_PREDICATE =
+            new NormalizedResidualPredicateProperty();
 
-    @Nonnull
-    @Override
-    public QueryPredicate visitRecordQueryUnionOnValuesPlan(@Nonnull final RecordQueryUnionOnValuesPlan unionPlan) {
-        final var predicatesFromQuantifiers = visitQuantifiers(unionPlan).stream()
-                .filter(Objects::nonNull)
-                .filter(predicate -> !predicate.isTautology())
-                .collect(ImmutableList.toImmutableList());
-        return OrPredicate.orOrTrue(predicatesFromQuantifiers);
+    private NormalizedResidualPredicateProperty() {
+        // prevent outside instantiation
     }
 
     @Nonnull
     @Override
-    public QueryPredicate evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<QueryPredicate> childResults) {
-        final var resultPredicatesBuilder = ImmutableList.<QueryPredicate>builder();
-
-        childResults.stream()
-                .filter(Objects::nonNull)
-                .filter(predicate -> !predicate.isTautology())
-                .forEach(resultPredicatesBuilder::add);
-
-        if (expression instanceof RelationalExpressionWithPredicates) {
-            ((RelationalExpressionWithPredicates)expression).getPredicates()
-                    .stream()
-                    .filter(predicate -> !predicate.isTautology())
-                    .forEach(resultPredicatesBuilder::add);
-        }
-
-        return AndPredicate.and(resultPredicatesBuilder.build());
+    public NormalizedResidualPredicateVisitor createVisitor() {
+        return new NormalizedResidualPredicateVisitor();
     }
 
     @Nonnull
-    @Override
-    public QueryPredicate evaluateAtRef(@Nonnull Reference ref, @Nonnull List<QueryPredicate> memberResults) {
-        Verify.verify(memberResults.size() == 1);
-        return Iterables.getOnlyElement(memberResults);
+    public QueryPredicate evaluate(@Nonnull final Reference reference) {
+        return Objects.requireNonNull(reference.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    public static QueryPredicate evaluate(Reference ref) {
-        return Verify.verifyNotNull(ref.acceptPropertyVisitor(INSTANCE));
+    public QueryPredicate evaluate(@Nonnull final RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    public static QueryPredicate evaluate(@Nonnull RelationalExpression expression) {
-        return Verify.verifyNotNull(expression.acceptPropertyVisitor(INSTANCE));
+    public static NormalizedResidualPredicateProperty normalizedResidualPredicate() {
+        return NORMALIZED_RESIDUAL_PREDICATE;
     }
 
     public static long countNormalizedConjuncts(@Nonnull RelationalExpression expression) {
-        final var magicPredicate = evaluate(expression);
+        final var magicPredicate = normalizedResidualPredicate().evaluate(expression);
         return magicPredicate.isTautology()
                ? 0
                : BooleanPredicateNormalizer
@@ -109,4 +88,44 @@ public static long countNormalizedConjuncts(@Nonnull RelationalExpression expres
                        .getMetrics(magicPredicate)
                        .getNormalFormFullSize();
     }
+
+    public static class NormalizedResidualPredicateVisitor implements SimpleExpressionVisitor<QueryPredicate> {
+        @Nonnull
+        @Override
+        public QueryPredicate visitRecordQueryUnionOnValuesPlan(@Nonnull final RecordQueryUnionOnValuesPlan unionPlan) {
+            final var predicatesFromQuantifiers = visitQuantifiers(unionPlan).stream()
+                    .filter(Objects::nonNull)
+                    .filter(predicate -> !predicate.isTautology())
+                    .collect(ImmutableList.toImmutableList());
+            return OrPredicate.orOrTrue(predicatesFromQuantifiers);
+        }
+
+        @Nonnull
+        @Override
+        public QueryPredicate evaluateAtExpression(@Nonnull final RelationalExpression expression,
+                                                   @Nonnull final List<QueryPredicate> childResults) {
+            final var resultPredicatesBuilder = ImmutableList.<QueryPredicate>builder();
+
+            childResults.stream()
+                    .filter(Objects::nonNull)
+                    .filter(predicate -> !predicate.isTautology())
+                    .forEach(resultPredicatesBuilder::add);
+
+            if (expression instanceof RelationalExpressionWithPredicates) {
+                ((RelationalExpressionWithPredicates)expression).getPredicates()
+                        .stream()
+                        .filter(predicate -> !predicate.isTautology())
+                        .forEach(resultPredicatesBuilder::add);
+            }
+            return AndPredicate.and(resultPredicatesBuilder.build());
+        }
+
+        @Nonnull
+        @Override
+        public QueryPredicate evaluateAtRef(@Nonnull final Reference ref,
+                                            @Nonnull final List<QueryPredicate> memberResults) {
+            Verify.verify(memberResults.size() == 1);
+            return Iterables.getOnlyElement(memberResults);
+        }
+    }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/OrderingProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/OrderingProperty.java
index 3e82785a1e..cf5d58553e 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/OrderingProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/OrderingProperty.java
@@ -26,15 +26,16 @@
 import com.apple.foundationdb.record.query.plan.bitmap.ComposedBitmapIndexQueryPlan;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
+import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Ordering;
 import com.apple.foundationdb.record.query.plan.cascades.Ordering.Binding;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart.ProvidedOrderingPart;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart.ProvidedSortOrder;
-import com.apple.foundationdb.record.query.plan.cascades.PlanProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.ValuePredicate;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.FieldValue;
@@ -100,17 +101,22 @@
 import java.util.stream.Stream;
 
 import static com.apple.foundationdb.record.Bindings.Internal.CORRELATION;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.CardinalitiesProperty.cardinalities;
 
 /**
  * A property used for the ordering(s) of a plan.
  */
-public class OrderingProperty implements PlanProperty<Ordering> {
-    public static final PlanProperty<Ordering> ORDERING = new OrderingProperty();
+public class OrderingProperty implements ExpressionProperty<Ordering> {
+    private static final OrderingProperty ORDERING = new OrderingProperty();
+
+    private OrderingProperty() {
+        // prevent outside instantiation
+    }
 
     @Nonnull
     @Override
-    public RecordQueryPlanVisitor<Ordering> createVisitor() {
-        return new OrderingVisitor();
+    public RelationalExpressionVisitor<Ordering> createVisitor() {
+        return ExpressionProperty.toExpressionVisitor(new OrderingVisitor());
     }
 
     @Override
@@ -118,6 +124,21 @@ public String toString() {
         return getClass().getSimpleName();
     }
 
+    @Nonnull
+    public Ordering evaluate(@Nonnull final Reference reference) {
+        return evaluate(reference.getAsPlan());
+    }
+
+    @Nonnull
+    public Ordering evaluate(@Nonnull final RecordQueryPlan recordQueryPlan) {
+        return createVisitor().visit(recordQueryPlan);
+    }
+
+    @Nonnull
+    public static OrderingProperty ordering() {
+        return ORDERING;
+    }
+
     /**
      * A property that determines the ordering of a {@link RecordQueryPlan}.
      */
@@ -512,7 +533,7 @@ public Ordering visitFlatMapPlan(@Nonnull final RecordQueryFlatMapPlan flatMapPl
             final var correlatedTo = flatMapPlan.getCorrelatedTo();
             final var resultValue = flatMapPlan.getResultValue();
 
-            final var outerCardinalities = CardinalitiesProperty.evaluate(flatMapPlan.getOuterQuantifier());
+            final var outerCardinalities = cardinalities().evaluate(flatMapPlan.getOuterQuantifier().getRangesOver());
             final var outerMaxCardinality = outerCardinalities.getMaxCardinality();
             if (!outerMaxCardinality.isUnknown() && outerMaxCardinality.getCardinality() == 1L) {
                 // outer max cardinality is proven to be 1 row
@@ -687,7 +708,7 @@ private List<Ordering> orderingsFromChildren(@Nonnull final RelationalExpression
         @Nonnull
         private Ordering evaluateForReference(@Nonnull Reference reference) {
             final var memberOrderings =
-                    reference.getPlannerAttributeForMembers(ORDERING).values();
+                    reference.getProperty(ORDERING).values();
             final var allAreDistinct =
                     memberOrderings
                             .stream()
@@ -702,9 +723,5 @@ public static <O extends Ordering.SetOperationsOrdering> Ordering deriveForDisti
             final var mergedOrdering = Ordering.merge(orderings, mergeOperator, (left, right) -> true);
             return mergedOrdering.applyComparisonKey(comparisonKeyOrderingParts);
         }
-
-        public static Ordering evaluate(@Nonnull RecordQueryPlan recordQueryPlan) {
-            return new OrderingVisitor().visit(recordQueryPlan);
-        }
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/PrimaryKeyProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/PrimaryKeyProperty.java
index cd714cfb76..57d615f797 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/PrimaryKeyProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/PrimaryKeyProperty.java
@@ -22,12 +22,13 @@
 
 import com.apple.foundationdb.record.RecordCoreException;
 import com.apple.foundationdb.record.query.plan.bitmap.ComposedBitmapIndexQueryPlan;
+import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.PlanProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.ScalarTranslationVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.WithPrimaryKeyMatchCandidate;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryAggregateIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryComparatorPlan;
@@ -89,13 +90,17 @@
  * This property is used by e.g. the implementation of set plans (e.g. distinct unions, intersections) to understand
  * if a stream of records originates from the same source (i.e. table) or not.
  */
-public class PrimaryKeyProperty implements PlanProperty<Optional<List<Value>>> {
-    public static final PlanProperty<Optional<List<Value>>> PRIMARY_KEY = new PrimaryKeyProperty();
+public class PrimaryKeyProperty implements ExpressionProperty<Optional<List<Value>>> {
+    private static final PrimaryKeyProperty PRIMARY_KEY = new PrimaryKeyProperty();
+
+    private PrimaryKeyProperty() {
+        // prevent outside instantiation
+    }
 
     @Nonnull
     @Override
-    public RecordQueryPlanVisitor<Optional<List<Value>>> createVisitor() {
-        return new PrimaryKeyVisitor();
+    public RelationalExpressionVisitor<Optional<List<Value>>> createVisitor() {
+        return ExpressionProperty.toExpressionVisitor(new PrimaryKeyVisitor());
     }
 
     @Override
@@ -103,6 +108,45 @@ public String toString() {
         return getClass().getSimpleName();
     }
 
+    @Nonnull
+    public Optional<List<Value>> evaluate(@Nonnull final Reference reference) {
+        return evaluate(reference.getAsPlan());
+    }
+
+    @Nonnull
+    public Optional<List<Value>> evaluate(@Nonnull final RecordQueryPlan recordQueryPlan) {
+        return createVisitor().visit(recordQueryPlan);
+    }
+
+    @Nonnull
+    public static PrimaryKeyProperty primaryKey() {
+        return PRIMARY_KEY;
+    }
+
+    @Nonnull
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    public static Optional<List<Value>> commonPrimaryKeyValuesMaybeFromOptionals(@Nonnull Iterable<Optional<List<Value>>> primaryKeyOptionals) {
+        if (Streams.stream(primaryKeyOptionals).anyMatch(Optional::isEmpty)) {
+            return Optional.empty();
+        }
+        return commonPrimaryKeyMaybe(Streams.stream(primaryKeyOptionals).map(Optional::get).collect(ImmutableList.toImmutableList()));
+    }
+
+    @Nonnull
+    private static Optional<List<Value>> commonPrimaryKeyMaybe(@Nonnull Iterable<List<Value>> primaryKeys) {
+        List<Value> common = null;
+        var first = true;
+        for (final var primaryKey : primaryKeys) {
+            if (first) {
+                common = primaryKey;
+                first = false;
+            } else if (!common.equals(primaryKey)) {
+                return Optional.empty();
+            }
+        }
+        return Optional.ofNullable(common);
+    }
+
     /**
      * Planner property which indicates if the record flowed as the result of a
      * {@link RecordQueryPlan} flows things stored records flow,
@@ -412,38 +456,9 @@ private Optional<List<Value>> commonPrimaryKeyFromChildren(@Nonnull final Record
 
         private Optional<List<Value>> evaluateForReference(@Nonnull Reference reference) {
             final var memberPrimaryKeysCollection =
-                    reference.getPlannerAttributeForMembers(PRIMARY_KEY).values();
+                    reference.getProperty(PRIMARY_KEY).values();
 
             return commonPrimaryKeyValuesMaybeFromOptionals(memberPrimaryKeysCollection);
         }
-
-        public static Optional<List<Value>> evaluate(@Nonnull RecordQueryPlan recordQueryPlan) {
-            // Won't actually be null for relational planner expressions.
-            return new PrimaryKeyVisitor().visit(recordQueryPlan);
-        }
-    }
-
-    @Nonnull
-    @SuppressWarnings("OptionalGetWithoutIsPresent")
-    public static Optional<List<Value>> commonPrimaryKeyValuesMaybeFromOptionals(@Nonnull Iterable<Optional<List<Value>>> primaryKeyOptionals) {
-        if (Streams.stream(primaryKeyOptionals).anyMatch(Optional::isEmpty)) {
-            return Optional.empty();
-        }
-        return commonPrimaryKeyMaybe(Streams.stream(primaryKeyOptionals).map(Optional::get).collect(ImmutableList.toImmutableList()));
-    }
-
-    @Nonnull
-    private static Optional<List<Value>> commonPrimaryKeyMaybe(@Nonnull Iterable<List<Value>> primaryKeys) {
-        List<Value> common = null;
-        var first = true;
-        for (final var primaryKey : primaryKeys) {
-            if (first) {
-                common = primaryKey;
-                first = false;
-            } else if (!common.equals(primaryKey)) {
-                return Optional.empty();
-            }
-        }
-        return Optional.ofNullable(common);
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/RecordTypesProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/RecordTypesProperty.java
index bc40fdbcf0..7f2dc21628 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/RecordTypesProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/RecordTypesProperty.java
@@ -24,16 +24,16 @@
 import com.apple.foundationdb.record.RecordCoreException;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
-import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.MatchCandidate;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifiers.AliasResolver;
+import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.FullUnorderedScanExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalUnionExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.PrimaryScanExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RecursiveUnionExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.SelectExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.TypeFilterExpression;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIndexPlan;
@@ -57,115 +57,133 @@
  */
 @API(API.Status.EXPERIMENTAL)
 @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
-public class RecordTypesProperty implements ExpressionProperty<Set<String>>, RelationalExpressionVisitorWithDefaults<Set<String>> {
-    @Nonnull
-    private final Optional<AliasResolver> aliasResolverOptional;
+public class RecordTypesProperty implements ExpressionProperty<Set<String>> {
+    private static final RecordTypesProperty RECORD_TYPES = new RecordTypesProperty();
 
-    private RecordTypesProperty(@Nonnull Optional<AliasResolver> aliasResolverOptional) {
-        this.aliasResolverOptional = aliasResolverOptional;
+    private RecordTypesProperty() {
+        // prevent outside instantiation
     }
 
     @Nonnull
     @Override
-    public Set<String> evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Set<String>> childResults) {
-        // shouldVisit() ensures that we only visit relational planner expressions
-        // If we mess this up, better to find out sooner rather than later.
-
-        if (expression instanceof RecordQueryScanPlan) {
-            final var recordTypesFromExpression = ((RecordQueryScanPlan)expression).getRecordTypes();
-            return recordTypesFromExpression == null ? ImmutableSet.of() : recordTypesFromExpression;
-        } else if (expression instanceof FullUnorderedScanExpression) {
-            return ((FullUnorderedScanExpression)expression).getRecordTypes();
-        } else if (expression instanceof RecordQueryIndexPlan) {
-            return ((RecordQueryIndexPlan)expression).getMatchCandidateMaybe()
-                    .map(MatchCandidate::getQueriedRecordTypeNames)
-                    .orElse(ImmutableSet.of());
-        } else if (expression instanceof TypeFilterExpression) {
-            return Sets.filter(childResults.get(0), ((TypeFilterExpression)expression).getRecordTypes()::contains);
-        } else if (expression instanceof PrimaryScanExpression) {
-            return ((PrimaryScanExpression)expression).getRecordTypes();
-        } else if (childResults.isEmpty()) {
-            // try to see if the leaf expression is correlated and follow up the correlations
-            final Set<String> recordTypes = Sets.newHashSet();
-            for (final CorrelationIdentifier alias : expression.getCorrelatedTo()) {
-                final Set<Quantifier> quantifiers = aliasResolverOptional
-                        .map(aliasResolver -> aliasResolver.resolveCorrelationAlias(expression, alias))
-                        .orElse(ImmutableSet.of());
-                for (final Quantifier quantifier : quantifiers) {
-                    recordTypes.addAll(Objects.requireNonNull(quantifier.getRangesOver().acceptPropertyVisitor(this)));
-                }
-            }
-
-            //
-            // If we use an alias resolver we should find where the correlations come from, if not, everything is
-            // best-effort.
-            //
-            if (aliasResolverOptional.isPresent() && recordTypes.isEmpty()) {
-                throw new RecordCoreException("tried to find record types for a relational expression with no children but case wasn't handled");
-            }
-            return recordTypes;
-        } else {
-            int nonNullChildResult = 0;
-            Set<String> firstChildResult = null;
-            for (Set<String> result : childResults) {
-                if (result != null) {
-                    nonNullChildResult++;
-                    if (firstChildResult == null) {
-                        firstChildResult = result;
-                    }
-                }
-            }
-
-            if (nonNullChildResult == 1) {
-                return firstChildResult;
-            } else  {
-                // If we have a single child, then there is a reasonable default for how most relational expressions will
-                // change the set of record types (i.e., they won't change them at all). However, if you have several relational
-                // children (like a union or intersection expression) then we must specify some way to combine them.
-                if (expression instanceof RecordQueryUnionPlan ||
-                        expression instanceof RecordQueryUnorderedUnionPlan ||
-                        expression instanceof RecordQueryIntersectionPlan ||
-                        expression instanceof LogicalUnionExpression ||
-                        expression instanceof RecursiveUnionExpression ||
-                        expression instanceof SelectExpression) {
-                    final Set<String> union = new HashSet<>();
-                    for (Set<String> childResulSet : childResults) {
-                        union.addAll(childResulSet);
-                    }
-                    return union;
-                } else {
-                    throw new RecordCoreException("tried to find record types for a relational expression with multiple " +
-                                                  "relational children, but no combiner was specified");
-                }
-            }
-        }
+    public RecordTypesVisitor createVisitor() {
+        return new RecordTypesVisitor(Optional.empty());
     }
 
-    @Nonnull
     @Override
-    public Set<String> evaluateAtRef(@Nonnull Reference ref,
-                                     @Nonnull List<Set<String>> memberResults) {
-        final Set<String> union = new HashSet<>();
-        for (Set<String> resultSet : memberResults) {
-            union.addAll(resultSet);
-        }
-        return union;
+    public String toString() {
+        return getClass().getSimpleName();
     }
 
     @Nonnull
-    public static Set<String> evaluate(@Nonnull Reference ref) {
-        return Objects.requireNonNull(ref.acceptPropertyVisitor(new RecordTypesProperty(Optional.empty())));
+    public Set<String> evaluate(@Nonnull Reference reference) {
+        return Objects.requireNonNull(reference.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    public static Set<String> evaluate(@Nonnull AliasResolver aliasResolver,
-                                       @Nonnull Reference ref) {
-        return Objects.requireNonNull(ref.acceptPropertyVisitor(new RecordTypesProperty(Optional.of(aliasResolver))));
+    public Set<String> evaluate(@Nonnull final RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    public static Set<String> evaluate(@Nonnull AliasResolver aliasResolver,
-                                       @Nonnull RelationalExpression ref) {
-        return Objects.requireNonNull(ref.acceptPropertyVisitor(new RecordTypesProperty(Optional.of(aliasResolver))));
+    public static RecordTypesProperty recordTypes() {
+        return RECORD_TYPES;
+    }
+
+    public static class RecordTypesVisitor implements SimpleExpressionVisitor<Set<String>> {
+        @Nonnull
+        private final Optional<AliasResolver> aliasResolverOptional;
+
+        public RecordTypesVisitor(@Nonnull final AliasResolver aliasResolver) {
+            this(Optional.of(aliasResolver));
+        }
+
+        public RecordTypesVisitor(@Nonnull final Optional<AliasResolver> aliasResolverOptional) {
+            this.aliasResolverOptional = aliasResolverOptional;
+        }
+
+        @Nonnull
+        @Override
+        public Set<String> evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Set<String>> childResults) {
+            if (expression instanceof RecordQueryScanPlan) {
+                final var recordTypesFromExpression = ((RecordQueryScanPlan)expression).getRecordTypes();
+                return recordTypesFromExpression == null ? ImmutableSet.of() : recordTypesFromExpression;
+            } else if (expression instanceof FullUnorderedScanExpression) {
+                return ((FullUnorderedScanExpression)expression).getRecordTypes();
+            } else if (expression instanceof RecordQueryIndexPlan) {
+                return ((RecordQueryIndexPlan)expression).getMatchCandidateMaybe()
+                        .map(MatchCandidate::getQueriedRecordTypeNames)
+                        .orElse(ImmutableSet.of());
+            } else if (expression instanceof TypeFilterExpression) {
+                return Sets.filter(childResults.get(0), ((TypeFilterExpression)expression).getRecordTypes()::contains);
+            } else if (expression instanceof PrimaryScanExpression) {
+                return ((PrimaryScanExpression)expression).getRecordTypes();
+            } else if (childResults.isEmpty()) {
+                // try to see if the leaf expression is correlated and follow up the correlations
+                final Set<String> recordTypes = Sets.newHashSet();
+                for (final CorrelationIdentifier alias : expression.getCorrelatedTo()) {
+                    final Set<Quantifier> quantifiers = aliasResolverOptional
+                            .map(aliasResolver -> aliasResolver.resolveCorrelationAlias(expression, alias))
+                            .orElse(ImmutableSet.of());
+                    for (final Quantifier quantifier : quantifiers) {
+                        recordTypes.addAll(Objects.requireNonNull(quantifier.getRangesOver().acceptVisitor(this)));
+                    }
+                }
+
+                //
+                // If we use an alias resolver we should find where the correlations come from, if not, everything is
+                // best-effort.
+                //
+                if (aliasResolverOptional.isPresent() && recordTypes.isEmpty()) {
+                    throw new RecordCoreException("tried to find record types for a relational expression with no children but case wasn't handled");
+                }
+                return recordTypes;
+            } else {
+                int nonNullChildResult = 0;
+                Set<String> firstChildResult = null;
+                for (Set<String> result : childResults) {
+                    if (result != null) {
+                        nonNullChildResult++;
+                        if (firstChildResult == null) {
+                            firstChildResult = result;
+                        }
+                    }
+                }
+
+                if (nonNullChildResult == 1) {
+                    return firstChildResult;
+                } else {
+                    // If we have a single child, then there is a reasonable default for how most relational expressions will
+                    // change the set of record types (i.e., they won't change them at all). However, if you have several relational
+                    // children (like a union or intersection expression) then we must specify some way to combine them.
+                    if (expression instanceof RecordQueryUnionPlan ||
+                            expression instanceof RecordQueryUnorderedUnionPlan ||
+                            expression instanceof RecordQueryIntersectionPlan ||
+                            expression instanceof LogicalUnionExpression ||
+                            expression instanceof RecursiveUnionExpression ||
+                            expression instanceof SelectExpression) {
+                        final Set<String> union = new HashSet<>();
+                        for (Set<String> childResulSet : childResults) {
+                            union.addAll(childResulSet);
+                        }
+                        return union;
+                    } else {
+                        throw new RecordCoreException("tried to find record types for a relational expression with multiple " +
+                                "relational children, but no combiner was specified");
+                    }
+                }
+            }
+        }
+
+        @Nonnull
+        @Override
+        public Set<String> evaluateAtRef(@Nonnull Reference ref,
+                                         @Nonnull List<Set<String>> memberResults) {
+            final Set<String> union = new HashSet<>();
+            for (Set<String> resultSet : memberResults) {
+                union.addAll(resultSet);
+            }
+            return union;
+        }
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ReferencesAndDependenciesProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ReferencesAndDependenciesProperty.java
index 643ddb8fd3..09543aa3ae 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ReferencesAndDependenciesProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/ReferencesAndDependenciesProperty.java
@@ -23,56 +23,61 @@
 import com.apple.foundationdb.record.query.combinatorics.PartiallyOrderedSet;
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSetMultimap;
 import com.google.common.collect.Streams;
 
 import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
 import java.util.List;
 import java.util.Objects;
 
 /**
  * This property establishes a partial order over the expressions contained in a subgraph.
  */
-public class ReferencesAndDependenciesProperty implements ExpressionProperty<PartiallyOrderedSet<Reference>>, RelationalExpressionVisitorWithDefaults<PartiallyOrderedSet<Reference>> {
+public class ReferencesAndDependenciesProperty implements ExpressionProperty<PartiallyOrderedSet<Reference>> {
+    private static final ReferencesAndDependenciesProperty REFERENCES_AND_DEPENDENCIES =
+            new ReferencesAndDependenciesProperty();
 
-    @Nonnull
-    @Override
-    public PartiallyOrderedSet<Reference> evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<PartiallyOrderedSet<Reference>> childResults) {
-        return mergePartialOrders(childResults);
+    private ReferencesAndDependenciesProperty() {
+        // prevent outside instantiation
     }
 
-    @SuppressWarnings("UnstableApiUsage")
     @Nonnull
     @Override
-    public PartiallyOrderedSet<Reference> evaluateAtRef(@Nonnull Reference ref, @Nonnull List<PartiallyOrderedSet<Reference>> memberResults) {
-        final var membersPartialOrder = mergePartialOrders(memberResults);
+    public ReferencesAndDependenciesVisitor createVisitor() {
+        return new ReferencesAndDependenciesVisitor();
+    }
 
-        final var membersSet = membersPartialOrder.getSet();
-        final var membersDependencyMap = membersPartialOrder.getDependencyMap();
+    @Nonnull
+    public PartiallyOrderedSet<Reference> evaluate(@Nonnull Iterable<? extends Reference> references) {
+        final var refResults =
+                Streams.stream(references)
+                        .map(this::evaluate)
+                        .collect(ImmutableList.toImmutableList());
 
-        final var setBuilder = ImmutableSet.<Reference>builder();
-        final var dependencyMapBuilder = ImmutableSetMultimap.<Reference, Reference>builder();
+        return mergePartialOrders(refResults);
+    }
 
-        setBuilder.addAll(membersSet);
-        setBuilder.add(ref);
-        dependencyMapBuilder.putAll(membersDependencyMap.entries());
+    @Nonnull
+    public PartiallyOrderedSet<Reference> evaluate(@Nonnull Reference reference) {
+        return Objects.requireNonNull(reference.acceptVisitor(createVisitor()));
+    }
 
-        for (final var member : ref.getMembers()) {
-            for (final var quantifier : member.getQuantifiers()) {
-                dependencyMapBuilder.put(ref, quantifier.getRangesOver());
-            }
-        }
+    @Nonnull
+    public PartiallyOrderedSet<Reference> evaluate(@Nonnull RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
+    }
 
-        return PartiallyOrderedSet.of(setBuilder.build(), dependencyMapBuilder.build());
+    @Nonnull
+    public static ReferencesAndDependenciesProperty referencesAndDependencies() {
+        return REFERENCES_AND_DEPENDENCIES;
     }
 
-    @SuppressWarnings("UnstableApiUsage")
-    private PartiallyOrderedSet<Reference> mergePartialOrders(@Nonnull Iterable<PartiallyOrderedSet<Reference>> partialOrders) {
+    @Nonnull
+    private static PartiallyOrderedSet<Reference> mergePartialOrders(@Nonnull final Iterable<PartiallyOrderedSet<Reference>> partialOrders) {
         final var setBuilder = ImmutableSet.<Reference>builder();
         final var dependencyMapBuilder = ImmutableSetMultimap.<Reference, Reference>builder();
 
@@ -84,20 +89,35 @@ private PartiallyOrderedSet<Reference> mergePartialOrders(@Nonnull Iterable<Part
         return PartiallyOrderedSet.of(setBuilder.build(), dependencyMapBuilder.build());
     }
 
-    @Nonnull
-    public static PartiallyOrderedSet<Reference> evaluate(@Nonnull Reference ref) {
-        @Nullable final var nullableResult =
-                ref.acceptPropertyVisitor(new ReferencesAndDependenciesProperty());
-        return Objects.requireNonNull(nullableResult);
-    }
+    public static class ReferencesAndDependenciesVisitor implements SimpleExpressionVisitor<PartiallyOrderedSet<Reference>> {
+        @Nonnull
+        @Override
+        public PartiallyOrderedSet<Reference> evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<PartiallyOrderedSet<Reference>> childResults) {
+            return mergePartialOrders(childResults);
+        }
 
-    @Nonnull
-    public static PartiallyOrderedSet<Reference> evaluate(@Nonnull Iterable<? extends Reference> refs) {
-        final var property = new ReferencesAndDependenciesProperty();
-        final var refResults = Streams.stream(refs)
-                .map(ref -> Objects.requireNonNull(ref.acceptPropertyVisitor(property)))
-                .collect(ImmutableList.toImmutableList());
+        @Nonnull
+        @Override
+        public PartiallyOrderedSet<Reference> evaluateAtRef(@Nonnull Reference ref, @Nonnull List<PartiallyOrderedSet<Reference>> memberResults) {
+            final var membersPartialOrder = mergePartialOrders(memberResults);
 
-        return property.mergePartialOrders(refResults);
+            final var membersSet = membersPartialOrder.getSet();
+            final var membersDependencyMap = membersPartialOrder.getDependencyMap();
+
+            final var setBuilder = ImmutableSet.<Reference>builder();
+            final var dependencyMapBuilder = ImmutableSetMultimap.<Reference, Reference>builder();
+
+            setBuilder.addAll(membersSet);
+            setBuilder.add(ref);
+            dependencyMapBuilder.putAll(membersDependencyMap.entries());
+
+            for (final var member : ref.getMembers()) {
+                for (final var quantifier : member.getQuantifiers()) {
+                    dependencyMapBuilder.put(ref, quantifier.getRangesOver());
+                }
+            }
+
+            return PartiallyOrderedSet.of(setBuilder.build(), dependencyMapBuilder.build());
+        }
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/StoredRecordProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/StoredRecordProperty.java
index 8a82cd5b34..55524082ec 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/StoredRecordProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/StoredRecordProperty.java
@@ -22,10 +22,11 @@
 
 import com.apple.foundationdb.record.RecordCoreException;
 import com.apple.foundationdb.record.query.plan.bitmap.ComposedBitmapIndexQueryPlan;
+import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
-import com.apple.foundationdb.record.query.plan.cascades.PlanProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryAggregateIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryComparatorPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryCoveringIndexPlan;
@@ -82,13 +83,17 @@
  * represent records that reside stored on disk and were retrieved by this query. This is opposite of truly computed
  * records which do not such data associated with them (such as primary key information and/or similar).
  */
-public class StoredRecordProperty implements PlanProperty<Boolean> {
-    public static final PlanProperty<Boolean> STORED_RECORD = new StoredRecordProperty();
+public class StoredRecordProperty implements ExpressionProperty<Boolean> {
+    private static final StoredRecordProperty STORED_RECORD = new StoredRecordProperty();
+
+    private StoredRecordProperty() {
+        // prevent outside instantiation
+    }
 
     @Nonnull
     @Override
-    public RecordQueryPlanVisitor<Boolean> createVisitor() {
-        return new StoredRecordVisitor();
+    public RelationalExpressionVisitor<Boolean> createVisitor() {
+        return ExpressionProperty.toExpressionVisitor(new StoredRecordVisitor());
     }
 
     @Override
@@ -96,6 +101,19 @@ public String toString() {
         return getClass().getSimpleName();
     }
 
+    public boolean evaluate(@Nonnull final Reference reference) {
+        return evaluate(reference.getAsPlan());
+    }
+
+    public boolean evaluate(@Nonnull final RecordQueryPlan recordQueryPlan) {
+        return createVisitor().visit(recordQueryPlan);
+    }
+
+    @Nonnull
+    public static StoredRecordProperty storedRecord() {
+        return STORED_RECORD;
+    }
+
     /**
      * Planner property which indicates if the record flowed as the result of a
      * {@link com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan} flows things stored records flow,
@@ -395,16 +413,11 @@ private List<Boolean> storedRecordsFromChildren(@Nonnull final RelationalExpress
 
         private boolean evaluateForReference(@Nonnull Reference reference) {
             final var memberStoredRecordsCollection =
-                    reference.getPlannerAttributeForMembers(STORED_RECORD).values();
+                    reference.getProperty(STORED_RECORD).values();
 
             return memberStoredRecordsCollection
                     .stream()
                     .allMatch(d -> d);
         }
-
-        public static boolean evaluate(@Nonnull RecordQueryPlan recordQueryPlan) {
-            // Won't actually be null for relational planner expressions.
-            return new StoredRecordVisitor().visit(recordQueryPlan);
-        }
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/TypeFilterCountProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/TypeFilterCountProperty.java
index 42d0e98ee8..00d70090cc 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/TypeFilterCountProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/TypeFilterCountProperty.java
@@ -22,12 +22,13 @@
 
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.TypeFilterExpression;
 
 import javax.annotation.Nonnull;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * A property that determines the sum, over all elements of a {@code PlannerExpression} tree, of the number of record
@@ -41,39 +42,56 @@
  * are aggressively pruned by the planner.
  * </p>
  */
-public class TypeFilterCountProperty implements ExpressionProperty<Integer>, RelationalExpressionVisitorWithDefaults<Integer> {
-    private static final TypeFilterCountProperty INSTANCE = new TypeFilterCountProperty();
+public class TypeFilterCountProperty implements ExpressionProperty<Integer> {
+    private static final TypeFilterCountProperty TYPE_FILTER_COUNT = new TypeFilterCountProperty();
+
+    private TypeFilterCountProperty() {
+        // prevent outside instantiation
+    }
 
     @Nonnull
     @Override
-    public Integer evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Integer> childResults) {
-        int total = expression instanceof TypeFilterExpression ?
-                    ((TypeFilterExpression)expression).getRecordTypes().size() : 0;
-        for (Integer childCount : childResults) {
-            if (childCount != null) {
-                total += childCount;
-            }
-        }
-        return total;
+    public TypeFilterCountVisitor createVisitor() {
+        return new TypeFilterCountVisitor();
+    }
+
+    public int evaluate(@Nonnull final Reference reference) {
+        return Objects.requireNonNull(reference.acceptVisitor(createVisitor()));
+    }
+
+    public int evaluate(@Nonnull final RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    @Override
-    public Integer evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Integer> memberResults) {
-        int min = Integer.MAX_VALUE;
-        for (int memberResult : memberResults) {
-            if (memberResult < min) {
-                min = memberResult;
+    public static TypeFilterCountProperty typeFilterCount() {
+        return TYPE_FILTER_COUNT;
+    }
+
+    public static class TypeFilterCountVisitor implements SimpleExpressionVisitor<Integer> {
+        @Nonnull
+        @Override
+        public Integer evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Integer> childResults) {
+            int total = expression instanceof TypeFilterExpression ?
+                        ((TypeFilterExpression)expression).getRecordTypes().size() : 0;
+            for (Integer childCount : childResults) {
+                if (childCount != null) {
+                    total += childCount;
+                }
             }
+            return total;
         }
-        return min;
-    }
 
-    public static int evaluate(@Nonnull RelationalExpression expression) {
-        Integer result = expression.acceptPropertyVisitor(INSTANCE);
-        if (result == null) {
-            return 0;
+        @Nonnull
+        @Override
+        public Integer evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Integer> memberResults) {
+            int min = Integer.MAX_VALUE;
+            for (int memberResult : memberResults) {
+                if (memberResult < min) {
+                    min = memberResult;
+                }
+            }
+            return min;
         }
-        return result;
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/UnmatchedFieldsCountProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/UnmatchedFieldsCountProperty.java
index 32b7d118f0..dff7789863 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/UnmatchedFieldsCountProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/UnmatchedFieldsCountProperty.java
@@ -26,8 +26,8 @@
 import com.apple.foundationdb.record.query.plan.ScanComparisons;
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryAggregateIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryCoveringIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlanWithComparisons;
@@ -56,63 +56,82 @@
  * The {@code UnmatchedFieldsCountProperty} on such a planner expression is 2.
  */
 @API(API.Status.EXPERIMENTAL)
-public class UnmatchedFieldsCountProperty implements ExpressionProperty<Integer>, RelationalExpressionVisitorWithDefaults<Integer> {
+public class UnmatchedFieldsCountProperty implements ExpressionProperty<Integer> {
+    private static final UnmatchedFieldsCountProperty UNMATCHED_FIELDS_COUNT = new UnmatchedFieldsCountProperty();
+
+    private UnmatchedFieldsCountProperty() {
+        // prevent outside instantiation
+    }
+
     @Nonnull
     @Override
-    public Integer evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Integer> childResults) {
-        int total = 0;
-        for (Integer result : childResults) {
-            if (result != null) {
-                total += result;
-            }
-        }
+    public UnmatchedFieldsCountVisitor createVisitor() {
+        return new UnmatchedFieldsCountVisitor();
+    }
 
-        if (expression instanceof RecordQueryCoveringIndexPlan) {
-            expression = ((RecordQueryCoveringIndexPlan)expression).getIndexPlan();
-        }
-        if (expression instanceof RecordQueryAggregateIndexPlan) {
-            expression = ((RecordQueryAggregateIndexPlan)expression).getIndexPlan();
-        }
+    public int evaluate(@Nonnull final Reference reference) {
+        return Objects.requireNonNull(reference.acceptVisitor(createVisitor()));
+    }
 
-        final int columnSize;
-        if (expression instanceof RecordQueryPlanWithComparisons) {
-            final ScanComparisons comparisons = ((RecordQueryPlanWithComparisons)expression).getScanComparisons();
-            final int numComparisons = comparisons.getEqualitySize() + (comparisons.isEquality() ? 0 : 1);
-            if (expression instanceof RecordQueryPlanWithIndex) {
-                final var matchCandidateOptional =
-                        ((RecordQueryPlanWithIndex)expression).getMatchCandidateMaybe();
-                final var matchCandidate = matchCandidateOptional.orElseThrow(() -> new RecordCoreException("expected match candidate to be present"));
-                columnSize = matchCandidate.getSargableAliases().size();
-            } else if (expression instanceof RecordQueryScanPlan) {
-                final RecordQueryScanPlan scanPlan = (RecordQueryScanPlan)expression;
-                final KeyExpression primaryKey = Objects.requireNonNull(scanPlan.getCommonPrimaryKey());
-                columnSize = primaryKey.getColumnSize();
-            } else {
-                throw new RecordCoreException("unhandled plan with comparisons: can't find key expression");
-            }
-            return total + columnSize - numComparisons;
-        } else {
-            return total;
-        }
+    public int evaluate(@Nonnull final RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    @Override
-    public Integer evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Integer> memberResults) {
-        int min = Integer.MAX_VALUE;
-        for (Integer memberResult : memberResults) {
-            if (memberResult != null && memberResult < min) {
-                min = memberResult;
+    public static UnmatchedFieldsCountProperty unmatchedFieldsCount() {
+        return UNMATCHED_FIELDS_COUNT;
+    }
+
+    public static class UnmatchedFieldsCountVisitor implements SimpleExpressionVisitor<Integer> {
+        @Nonnull
+        @Override
+        public Integer evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Integer> childResults) {
+            int total = 0;
+            for (Integer result : childResults) {
+                if (result != null) {
+                    total += result;
+                }
+            }
+
+            if (expression instanceof RecordQueryCoveringIndexPlan) {
+                expression = ((RecordQueryCoveringIndexPlan)expression).getIndexPlan();
+            }
+            if (expression instanceof RecordQueryAggregateIndexPlan) {
+                expression = ((RecordQueryAggregateIndexPlan)expression).getIndexPlan();
+            }
+
+            final int columnSize;
+            if (expression instanceof RecordQueryPlanWithComparisons) {
+                final ScanComparisons comparisons = ((RecordQueryPlanWithComparisons)expression).getScanComparisons();
+                final int numComparisons = comparisons.getEqualitySize() + (comparisons.isEquality() ? 0 : 1);
+                if (expression instanceof RecordQueryPlanWithIndex) {
+                    final var matchCandidateOptional =
+                            ((RecordQueryPlanWithIndex)expression).getMatchCandidateMaybe();
+                    final var matchCandidate = matchCandidateOptional.orElseThrow(() -> new RecordCoreException("expected match candidate to be present"));
+                    columnSize = matchCandidate.getSargableAliases().size();
+                } else if (expression instanceof RecordQueryScanPlan) {
+                    final RecordQueryScanPlan scanPlan = (RecordQueryScanPlan)expression;
+                    final KeyExpression primaryKey = Objects.requireNonNull(scanPlan.getCommonPrimaryKey());
+                    columnSize = primaryKey.getColumnSize();
+                } else {
+                    throw new RecordCoreException("unhandled plan with comparisons: can't find key expression");
+                }
+                return total + columnSize - numComparisons;
+            } else {
+                return total;
             }
         }
-        return min;
-    }
 
-    public static int evaluate(@Nonnull RelationalExpression expression) {
-        Integer result = expression.acceptPropertyVisitor(new UnmatchedFieldsCountProperty());
-        if (result == null) {
-            return Integer.MAX_VALUE;
+        @Nonnull
+        @Override
+        public Integer evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Integer> memberResults) {
+            int min = Integer.MAX_VALUE;
+            for (Integer memberResult : memberResults) {
+                if (memberResult != null && memberResult < min) {
+                    min = memberResult;
+                }
+            }
+            return min;
         }
-        return result;
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/UsedTypesProperty.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/UsedTypesProperty.java
index f0bf4f2927..c9b3ef9f02 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/UsedTypesProperty.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/properties/UsedTypesProperty.java
@@ -23,60 +23,74 @@
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.query.plan.cascades.ExpressionProperty;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
+import com.apple.foundationdb.record.query.plan.cascades.SimpleExpressionVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionVisitorWithDefaults;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.google.common.collect.ImmutableSet;
 
 import javax.annotation.Nonnull;
 import java.util.Collection;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 
 /**
  * A property that computes the set of complex (dynamic) types that is used by the graph passed in.
  */
 @API(API.Status.EXPERIMENTAL)
-public class UsedTypesProperty implements ExpressionProperty<Set<Type>>, RelationalExpressionVisitorWithDefaults<Set<Type>> {
-    private static final UsedTypesProperty INSTANCE = new UsedTypesProperty();
+public class UsedTypesProperty implements ExpressionProperty<Set<Type>> {
+    private static final UsedTypesProperty USED_TYPES = new UsedTypesProperty();
+
+    private UsedTypesProperty() {
+        // prevent outside instantiation
+    }
 
     @Nonnull
     @Override
-    public Set<Type> evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Set<Type>> childResults) {
-        final ImmutableSet.Builder<Type> resultBuilder = ImmutableSet.builder();
-        for (final Set<Type> childResult : childResults) {
-            resultBuilder.addAll(childResult);
-        }
+    public UsedTypesVisitor createVisitor() {
+        return new UsedTypesVisitor();
+    }
 
-        resultBuilder.addAll(expression.getDynamicTypes());
+    public Set<Type> evaluate(@Nonnull final Reference ref) {
+        return Objects.requireNonNull(ref.acceptVisitor(createVisitor()));
+    }
 
-        return resultBuilder.build();
+    public Set<Type> evaluate(@Nonnull final RelationalExpression expression) {
+        return Objects.requireNonNull(expression.acceptVisitor(createVisitor()));
     }
 
     @Nonnull
-    @Override
-    public Set<Type> evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Set<Type>> memberResults) {
-        return unionTypes(memberResults);
+    public static UsedTypesProperty usedTypes() {
+        return USED_TYPES;
     }
 
-    @Nonnull
-    private static Set<Type> unionTypes(@Nonnull final Collection<Set<Type>> types) {
-        final ImmutableSet.Builder<Type> resultBuilder = ImmutableSet.builder();
-        for (final Set<Type> childResult : types) {
-            resultBuilder.addAll(childResult);
+    public static class UsedTypesVisitor implements SimpleExpressionVisitor<Set<Type>> {
+        @Nonnull
+        @Override
+        public Set<Type> evaluateAtExpression(@Nonnull RelationalExpression expression, @Nonnull List<Set<Type>> childResults) {
+            final ImmutableSet.Builder<Type> resultBuilder = ImmutableSet.builder();
+            for (final Set<Type> childResult : childResults) {
+                resultBuilder.addAll(childResult);
+            }
+
+            resultBuilder.addAll(expression.getDynamicTypes());
+
+            return resultBuilder.build();
         }
-        return resultBuilder.build();
-    }
 
-    public static Set<Type> evaluate(Reference ref) {
-        return ref.acceptPropertyVisitor(INSTANCE);
-    }
+        @Nonnull
+        @Override
+        public Set<Type> evaluateAtRef(@Nonnull Reference ref, @Nonnull List<Set<Type>> memberResults) {
+            return unionTypes(memberResults);
+        }
 
-    public static Set<Type> evaluate(@Nonnull RelationalExpression expression) {
-        final Set<Type> result = expression.acceptPropertyVisitor(INSTANCE);
-        if (result == null) {
-            return ImmutableSet.of();
+        @Nonnull
+        private static Set<Type> unionTypes(@Nonnull final Collection<Set<Type>> types) {
+            final ImmutableSet.Builder<Type> resultBuilder = ImmutableSet.builder();
+            for (final Set<Type> childResult : types) {
+                resultBuilder.addAll(childResult);
+            }
+            return resultBuilder.build();
         }
-        return result;
     }
 }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/AbstractDataAccessRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/AbstractDataAccessRule.java
index 93e4a0ffa3..78b19af479 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/AbstractDataAccessRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/AbstractDataAccessRule.java
@@ -52,7 +52,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.PrimaryScanExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
-import com.apple.foundationdb.record.query.plan.cascades.properties.CardinalitiesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.properties.CardinalitiesProperty.Cardinality;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIntersectionPlan;
@@ -83,6 +82,8 @@
 import java.util.Set;
 import java.util.function.Function;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.CardinalitiesProperty.cardinalities;
+
 /**
  * A rule that utilizes index matching information compiled by {@link CascadesPlanner} to create one or more
  * expressions for data access. While this rule delegates specifics to the {@link MatchCandidate}s, the following are
@@ -1008,7 +1009,7 @@ private static void addToIntersectionInfoMap(@Nonnull final Map<BitSet, Intersec
             intersectionInfoMap.put(cacheKey, IntersectionInfo.ofImpossibleAccess(orderingFromSingleMatchedAccess));
         } else {
             final var compensatedExpression = compensatedExpressionOptional.get();
-            final var cardinalities = CardinalitiesProperty.evaluate(compensatedExpression);
+            final var cardinalities = cardinalities().evaluate(compensatedExpression);
 
             intersectionInfoMap.put(cacheKey,
                     IntersectionInfo.ofSingleAccess(orderingFromSingleMatchedAccess, compensatedExpression,
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDeleteRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDeleteRule.java
index 3fd0712435..522b6a090d 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDeleteRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDeleteRule.java
@@ -29,17 +29,17 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.DeleteExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
 import com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryUnorderedPrimaryKeyDistinctPlan;
 
 import javax.annotation.Nonnull;
 
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.where;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.filterPartition;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.deleteExpression;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty.STORED_RECORD;
 
 /**
  * A rule that implements a {@link DeleteExpression} by creating
@@ -53,7 +53,7 @@ public class ImplementDeleteRule extends CascadesRule<DeleteExpression> {
 
     @Nonnull
     private static final BindingMatcher<Reference> innerReferenceMatcher =
-            planPartitions(where(planPartition -> planPartition.getAttributeValue(STORED_RECORD),
+            planPartitions(filterPartition(planPartition -> planPartition.getPropertyValue(StoredRecordProperty.storedRecord()),
                     any(innerPlanPartitionMatcher)));
 
     private static final BindingMatcher<Quantifier.ForEach> innerQuantifierMatcher =
@@ -77,7 +77,7 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
         final var planPartitionReference =
                 call.memoizeMemberPlans(innerReference, innerPlanPartition.getPlans());
         final var distinctPlansReference =
-                innerPlanPartition.getAttributeValue(DistinctRecordsProperty.DISTINCT_RECORDS)
+                innerPlanPartition.getPropertyValue(DistinctRecordsProperty.distinctRecords())
                 ? planPartitionReference
                 : call.memoizePlans(new RecordQueryUnorderedPrimaryKeyDistinctPlan(Quantifier.physical(planPartitionReference)));
 
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDistinctRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDistinctRule.java
index 076a962034..b4d92ea6d3 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDistinctRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDistinctRule.java
@@ -29,6 +29,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalDistinctExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
 import com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryUnorderedPrimaryKeyDistinctPlan;
 
@@ -37,11 +38,10 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ListMatcher.only;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.where;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.filterPartition;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.logicalDistinctExpression;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty.STORED_RECORD;
 
 /**
  * A rule that implements a distinct expression by adding a {@link RecordQueryUnorderedPrimaryKeyDistinctPlan}
@@ -65,7 +65,7 @@ public class ImplementDistinctRule extends CascadesRule<LogicalDistinctExpressio
 
     @Nonnull
     private static final BindingMatcher<Reference> innerReferenceMatcher =
-            planPartitions(where(planPartition -> planPartition.getAttributeValue(STORED_RECORD),
+            planPartitions(filterPartition(planPartition -> planPartition.getPropertyValue(StoredRecordProperty.storedRecord()),
                     any(innerPlanPartitionMatcher)));
 
     @Nonnull
@@ -81,7 +81,7 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
         final var innerPlanPartition = call.get(innerPlanPartitionMatcher);
         final var innerReference = call.get(innerReferenceMatcher);
 
-        if (innerPlanPartition.getAttributeValue(DistinctRecordsProperty.DISTINCT_RECORDS)) {
+        if (innerPlanPartition.getPropertyValue(DistinctRecordsProperty.distinctRecords())) {
             call.yieldExpression(innerPlanPartition.getPlans());
         } else {
             // these create duplicates
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDistinctUnionRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDistinctUnionRule.java
index cfb21349e8..63df6635b4 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDistinctUnionRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementDistinctUnionRule.java
@@ -35,7 +35,10 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalUnionExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.CollectionMatcher;
+import com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.OrderingProperty;
 import com.apple.foundationdb.record.query.plan.cascades.properties.PrimaryKeyProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQuerySetPlan;
@@ -49,21 +52,17 @@
 import javax.annotation.Nonnull;
 import java.util.List;
 
-import static com.apple.foundationdb.record.query.plan.cascades.PropertiesMap.allAttributesExcept;
+import static com.apple.foundationdb.record.query.plan.cascades.PlanPropertiesMap.allAttributesExcept;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ListMatcher.exactly;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.MultiMatcher.all;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifier;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.rollUpTo;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.where;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.rollUpPartitionsTo;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.filterPartition;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.logicalDistinctExpression;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.logicalUnionExpression;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty.DISTINCT_RECORDS;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.OrderingProperty.ORDERING;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.PrimaryKeyProperty.PRIMARY_KEY;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty.STORED_RECORD;
 
 /**
  * A rule that implements a distinct union of its (already implemented) children. This will extract the
@@ -79,9 +78,9 @@ public class ImplementDistinctUnionRule extends CascadesRule<LogicalDistinctExpr
 
     @Nonnull
     private static final BindingMatcher<Reference> unionLegReferenceMatcher =
-            planPartitions(where(planPartition -> planPartition.getAttributeValue(STORED_RECORD) &&
-                                                  planPartition.getAttributeValue(PRIMARY_KEY).isPresent(),
-                    rollUpTo(unionLegPlanPartitionsMatcher, allAttributesExcept(DISTINCT_RECORDS))));
+            planPartitions(filterPartition(planPartition -> planPartition.getPropertyValue(StoredRecordProperty.storedRecord()) &&
+                                                  planPartition.getPropertyValue(PrimaryKeyProperty.primaryKey()).isPresent(),
+                    rollUpPartitionsTo(unionLegPlanPartitionsMatcher, allAttributesExcept(DistinctRecordsProperty.distinctRecords()))));
 
     private static final CollectionMatcher<Quantifier.ForEach> allForEachQuantifiersMatcher =
             all(forEachQuantifierOverRef(unionLegReferenceMatcher));
@@ -151,7 +150,7 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
 
                 final var commonPrimaryKeyValuesMaybe =
                         PrimaryKeyProperty.commonPrimaryKeyValuesMaybeFromOptionals(partitions.stream()
-                                .map(partition -> partition.getAttributeValue(PRIMARY_KEY))
+                                .map(partition -> partition.getPropertyValue(PrimaryKeyProperty.primaryKey()))
                                 .collect(ImmutableList.toImmutableList()));
 
                 if (commonPrimaryKeyValuesMaybe.isEmpty()) {
@@ -162,7 +161,7 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
                 final ImmutableList<Ordering> orderings =
                         partitions
                                 .stream()
-                                .map(planPartition -> planPartition.getAttributeValue(ORDERING))
+                                .map(planPartition -> planPartition.getPropertyValue(OrderingProperty.ordering()))
                                 .collect(ImmutableList.toImmutableList());
                 pushInterestingOrders(call, unionForEachQuantifier, orderings, requestedOrdering);
 
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementFilterRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementFilterRule.java
index ffa2b709f4..2fcc443c87 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementFilterRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementFilterRule.java
@@ -41,8 +41,8 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.MultiMatcher.all;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QueryPredicateMatchers.anyPredicate;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.logicalFilterExpression;
 
 /**
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInJoinRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInJoinRule.java
index 86e57641ee..e4901aa64d 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInJoinRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInJoinRule.java
@@ -34,7 +34,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart.ProvidedOrderingPart;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart.ProvidedSortOrder;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart.RequestedSortOrder;
-import com.apple.foundationdb.record.query.plan.cascades.PlanPartition;
+import com.apple.foundationdb.record.query.plan.cascades.PlanPartitions;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifiers;
 import com.apple.foundationdb.record.query.plan.cascades.RequestedOrdering;
@@ -141,10 +141,10 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
                 computeQuantifierToExplodeMap(explodeQuantifiers, explodeExpressions.stream().collect(LinkedIdentitySet.toLinkedIdentitySet()));
         
         final var innerReference = innerQuantifier.getRangesOver();
-        final var planPartitions = PlanPartition.rollUpTo(innerReference.getPlanPartitions(), OrderingProperty.ORDERING);
+        final var planPartitions = PlanPartitions.rollUpTo(innerReference.toPlanPartitions(), OrderingProperty.ordering());
 
         for (final var planPartition  : planPartitions) {
-            final var providedOrdering = planPartition.getAttributeValue(OrderingProperty.ORDERING);
+            final var providedOrdering = planPartition.getPropertyValue(OrderingProperty.ordering());
 
             for (final RequestedOrdering requestedOrdering : requestedOrderings) {
                 final var sourcesStream =
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInUnionRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInUnionRule.java
index c56789fc96..984788cca2 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInUnionRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInUnionRule.java
@@ -29,7 +29,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.Ordering.Binding;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart.RequestedSortOrder;
-import com.apple.foundationdb.record.query.plan.cascades.PlanPartition;
+import com.apple.foundationdb.record.query.plan.cascades.PlanPartitions;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifiers;
 import com.apple.foundationdb.record.query.plan.cascades.RequestedOrderingConstraint;
@@ -159,14 +159,14 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
         
         final var innerReference = innerQuantifier.getRangesOver();
         final var planPartitions =
-                PlanPartition.rollUpTo(
-                        innerReference.getPlanPartitions(),
-                        OrderingProperty.ORDERING);
+                PlanPartitions.rollUpTo(
+                        innerReference.toPlanPartitions(),
+                        OrderingProperty.ordering());
 
         final int attemptFailedInJoinAsUnionMaxSize = call.getContext().getPlannerConfiguration().getAttemptFailedInJoinAsUnionMaxSize();
 
         for (final var planPartition : planPartitions) {
-            final var providedOrdering = planPartition.getAttributeValue(OrderingProperty.ORDERING);
+            final var providedOrdering = planPartition.getPropertyValue(OrderingProperty.ordering());
 
             for (final var requestedOrdering : requestedOrderings) {
                 if (requestedOrdering.isPreserve()) {
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInsertRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInsertRule.java
index 1f30873ca5..8adc01247d 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInsertRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementInsertRule.java
@@ -33,8 +33,8 @@
 
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.insertExpression;
 
 /**
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementIntersectionRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementIntersectionRule.java
index d2aa5221f4..2e840d73bc 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementIntersectionRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementIntersectionRule.java
@@ -26,11 +26,14 @@
 import com.apple.foundationdb.record.query.plan.cascades.Quantifiers;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.PlanPartition;
-import com.apple.foundationdb.record.query.plan.cascades.PropertiesMap;
+import com.apple.foundationdb.record.query.plan.cascades.PlanPropertiesMap;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalIntersectionExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.CollectionMatcher;
+import com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.OrderingProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIntersectionPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 import com.google.common.collect.ImmutableList;
@@ -42,13 +45,10 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.MultiMatcher.all;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RecordQueryPlanMatchers.logicalIntersectionExpression;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.rollUpTo;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.where;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty.DISTINCT_RECORDS;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.OrderingProperty.ORDERING;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty.STORED_RECORD;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.rollUpPartitionsTo;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.filterPartition;
 
 /**
  * A rule that implements an intersection of its (already implemented) children. This will extract the
@@ -63,9 +63,8 @@ public class ImplementIntersectionRule extends CascadesRule<LogicalIntersectionE
 
     @Nonnull
     private static final BindingMatcher<Reference> intersectionLegReferenceMatcher =
-            planPartitions(where(planPartition -> planPartition.getAttributeValue(STORED_RECORD),
-                    rollUpTo(any(intersectionLegPlanPartitionMatcher), PropertiesMap.allAttributesExcept(DISTINCT_RECORDS, ORDERING))));
-
+            planPartitions(filterPartition(planPartition -> planPartition.getPropertyValue(StoredRecordProperty.storedRecord()),
+                    rollUpPartitionsTo(any(intersectionLegPlanPartitionMatcher), PlanPropertiesMap.allAttributesExcept(DistinctRecordsProperty.distinctRecords(), OrderingProperty.ordering()))));
     @Nonnull
     private static final CollectionMatcher<Quantifier.ForEach> allForEachQuantifiersMatcher =
             all(forEachQuantifierOverRef(intersectionLegReferenceMatcher));
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementNestedLoopJoinRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementNestedLoopJoinRule.java
index 4f8eb4ce4b..8bb0243855 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementNestedLoopJoinRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementNestedLoopJoinRule.java
@@ -49,9 +49,9 @@
 
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.MultiMatcher.all;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.anyQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.rollUp;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.rollUpPartitions;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.canBeImplemented;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.selectExpression;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.SetMatcher.exactlyInAnyOrder;
@@ -70,7 +70,7 @@ public class ImplementNestedLoopJoinRule extends CascadesRule<SelectExpression>
 
     @Nonnull
     private static final BindingMatcher<Reference> outerReferenceMatcher =
-            planPartitions(rollUp(all(outerPlanPartitionsMatcher)));
+            planPartitions(rollUpPartitions(all(outerPlanPartitionsMatcher)));
     @Nonnull
     private static final BindingMatcher<Quantifier> outerQuantifierMatcher = anyQuantifierOverRef(outerReferenceMatcher);
     @Nonnull
@@ -78,7 +78,7 @@ public class ImplementNestedLoopJoinRule extends CascadesRule<SelectExpression>
 
     @Nonnull
     private static final BindingMatcher<Reference> innerReferenceMatcher =
-            planPartitions(rollUp(all(innerPlanPartitionsMatcher)));
+            planPartitions(rollUpPartitions(all(innerPlanPartitionsMatcher)));
     @Nonnull
     private static final BindingMatcher<Quantifier> innerQuantifierMatcher = anyQuantifierOverRef(innerReferenceMatcher);
     @Nonnull
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementRecursiveUnionRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementRecursiveUnionRule.java
index 4da9711061..1921f77153 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementRecursiveUnionRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementRecursiveUnionRule.java
@@ -33,9 +33,9 @@
 
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.rollUp;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.rollUpPartitions;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.recursiveUnionExpression;
 
 /**
@@ -53,14 +53,14 @@ public class ImplementRecursiveUnionRule extends CascadesRule<RecursiveUnionExpr
 
     @Nonnull
     private static final BindingMatcher<Quantifier.ForEach> initialQunMatcher =
-            forEachQuantifierOverRef(planPartitions(rollUp(any(initialPlanPartitionsMatcher))));
+            forEachQuantifierOverRef(planPartitions(rollUpPartitions(any(initialPlanPartitionsMatcher))));
 
     @Nonnull
     private static final BindingMatcher<PlanPartition> recursivePlanPartitionsMatcher = anyPlanPartition();
 
     @Nonnull
     private static final BindingMatcher<Quantifier.ForEach> recursiveQunMatcher =
-            forEachQuantifierOverRef(planPartitions(rollUp(any(recursivePlanPartitionsMatcher))));
+            forEachQuantifierOverRef(planPartitions(rollUpPartitions(any(recursivePlanPartitionsMatcher))));
 
     @Nonnull
     private static final BindingMatcher<RecursiveUnionExpression> root = recursiveUnionExpression(initialQunMatcher, recursiveQunMatcher);
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementSimpleSelectRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementSimpleSelectRule.java
index fc632d4e9d..10655efc35 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementSimpleSelectRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementSimpleSelectRule.java
@@ -45,8 +45,8 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.MultiMatcher.all;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.anyQuantifierOverRef;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QueryPredicateMatchers.anyPredicate;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.selectExpression;
 
 /**
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementStreamingAggregationRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementStreamingAggregationRule.java
index b1b2780189..1994125bad 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementStreamingAggregationRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementStreamingAggregationRule.java
@@ -25,6 +25,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.CascadesRule;
 import com.apple.foundationdb.record.query.plan.cascades.CascadesRuleCall;
 import com.apple.foundationdb.record.query.plan.cascades.PlanPartition;
+import com.apple.foundationdb.record.query.plan.cascades.PlanPartitions;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.RequestedOrderingConstraint;
@@ -90,10 +91,10 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
                                 AliasMap.emptyMap(), correlatedTo));
 
         final var innerReference = innerQuantifier.getRangesOver();
-        final var planPartitions = PlanPartition.rollUpTo(innerReference.getPlanPartitions(), OrderingProperty.ORDERING);
+        final var planPartitions = PlanPartitions.rollUpTo(innerReference.toPlanPartitions(), OrderingProperty.ordering());
 
         for (final var planPartition : planPartitions) {
-            final var providedOrdering = planPartition.getAttributeValue(OrderingProperty.ORDERING);
+            final var providedOrdering = planPartition.getPropertyValue(OrderingProperty.ordering());
             if (requiredOrderingKeyValues == null || providedOrdering.satisfiesGroupingValues(requiredOrderingKeyValues)) {
                 call.yieldExpression(implementGroupBy(call, planPartition, groupByExpression));
             }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementTempTableInsertRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementTempTableInsertRule.java
index c50c10e076..8605d56c9d 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementTempTableInsertRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementTempTableInsertRule.java
@@ -34,8 +34,8 @@
 
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.tempTableInsertExpression;
 
 /**
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementTypeFilterRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementTypeFilterRule.java
index dcde5b61f8..8cce16afac 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementTypeFilterRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementTypeFilterRule.java
@@ -23,13 +23,13 @@
 import com.apple.foundationdb.annotation.API;
 import com.apple.foundationdb.record.query.plan.cascades.CascadesRule;
 import com.apple.foundationdb.record.query.plan.cascades.CascadesRuleCall;
-import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.LinkedIdentitySet;
 import com.apple.foundationdb.record.query.plan.cascades.PlanPartition;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
+import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalTypeFilterExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
-import com.apple.foundationdb.record.query.plan.cascades.properties.RecordTypesProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.RecordTypesProperty.RecordTypesVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
@@ -45,9 +45,9 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ListMatcher.exactly;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.where;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.filterPartition;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.logicalTypeFilterExpression;
 
 /**
@@ -62,7 +62,7 @@ public class ImplementTypeFilterRule extends CascadesRule<LogicalTypeFilterExpre
 
     @Nonnull
     private static final BindingMatcher<Reference> innerReferenceMatcher =
-            planPartitions(where(planPartition -> planPartition.getAttributeValue(StoredRecordProperty.STORED_RECORD),
+            planPartitions(filterPartition(planPartition -> planPartition.getPropertyValue(StoredRecordProperty.storedRecord()),
                     any(innerPlanPartitionMatcher)));
 
     @Nonnull
@@ -82,7 +82,7 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
         final var unsatisfiedMapBuilder = ImmutableMultimap.<Set<String>, RecordQueryPlan>builder();
 
         for (final var innerPlan : planPartition.getPlans()) {
-            final var childRecordTypes = RecordTypesProperty.evaluate(call.newAliasResolver(), innerPlan);
+            final var childRecordTypes = new RecordTypesVisitor(call.newAliasResolver()).visit(innerPlan);
             final var filterRecordTypes = Sets.newHashSet(logicalTypeFilterExpression.getRecordTypes());
 
             if (filterRecordTypes.containsAll(childRecordTypes)) {
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUniqueRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUniqueRule.java
index 7a5369579d..a3b20266f2 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUniqueRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUniqueRule.java
@@ -37,10 +37,10 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ListMatcher.only;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.MultiMatcher.all;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.rollUp;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.where;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.rollUpPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.filterPartition;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.logicalUniqueExpression;
 
 /**
@@ -54,9 +54,9 @@ public class ImplementUniqueRule extends CascadesRule<LogicalUniqueExpression> {
 
     @Nonnull
     private static final BindingMatcher<Reference> innerReferenceMatcher = planPartitions(
-            where(planPartition -> planPartition.getAttributesMap().containsKey(DistinctRecordsProperty.DISTINCT_RECORDS)
-                                   && planPartition.getAttributeValue(PrimaryKeyProperty.PRIMARY_KEY).isPresent(),
-                    rollUp(anyPlanPartitionMatcher)));
+            filterPartition(planPartition -> planPartition.getPropertyValuesMap().containsKey(DistinctRecordsProperty.distinctRecords())
+                                   && planPartition.getPropertyValue(PrimaryKeyProperty.primaryKey()).isPresent(),
+                    rollUpPartitions(anyPlanPartitionMatcher)));
 
     @Nonnull
     private static final BindingMatcher<LogicalUniqueExpression> root = logicalUniqueExpression(only(forEachQuantifierOverRef(innerReferenceMatcher)));
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUnorderedUnionRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUnorderedUnionRule.java
index 082baba186..deb83c438a 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUnorderedUnionRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUnorderedUnionRule.java
@@ -39,9 +39,9 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.MultiMatcher.all;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.rollUp;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.rollUpPartitions;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.logicalUnionExpression;
 
 /**
@@ -57,7 +57,7 @@ public class ImplementUnorderedUnionRule extends CascadesRule<LogicalUnionExpres
 
     @Nonnull
     private static final BindingMatcher<Reference> unionLegReferenceMatcher =
-            planPartitions(rollUp(any(unionLegPlanPartitionsMatcher)));
+            planPartitions(rollUpPartitions(any(unionLegPlanPartitionsMatcher)));
 
     @Nonnull
     private static final CollectionMatcher<Quantifier.ForEach> allForEachQuantifiersMatcher =
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUpdateRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUpdateRule.java
index d4ac51c633..2e70e48e9a 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUpdateRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/ImplementUpdateRule.java
@@ -28,17 +28,17 @@
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.UpdateExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
+import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryUnorderedPrimaryKeyDistinctPlan;
 
 import javax.annotation.Nonnull;
 
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.anyPlanPartition;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.where;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.anyPlanPartition;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.filterPartition;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.updateExpression;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty.STORED_RECORD;
 
 /**
  * A rule that implements an {@link UpdateExpression} by creating
@@ -52,7 +52,7 @@ public class ImplementUpdateRule extends CascadesRule<UpdateExpression> {
 
     @Nonnull
     private static final BindingMatcher<Reference> innerReferenceMatcher =
-            planPartitions(where(planPartition -> planPartition.getAttributeValue(STORED_RECORD),
+            planPartitions(filterPartition(planPartition -> planPartition.getPropertyValue(StoredRecordProperty.storedRecord()),
                     any(innerPlanPartitionMatcher)));
 
     private static final BindingMatcher<Quantifier.ForEach> innerQuantifierMatcher =
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/PartitionSelectRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/PartitionSelectRule.java
index 497ee5afc4..9b30b3a68b 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/PartitionSelectRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/PartitionSelectRule.java
@@ -78,6 +78,10 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
             return;
         }
 
+        //
+        // Form lowerAliases and upperAliases. We get lowerAliases from the matcher; upperAliases is what lowerAliases
+        // is not, i.e. the complement of the quantifiers owned by the select expression.
+        //
         final var lowerAliases = bindings.get(combinationQuantifierMatcher)
                 .stream()
                 .map(Quantifier::getAlias)
@@ -94,6 +98,8 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
             }
         }
         final var upperAliases = upperAliasesBuilder.build();
+
+        // we need to have a non-trivial partitioning.
         if (upperAliases.isEmpty()) {
             return;
         }
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/RemoveSortRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/RemoveSortRule.java
index d9f9c5cb67..05e0e7fa3f 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/RemoveSortRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/rules/RemoveSortRule.java
@@ -33,7 +33,10 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalSortExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
-import com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers;
+import com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers;
+import com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.OrderingProperty;
+import com.apple.foundationdb.record.query.plan.cascades.properties.PrimaryKeyProperty;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryCoveringIndexPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryIndexPlan;
@@ -48,12 +51,9 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.AnyMatcher.any;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ListMatcher.exactly;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.QuantifierMatchers.forEachQuantifierOverRef;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.planPartitions;
-import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ReferenceMatchers.rollUpTo;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.planPartitions;
+import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.PlanPartitionMatchers.rollUpPartitionsTo;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RelationalExpressionMatchers.logicalSortExpression;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.DistinctRecordsProperty.DISTINCT_RECORDS;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.OrderingProperty.ORDERING;
-import static com.apple.foundationdb.record.query.plan.cascades.properties.PrimaryKeyProperty.PRIMARY_KEY;
 
 /**
  * A rule that implements a sort expression by removing this expression if appropriate.
@@ -62,11 +62,13 @@
 @SuppressWarnings("PMD.TooManyStaticImports")
 public class RemoveSortRule extends CascadesRule<LogicalSortExpression> {
     @Nonnull
-    private static final BindingMatcher<PlanPartition> innerPlanPartitionMatcher = ReferenceMatchers.anyPlanPartition();
+    private static final BindingMatcher<PlanPartition> innerPlanPartitionMatcher = PlanPartitionMatchers.anyPlanPartition();
 
     @Nonnull
     private static final BindingMatcher<Reference> innerReferenceMatcher =
-            planPartitions(rollUpTo(any(innerPlanPartitionMatcher), ImmutableSet.of(ORDERING, DISTINCT_RECORDS, PRIMARY_KEY)));
+            planPartitions(rollUpPartitionsTo(any(innerPlanPartitionMatcher), ImmutableSet.of(OrderingProperty.ordering(),
+                    DistinctRecordsProperty.distinctRecords(),
+                    PrimaryKeyProperty.primaryKey())));
 
     @Nonnull
     private static final BindingMatcher<Quantifier.ForEach> innerQuantifierMatcher = forEachQuantifierOverRef(innerReferenceMatcher);
@@ -91,7 +93,7 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
         final List<OrderingPart.RequestedOrderingPart> requestedOrderingParts = requestedOrdering.getOrderingParts();
         final Set<Value> sortValuesSet = requestedOrderingParts.stream().map(OrderingPart::getValue).collect(Collectors.toSet());
 
-        final Ordering ordering = innerPlanPartition.getAttributeValue(ORDERING);
+        final Ordering ordering = innerPlanPartition.getPropertyValue(OrderingProperty.ordering());
         final Set<Value> equalityBoundKeys = ordering.getEqualityBoundValues();
         int equalityBoundUnsorted = equalityBoundKeys.size();
 
@@ -108,7 +110,7 @@ public void onMatch(@Nonnull final CascadesRuleCall call) {
             return;
         }
 
-        final boolean isDistinct = innerPlanPartition.getAttributeValue(DISTINCT_RECORDS);
+        final boolean isDistinct = innerPlanPartition.getPropertyValue(DistinctRecordsProperty.distinctRecords());
         if (isDistinct) {
             if (ordering.getOrderingSet()
                     .getSet()
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/values/simplification/AbstractRule.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/values/simplification/AbstractRule.java
index 729ef847b2..0bbc1a10c6 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/values/simplification/AbstractRule.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/values/simplification/AbstractRule.java
@@ -21,11 +21,11 @@
 package com.apple.foundationdb.record.query.plan.cascades.values.simplification;
 
 import com.apple.foundationdb.annotation.API;
+import com.apple.foundationdb.record.query.plan.cascades.PlanningRuleSet;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.PlanContext;
 import com.apple.foundationdb.record.query.plan.cascades.PlannerRule;
 import com.apple.foundationdb.record.query.plan.cascades.PlannerRuleCall;
-import com.apple.foundationdb.record.query.plan.cascades.PlannerRuleSet;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
 
 import javax.annotation.Nonnull;
@@ -73,7 +73,7 @@ public AbstractRule(@Nonnull BindingMatcher<TYPE> matcher) {
      * Returns the class of the operator at the root of the binding expression, if this rule uses a non-trivial binding.
      * Used primarily for indexing rules for more efficient rule search.
      * @return the class of the root of this rule's binding, or <code>Optional.empty()</code> if the rule matches anything
-     * @see PlannerRuleSet
+     * @see PlanningRuleSet
      */
     @Nonnull
     @Override
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryAggregateIndexPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryAggregateIndexPlan.java
index 8bd4189af8..ec20b9f922 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryAggregateIndexPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryAggregateIndexPlan.java
@@ -39,7 +39,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
 import com.apple.foundationdb.record.query.plan.IndexKeyValueToPartialRecord;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.QueryPlanConstraint;
 import com.apple.foundationdb.record.query.plan.ScanComparisons;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
@@ -51,6 +50,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryComparatorPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryComparatorPlan.java
index 1937b072ab..c9d7daf4be 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryComparatorPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryComparatorPlan.java
@@ -35,7 +35,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.cursors.ComparatorCursor;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.Memoizer;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -45,6 +44,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryCoveringIndexPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryCoveringIndexPlan.java
index 3dbb742e71..e36e9060c0 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryCoveringIndexPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryCoveringIndexPlan.java
@@ -39,7 +39,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
 import com.apple.foundationdb.record.query.plan.IndexKeyValueToPartialRecord;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.MatchCandidate;
@@ -49,6 +48,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.IndexedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryDefaultOnEmptyPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryDefaultOnEmptyPlan.java
index 2163b0d427..a76911c2b1 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryDefaultOnEmptyPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryDefaultOnEmptyPlan.java
@@ -32,7 +32,6 @@
 import com.apple.foundationdb.record.planprotos.PRecordQueryPlan;
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Memoizer;
@@ -43,6 +42,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionWithChildren;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.DerivedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryDeletePlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryDeletePlan.java
index a7eecf8e2a..d03b3e054e 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryDeletePlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryDeletePlan.java
@@ -33,7 +33,6 @@
 import com.apple.foundationdb.record.planprotos.PRecordQueryPlan;
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -42,6 +41,8 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphRewritable;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
+import com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.auto.service.AutoService;
@@ -67,8 +68,7 @@
  * {@link QueryResult} that represents the in record. Note that
  * {@link com.apple.foundationdb.record.query.plan.cascades.rules.ImplementDeleteRule} only allows implementation of
  * a {@link com.apple.foundationdb.record.query.plan.cascades.expressions.DeleteExpression} if the plan partition
- * of the child guarantees
- * {@link com.apple.foundationdb.record.query.plan.cascades.properties.StoredRecordProperty#STORED_RECORD}.
+ * of the child guarantees {@link StoredRecordProperty#storedRecord()}.
  * Not that we hold on to a target record type in this plan operator only for debugging purposes at the moment.
  */
 @API(API.Status.INTERNAL)
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryExplodePlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryExplodePlan.java
index 2935edd3b9..ae3c499843 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryExplodePlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryExplodePlan.java
@@ -33,7 +33,6 @@
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Memoizer;
@@ -42,6 +41,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFetchFromPartialRecordPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFetchFromPartialRecordPlan.java
index 61d215a9cb..c723fc0aaf 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFetchFromPartialRecordPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFetchFromPartialRecordPlan.java
@@ -40,7 +40,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.IndexOrphanBehavior;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -48,6 +47,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.DerivedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.QuantifiedObjectValue;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFilterPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFilterPlan.java
index 218759e217..0bb00ddc48 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFilterPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFilterPlan.java
@@ -30,7 +30,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.expressions.Query;
 import com.apple.foundationdb.record.query.expressions.QueryComponent;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -39,6 +38,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFirstOrDefaultPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFirstOrDefaultPlan.java
index 04f32305f9..de6943e06c 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFirstOrDefaultPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFirstOrDefaultPlan.java
@@ -42,10 +42,10 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionWithChildren;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.DerivedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.google.auto.service.AutoService;
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFlatMapPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFlatMapPlan.java
index a614c3726c..0fe9775953 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFlatMapPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryFlatMapPlan.java
@@ -34,7 +34,6 @@
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Memoizer;
@@ -45,6 +44,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionWithChildren;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.auto.service.AutoService;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInComparandJoinPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInComparandJoinPlan.java
index 0b48583bc5..709dd20aa9 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInComparandJoinPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInComparandJoinPlan.java
@@ -30,7 +30,6 @@
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.query.expressions.Comparisons;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
@@ -38,6 +37,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInParameterJoinPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInParameterJoinPlan.java
index 353042045e..2b5ae91740 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInParameterJoinPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInParameterJoinPlan.java
@@ -29,12 +29,12 @@
 import com.apple.foundationdb.record.planprotos.PRecordQueryPlan;
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.explain.Attribute;
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInUnionPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInUnionPlan.java
index 63c29f3a23..0ab0e8f7be 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInUnionPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInUnionPlan.java
@@ -35,7 +35,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.cursors.UnionCursor;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart.ProvidedOrderingPart;
@@ -46,6 +45,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInValuesJoinPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInValuesJoinPlan.java
index a4632ff767..3a545bc343 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInValuesJoinPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInValuesJoinPlan.java
@@ -31,12 +31,12 @@
 import com.apple.foundationdb.record.planprotos.PRecordQueryPlan;
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.explain.Attribute;
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryIndexPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryIndexPlan.java
index 157efd4d04..6e43ea876b 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryIndexPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryIndexPlan.java
@@ -60,7 +60,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.MultidimensionalIndexScanComparisons;
 import com.apple.foundationdb.record.provider.foundationdb.UnsupportedRemoteFetchIndexException;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.QueryPlanConstraint;
 import com.apple.foundationdb.record.query.plan.ScanComparisons;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
@@ -75,6 +74,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphRewritable;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInsertPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInsertPlan.java
index 8d2c08b391..ae4ebbd1c4 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInsertPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryInsertPlan.java
@@ -32,11 +32,11 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBQueriedRecord;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoredRecord;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.MessageHelpers;
 import com.apple.foundationdb.record.query.plan.cascades.values.PromoteValue;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryIntersectionPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryIntersectionPlan.java
index deede8b769..9ba7b07472 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryIntersectionPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryIntersectionPlan.java
@@ -36,7 +36,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.cursors.IntersectionCursor;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.OrderingPart.ProvidedOrderingPart;
@@ -47,6 +46,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryLoadByKeysPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryLoadByKeysPlan.java
index 1b83583d93..2eaeeaff19 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryLoadByKeysPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryLoadByKeysPlan.java
@@ -36,7 +36,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -44,6 +43,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryMapPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryMapPlan.java
index d2025d9f4d..555bc6b89c 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryMapPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryMapPlan.java
@@ -33,7 +33,6 @@
 import com.apple.foundationdb.record.planprotos.PRecordQueryPlan;
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Memoizer;
@@ -44,6 +43,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionWithChildren;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.auto.service.AutoService;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryPredicatesFilterPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryPredicatesFilterPlan.java
index 04bffbc142..899d24bfca 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryPredicatesFilterPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryPredicatesFilterPlan.java
@@ -32,7 +32,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.expressions.AsyncBoolean;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -44,6 +43,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpressionWithPredicates;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.AndPredicate;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.QueryPredicate;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.auto.service.AutoService;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryRangePlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryRangePlan.java
index b0c97e1397..d673e173b3 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryRangePlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryRangePlan.java
@@ -34,7 +34,6 @@
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Memoizer;
@@ -43,6 +42,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryScanPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryScanPlan.java
index 1e84b06529..fdcd3a14d5 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryScanPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryScanPlan.java
@@ -37,7 +37,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.ScanComparisons;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.ComparisonRanges;
@@ -50,6 +49,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphRewritable;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryScoreForRankPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryScoreForRankPlan.java
index 857c82df94..eacbe3b4fb 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryScoreForRankPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryScoreForRankPlan.java
@@ -43,7 +43,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.indexes.RankedSetIndexHelper;
 import com.apple.foundationdb.record.query.expressions.Comparisons;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -52,6 +51,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQuerySelectorPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQuerySelectorPlan.java
index 74dc2d1a68..19f051080f 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQuerySelectorPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQuerySelectorPlan.java
@@ -36,7 +36,6 @@
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifiers;
@@ -45,6 +44,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.apple.foundationdb.tuple.ByteArrayUtil2;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryStreamingAggregationPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryStreamingAggregationPlan.java
index 3398ff2e9a..a49e2109f4 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryStreamingAggregationPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryStreamingAggregationPlan.java
@@ -45,12 +45,12 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.GroupByExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.AggregateValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.ObjectValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.serialization.PlanSerialization;
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTableFunctionPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTableFunctionPlan.java
index 45e8d323d7..6891023c2e 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTableFunctionPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTableFunctionPlan.java
@@ -43,12 +43,12 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.StreamingValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTextIndexPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTextIndexPlan.java
index 1c80a923b2..c324d274b0 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTextIndexPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTextIndexPlan.java
@@ -35,7 +35,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.TextScan;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
@@ -45,6 +44,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTypeFilterPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTypeFilterPlan.java
index 57fc012f7a..ccc1853f28 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTypeFilterPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryTypeFilterPlan.java
@@ -33,7 +33,6 @@
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
@@ -41,6 +40,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.TypeFilterExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.QuantifiedObjectValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnionPlanBase.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnionPlanBase.java
index f44b330bc1..4a717e6bd1 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnionPlanBase.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnionPlanBase.java
@@ -32,11 +32,11 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBQueriedRecord;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.Memoizer;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableList;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedDistinctPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedDistinctPlan.java
index 9a4448b6a3..f877c4a2c8 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedDistinctPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedDistinctPlan.java
@@ -35,7 +35,6 @@
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -44,6 +43,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.google.auto.service.AutoService;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedPrimaryKeyDistinctPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedPrimaryKeyDistinctPlan.java
index a985929d80..0575921240 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedPrimaryKeyDistinctPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedPrimaryKeyDistinctPlan.java
@@ -33,7 +33,6 @@
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -41,6 +40,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
 import com.apple.foundationdb.tuple.Tuple;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedUnionPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedUnionPlan.java
index 8c2d57670c..252b5acd05 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedUnionPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUnorderedUnionPlan.java
@@ -34,7 +34,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.cursors.UnorderedUnionCursor;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifiers;
@@ -89,12 +88,6 @@ public String getDelimiter() {
         return " " + UNION + " ";
     }
 
-    @Nonnull
-    @Override
-    public String toString() {
-        return ExplainPlanVisitor.toStringForDebugging(this);
-    }
-
     @Nonnull
     @Override
     StoreTimer.Count getPlanCount() {
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUpdatePlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUpdatePlan.java
index 01b1b58c22..d40df90d89 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUpdatePlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/RecordQueryUpdatePlan.java
@@ -33,12 +33,12 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBQueriedRecord;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoredRecord;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.SemanticException;
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.FieldValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.MessageHelpers;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/TempTableInsertPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/TempTableInsertPlan.java
index 4276ae72d8..8cb4edd1f5 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/TempTableInsertPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/TempTableInsertPlan.java
@@ -42,11 +42,11 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphRewritable;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/TempTableScanPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/TempTableScanPlan.java
index 7382917f93..20be4ba245 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/TempTableScanPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/plans/TempTableScanPlan.java
@@ -29,12 +29,11 @@
 import com.apple.foundationdb.record.PlanSerializationContext;
 import com.apple.foundationdb.record.RecordCursor;
 import com.apple.foundationdb.record.cursors.ListCursor;
-import com.apple.foundationdb.record.planprotos.PTempTableScanPlan;
 import com.apple.foundationdb.record.planprotos.PRecordQueryPlan;
+import com.apple.foundationdb.record.planprotos.PTempTableScanPlan;
 import com.apple.foundationdb.record.provider.common.StoreTimer;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Memoizer;
@@ -43,6 +42,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/sorting/RecordQuerySortPlan.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/sorting/RecordQuerySortPlan.java
index cafaf74ac2..34a066a508 100644
--- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/sorting/RecordQuerySortPlan.java
+++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/sorting/RecordQuerySortPlan.java
@@ -35,7 +35,6 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.FDBStoreTimer;
 import com.apple.foundationdb.record.query.plan.AvailableFields;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
 import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
@@ -43,6 +42,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.explain.NodeInfo;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.cascades.values.translation.TranslationMap;
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBCoveringIndexQueryTest.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBCoveringIndexQueryTest.java
index a0ce8cd2bd..d375ffc58d 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBCoveringIndexQueryTest.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBCoveringIndexQueryTest.java
@@ -42,7 +42,7 @@
 import com.apple.foundationdb.record.query.expressions.Query;
 import com.apple.foundationdb.record.query.plan.RecordQueryPlanner;
 import com.apple.foundationdb.record.query.plan.cascades.KeyExpressionVisitor;
-import com.apple.foundationdb.record.query.plan.cascades.PlannerRuleSet;
+import com.apple.foundationdb.record.query.plan.cascades.PlanningRuleSet;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.ValueMatchers;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
@@ -166,7 +166,7 @@ void coveringOff() throws Exception {
                         "PushFilterThroughFetchRule",
                         "PushDistinctThroughFetchRule",
                         "PushSetOperationThroughFetchRule",
-                        "MergeProjectionAndFetchRule"), PlannerRuleSet.DEFAULT).build());
+                        "MergeProjectionAndFetchRule"), PlanningRuleSet.DEFAULT).build());
         RecordQueryPlan plan = planQuery(query);
         if (planner instanceof RecordQueryPlanner) {
             final BindingMatcher<? extends RecordQueryPlan> planMatcher =
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBInQueryTest.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBInQueryTest.java
index 7b4e5d7441..caf5c56edd 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBInQueryTest.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBInQueryTest.java
@@ -57,7 +57,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.PrimitiveMatchers;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.RecordQueryPlanMatchers;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
 import com.apple.foundationdb.record.query.plan.cascades.values.AbstractArrayConstructorValue;
@@ -164,6 +163,7 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RecordQueryPlanMatchers.unorderedUnionPlan;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ValueMatchers.anyValue;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ValueMatchers.fieldValueWithFieldNames;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty.usedTypes;
 import static java.util.Arrays.asList;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.anyOf;
@@ -451,7 +451,7 @@ void testTupleInListNoIndex() throws Exception {
                         mapPlan(predicatesFilterPlan(typeFilterPlan(scanPlan()))));
         assertEquals(-1783159911, plan.planHash(PlanHashable.CURRENT_FOR_CONTINUATION));
 
-        final var usedTypes = UsedTypesProperty.evaluate(plan);
+        final var usedTypes = usedTypes().evaluate(plan);
         final var evaluationContext =
                 EvaluationContext.forTypeRepository(TypeRepository.newBuilder().addAllTypes(usedTypes).build());
         assertEquals(20, querySimpleRecordStore(hook, plan, () -> evaluationContext,
@@ -2694,7 +2694,7 @@ void testInUnionWithSomeSargable(int replans) throws Exception {
         final Consumer<TestRecords1Proto.MySimpleRecord> numValue2Check = simpleRecord -> assertThat(simpleRecord.getNumValue2(), in(nv2List));
         final Function<TestRecords1Proto.MySimpleRecord, Tuple> sortKey = simpleRecord -> Tuple.from(simpleRecord.getNumValue3Indexed());
         final Bindings base = Bindings.newBuilder().set("nv2_list", nv2List).build();
-        TypeRepository typeRepository = TypeRepository.newBuilder().addAllTypes(UsedTypesProperty.evaluate(plan)).build();
+        TypeRepository typeRepository = TypeRepository.newBuilder().addAllTypes(usedTypes().evaluate(plan)).build();
         assertEquals(34,
                 querySimpleRecordStore(hook, plan,
                         () -> EvaluationContext.forBindingsAndTypeRepository(base.childBuilder().set("str_list", List.of("even")).build(), typeRepository),
@@ -2817,7 +2817,7 @@ void testInUnionWithIntersectionOnTwoPredicates(int replans, boolean dropNumValu
         final Consumer<TestRecords1Proto.MySimpleRecord> numValue2Check = simpleRecord -> assertThat(simpleRecord.getNumValue2(), in(nv2List));
         final Function<TestRecords1Proto.MySimpleRecord, Tuple> sortKey = simpleRecord -> Tuple.from(simpleRecord.getNumValue3Indexed());
         final Bindings base = Bindings.newBuilder().set("nv2_list", nv2List).build();
-        TypeRepository typeRepository = TypeRepository.newBuilder().addAllTypes(UsedTypesProperty.evaluate(plan)).build();
+        TypeRepository typeRepository = TypeRepository.newBuilder().addAllTypes(usedTypes().evaluate(plan)).build();
         assertEquals(34,
                 querySimpleRecordStore(hook, plan,
                         () -> EvaluationContext.forBindingsAndTypeRepository(base.childBuilder().set("str_list", List.of("even")).build(), typeRepository),
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBModificationQueryTest.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBModificationQueryTest.java
index 6bdd422e1e..b66559533f 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBModificationQueryTest.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBModificationQueryTest.java
@@ -33,9 +33,9 @@
 import com.apple.foundationdb.record.query.expressions.Comparisons;
 import com.apple.foundationdb.record.query.plan.cascades.AccessHints;
 import com.apple.foundationdb.record.query.plan.cascades.CascadesPlanner;
-import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.GraphExpansion;
 import com.apple.foundationdb.record.query.plan.cascades.Quantifier;
+import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.DeleteExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.ExplodeExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.FullUnorderedScanExpression;
@@ -47,7 +47,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.predicates.NotPredicate;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.QueryPredicate;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.ValuePredicate;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
 import com.apple.foundationdb.record.query.plan.cascades.values.AbstractArrayConstructorValue.LightArrayConstructorValue;
@@ -89,6 +88,7 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RecordQueryPlanMatchers.typeFilterPlan;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RecordQueryPlanMatchers.unorderedPrimaryKeyDistinctPlan;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RecordQueryPlanMatchers.updatePlan;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty.usedTypes;
 import static com.apple.foundationdb.record.query.plan.cascades.values.AbstractArrayConstructorValue.LightArrayConstructorValue.emptyArray;
 
 /**
@@ -330,7 +330,7 @@ public void testInsertExistingRecordThrowsException() throws Exception {
             fetchResultValues(context, plan, Function.identity(), c -> {
             });
             // after inserting, try inserting again, throws RecordAlreadyExistsException
-            final var usedTypes = UsedTypesProperty.evaluate(plan);
+            final var usedTypes = usedTypes().evaluate(plan);
             final var evaluationContext = EvaluationContext.forTypeRepository(TypeRepository.newBuilder().addAllTypes(usedTypes).build());
             try (RecordCursorIterator<QueryResult> cursor = plan.executePlan(recordStore, evaluationContext, null, ExecuteProperties.SERIAL_EXECUTE).asIterator()) {
                 RecordCoreException ex1 = Assertions.assertThrows(RecordCoreException.class, cursor::hasNext);
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBQueryGraphTestHelpers.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBQueryGraphTestHelpers.java
index 4a887490e6..485895c6c9 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBQueryGraphTestHelpers.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBQueryGraphTestHelpers.java
@@ -33,7 +33,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.FullUnorderedScanExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalSortExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalTypeFilterExpression;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type.Record;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
@@ -54,6 +53,7 @@
 import java.util.Optional;
 import java.util.Set;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty.usedTypes;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
@@ -109,7 +109,7 @@ static RecordCursor<QueryResult> executeCascades(FDBRecordStore store, RecordQue
     }
 
     static RecordCursor<QueryResult> executeCascades(FDBRecordStore store, RecordQueryPlan plan, Bindings bindings) {
-        Set<Type> usedTypes = UsedTypesProperty.evaluate(plan);
+        Set<Type> usedTypes = usedTypes().evaluate(plan);
         TypeRepository typeRepository = TypeRepository.newBuilder()
                 .addAllTypes(usedTypes)
                 .build();
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBRecordStoreQueryTestBase.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBRecordStoreQueryTestBase.java
index d4fc440244..60dc3336c3 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBRecordStoreQueryTestBase.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBRecordStoreQueryTestBase.java
@@ -60,10 +60,9 @@
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger;
 import com.apple.foundationdb.record.query.plan.cascades.matching.structure.BindingMatcher;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
 import com.apple.foundationdb.record.query.plan.cascades.values.ConstantObjectValue;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.plans.QueryResult;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 import com.apple.foundationdb.record.query.plan.serialization.DefaultPlanSerializationRegistry;
@@ -97,6 +96,7 @@
 import static com.apple.foundationdb.record.metadata.Key.Expressions.concat;
 import static com.apple.foundationdb.record.metadata.Key.Expressions.concatenateFields;
 import static com.apple.foundationdb.record.metadata.Key.Expressions.field;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty.usedTypes;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
 import static org.hamcrest.Matchers.instanceOf;
@@ -246,7 +246,7 @@ protected void complexQuerySetup(RecordMetaDataHook hook) throws Exception {
     @Nonnull
     protected List<Map<String, Object>> queryAsMaps(@Nonnull RecordQueryPlan plan, @Nonnull Bindings bindings) {
         final TypeRepository types = TypeRepository.newBuilder()
-                .addAllTypes(UsedTypesProperty.evaluate(plan))
+                .addAllTypes(usedTypes().evaluate(plan))
                 .build();
         final EvaluationContext evaluationContext = EvaluationContext.forBindingsAndTypeRepository(bindings, types);
         try (RecordCursor<QueryResult> resultCursor = plan.executePlan(recordStore, evaluationContext, null, ExecuteProperties.SERIAL_EXECUTE)) {
@@ -428,7 +428,7 @@ protected <T> List<T> fetchResultValues(FDBRecordContext context, RecordQueryPla
     protected <T> List<T> fetchResultValues(FDBRecordContext context, RecordQueryPlan plan, Function<Message, T> rowHandler,
                                             EvaluationContext extraEvaluationContext,
                                             TestHelpers.DangerousConsumer<FDBRecordContext> checkDiscarded, ExecuteProperties executeProperties) throws Exception {
-        final var usedTypes = UsedTypesProperty.evaluate(plan);
+        final var usedTypes = usedTypes().evaluate(plan);
         List<T> result = new ArrayList<>();
         var evaluationContext = EvaluationContext.forTypeRepository(TypeRepository.newBuilder().addAllTypes(usedTypes).build());
         for (final var binding : extraEvaluationContext.getBindings().asMappingList()) {
@@ -705,7 +705,7 @@ protected RecordCursorIterator<FDBQueriedRecord<Message>> executeQuery(@Nonnull
 
     @Nonnull
     protected RecordCursorIterator<FDBQueriedRecord<Message>> executeQuery(@Nonnull final RecordQueryPlan plan, @Nonnull Bindings bindings) {
-        final var usedTypes = UsedTypesProperty.evaluate(plan);
+        final var usedTypes = usedTypes().evaluate(plan);
         final var typeRepository = TypeRepository.newBuilder().addAllTypes(usedTypes).build();
         return plan.execute(recordStore, EvaluationContext.forBindingsAndTypeRepository(bindings, typeRepository)).asIterator();
     }
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBRepeatedFieldQueryTest.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBRepeatedFieldQueryTest.java
index fac02c1956..130aa3c1d0 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBRepeatedFieldQueryTest.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBRepeatedFieldQueryTest.java
@@ -38,7 +38,6 @@
 import com.apple.foundationdb.record.query.expressions.Query;
 import com.apple.foundationdb.record.query.expressions.QueryComponent;
 import com.apple.foundationdb.record.query.plan.RecordQueryPlanner;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
 import com.apple.foundationdb.record.query.plan.plans.QueryResult;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
@@ -61,6 +60,7 @@
 import static com.apple.foundationdb.record.TestHelpers.assertDiscardedNone;
 import static com.apple.foundationdb.record.metadata.Key.Expressions.concat;
 import static com.apple.foundationdb.record.metadata.Key.Expressions.field;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty.usedTypes;
 import static com.apple.foundationdb.record.query.plan.match.PlanMatchers.bounds;
 import static com.apple.foundationdb.record.query.plan.match.PlanMatchers.coveringIndexScan;
 import static com.apple.foundationdb.record.query.plan.match.PlanMatchers.fetch;
@@ -585,7 +585,7 @@ void testComplexQuery7() throws Exception {
                 assertEquals(-1199247774, plan.planHash(PlanHashable.CURRENT_LEGACY));
                 assertEquals(325380875, plan.planHash(PlanHashable.CURRENT_FOR_CONTINUATION));
             }
-            final var usedTypes = UsedTypesProperty.evaluate(plan);
+            final var usedTypes = usedTypes().evaluate(plan);
             final var typeRepository = TypeRepository.newBuilder().addAllTypes(usedTypes).build();
             List<Message> byQuery =
                     recordStore.executeQuery(plan, null, EvaluationContext.forBindingsAndTypeRepository(Bindings.EMPTY_BINDINGS, typeRepository), ExecuteProperties.SERIAL_EXECUTE)
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBSimpleQueryGraphTest.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBSimpleQueryGraphTest.java
index 68d3651624..ae22e499d3 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBSimpleQueryGraphTest.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/FDBSimpleQueryGraphTest.java
@@ -47,7 +47,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.predicates.DatabaseObjectDependenciesPredicate;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.ExistsPredicate;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.ValuePredicate;
-import com.apple.foundationdb.record.query.plan.cascades.properties.DerivationsProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type.Record;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type.Record.Field;
@@ -106,6 +105,7 @@
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ValueMatchers.anyValue;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ValueMatchers.fieldValueWithFieldNames;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.ValueMatchers.recordConstructorValue;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.DerivationsProperty.derivations;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
@@ -583,7 +583,7 @@ void testMediumJoinTypeEvolutionIdentical() {
         // find restaurants that where at least reviewed by two common reviewers
         final var plannedPlan = planMediumJoin(cascadesPlanner);
 
-        final var derivations = DerivationsProperty.evaluateDerivations(plannedPlan);
+        final var derivations = derivations().evaluate(plannedPlan);
         final var simplifiedLocalValues = derivations.simplifyLocalValues();
         final var fieldAccesses = CompatibleTypeEvolutionPredicate.computeFieldAccesses(simplifiedLocalValues);
         final var compatibleTypeEvolutionPredicate = new CompatibleTypeEvolutionPredicate(fieldAccesses);
@@ -704,7 +704,7 @@ void testMediumJoinTypeEvolutionCompatible() {
         // find restaurants that where at least reviewed by two common reviewers
         final var plannedPlan = planMediumJoin(cascadesPlanner);
 
-        final var derivations = DerivationsProperty.evaluateDerivations(plannedPlan);
+        final var derivations = derivations().evaluate(plannedPlan);
         final var simplifiedLocalValues = derivations.simplifyLocalValues();
         final var fieldAccesses = CompatibleTypeEvolutionPredicate.computeFieldAccesses(simplifiedLocalValues);
 
@@ -791,7 +791,7 @@ void testMediumJoinTypeEvolutionIncompatible1() {
         // find restaurants that where at least reviewed by two common reviewers
         final var plannedPlan = planMediumJoin(cascadesPlanner);
 
-        final var derivations = DerivationsProperty.evaluateDerivations(plannedPlan);
+        final var derivations = derivations().evaluate(plannedPlan);
         final var simplifiedLocalValues = derivations.simplifyLocalValues();
         final var fieldAccesses = CompatibleTypeEvolutionPredicate.computeFieldAccesses(simplifiedLocalValues);
 
@@ -872,7 +872,7 @@ void testMediumJoinTypeEvolutionIncompatible2() {
         // find restaurants that where at least reviewed by two common reviewers
         final var plannedPlan = planMediumJoin(cascadesPlanner);
 
-        final var derivations = DerivationsProperty.evaluateDerivations(plannedPlan);
+        final var derivations = derivations().evaluate(plannedPlan);
         final var simplifiedLocalValues = derivations.simplifyLocalValues();
         final var fieldAccesses = CompatibleTypeEvolutionPredicate.computeFieldAccesses(simplifiedLocalValues);
 
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/RecursiveUnionTest.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/RecursiveUnionTest.java
index e120dbcafc..38652e1085 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/RecursiveUnionTest.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/RecursiveUnionTest.java
@@ -48,7 +48,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.values.ArithmeticValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.LiteralValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.plans.QueryResult;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryRecursiveUnionPlan;
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/TempTableTestBase.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/TempTableTestBase.java
index 710184f8b3..c6e9817ea5 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/TempTableTestBase.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/query/TempTableTestBase.java
@@ -35,7 +35,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.TempTable;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.LogicalSortExpression;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.TempTableScanExpression;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
 import com.apple.foundationdb.record.query.plan.cascades.values.FieldValue;
@@ -72,6 +71,7 @@
 
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RecordQueryPlanMatchers.mapPlan;
 import static com.apple.foundationdb.record.query.plan.cascades.matching.structure.RecordQueryPlanMatchers.tempTableScanPlan;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty.usedTypes;
 
 /**
  * Contains utility methods around {@link TempTable}s to make testing temp table planning and execution easier.
@@ -290,7 +290,7 @@ static EvaluationContext setUpPlanContext(@Nonnull final RecordQueryPlan recordQ
 
     @Nonnull
     static EvaluationContext setUpPlanContextTypes(@Nonnull final RecordQueryPlan recordQueryPlan) {
-        final var usedTypes = UsedTypesProperty.evaluate(recordQueryPlan);
+        final var usedTypes = usedTypes().evaluate(recordQueryPlan);
         return EvaluationContext.forTypeRepository(TypeRepository.newBuilder().addAllTypes(usedTypes).build());
     }
 
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/Commands.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/Commands.java
index f4d6ece49d..b5f0f6aa58 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/Commands.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/Commands.java
@@ -29,7 +29,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger.EventWithState;
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger.Location;
 import com.apple.foundationdb.record.query.plan.cascades.debug.RestartException;
-import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.google.auto.service.AutoService;
 import com.google.common.base.Enums;
@@ -533,7 +533,7 @@ public boolean executeCommand(@Nonnull final PlannerRepl plannerRepl,
                     final EventWithState eventWithState = (EventWithState)event;
                     final Reference rootReference = eventWithState.getRootReference();
                     if ("GRAPH".equals(word1)) {
-                        PlannerGraphProperty.show(PlannerGraphProperty.RENDER_SINGLE_GROUPS, rootReference);
+                        PlannerGraphVisitor.show(PlannerGraphVisitor.RENDER_SINGLE_GROUPS, rootReference);
                         return false;
                     } else if ("MATCH".equals(word1) && words.size() == 3) {
                         final String word2 = words.get(2);
@@ -544,16 +544,16 @@ public boolean executeCommand(@Nonnull final PlannerRepl plannerRepl,
                                         .filter(matchCandidate -> word2.equals(matchCandidate.getName()))
                                         .findFirst();
                         if (matchCandidateOptional.isPresent()) {
-                            PlannerGraphProperty.show(true, rootReference, ImmutableSet.of(matchCandidateOptional.get()));
+                            PlannerGraphVisitor.show(true, rootReference, ImmutableSet.of(matchCandidateOptional.get()));
                         } else {
                             plannerRepl.printlnError("unknown match candidate");
                         }
                         return false;
                     } else if ("MATCHES".equals(word1)) {
-                        PlannerGraphProperty.show(true, rootReference, Objects.requireNonNull(plannerRepl.getPlanContext()).getMatchCandidates());
+                        PlannerGraphVisitor.show(true, rootReference, Objects.requireNonNull(plannerRepl.getPlanContext()).getMatchCandidates());
                         return false;
                     } else if ("PLANS".equals(word1)) {
-                        PlannerGraphProperty.show(PlannerGraphProperty.REMOVE_LOGICAL_EXPRESSIONS, rootReference);
+                        PlannerGraphVisitor.show(PlannerGraphVisitor.REMOVE_LOGICAL_EXPRESSIONS, rootReference);
                         return false;
                     }
                 }
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/DebuggerWithSymbolTables.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/DebuggerWithSymbolTables.java
index d0af27d77d..f1b2223b96 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/DebuggerWithSymbolTables.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/DebuggerWithSymbolTables.java
@@ -31,7 +31,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.debug.StatsMaps;
 import com.apple.foundationdb.record.query.plan.cascades.debug.eventprotos.PEvent;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
-import com.apple.foundationdb.record.query.plan.cascades.properties.ReferencesAndDependenciesProperty;
 import com.google.common.base.Verify;
 import com.google.common.cache.Cache;
 import com.google.common.collect.AbstractIterator;
@@ -59,6 +58,8 @@
 import java.util.function.IntUnaryOperator;
 import java.util.stream.Collectors;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.ReferencesAndDependenciesProperty.referencesAndDependencies;
+
 /**
  * Implementation of a debugger that maintains symbol tables for easier human consumption e.g. in test cases and/or
  * while debugging.
@@ -391,7 +392,7 @@ public static void printForEachExpression(@Nonnull final Reference root) {
     }
 
     public static void forEachExpression(@Nonnull final Reference root, @Nonnull final Consumer<RelationalExpression> consumer) {
-        final var references = ReferencesAndDependenciesProperty.evaluate(root);
+        final var references = referencesAndDependencies().evaluate(root);
         final var referenceList = TopologicalSort.anyTopologicalOrderPermutation(references).orElseThrow();
         for (final var reference : referenceList) {
             for (final var member : reference.getMembers()) {
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/PlannerRepl.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/PlannerRepl.java
index 32e0873ecc..0701fa88ab 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/PlannerRepl.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/debug/PlannerRepl.java
@@ -26,7 +26,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger;
 import com.apple.foundationdb.record.query.plan.cascades.debug.RestartException;
 import com.apple.foundationdb.record.query.plan.cascades.debug.StatsMaps;
-import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.util.ServiceLoaderProvider;
 import com.google.common.cache.Cache;
@@ -197,7 +197,7 @@ public void onSetup() {
 
     @Override
     public void onShow(@Nonnull final Reference ref) {
-        PlannerGraphProperty.show(true, ref);
+        PlannerGraphVisitor.show(true, ref);
     }
 
     @Override
diff --git a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/explain/ExplainPlanVisitorTest.java b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/explain/ExplainPlanVisitorTest.java
index cb0ae69bb5..5bbfdfc193 100644
--- a/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/explain/ExplainPlanVisitorTest.java
+++ b/fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/explain/ExplainPlanVisitorTest.java
@@ -52,6 +52,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.Reference;
 import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraph;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.ConstantObjectValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.LiteralValue;
diff --git a/fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/LuceneIndexQueryPlan.java b/fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/LuceneIndexQueryPlan.java
index 54a40a8af2..a03d119ae3 100644
--- a/fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/LuceneIndexQueryPlan.java
+++ b/fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/LuceneIndexQueryPlan.java
@@ -30,7 +30,7 @@
 import com.apple.foundationdb.record.planprotos.PRecordQueryPlan;
 import com.apple.foundationdb.record.provider.foundationdb.IndexScanParameters;
 import com.apple.foundationdb.record.query.expressions.Comparisons;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.IndexKeyValueToPartialRecord;
 import com.apple.foundationdb.record.query.plan.PlanOrderingKey;
 import com.apple.foundationdb.record.query.plan.PlanWithOrderingKey;
diff --git a/fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/LuceneIndexSpellCheckQueryPlan.java b/fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/LuceneIndexSpellCheckQueryPlan.java
index 13a7804541..7c8bd51f72 100644
--- a/fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/LuceneIndexSpellCheckQueryPlan.java
+++ b/fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/LuceneIndexSpellCheckQueryPlan.java
@@ -32,7 +32,7 @@
 import com.apple.foundationdb.record.provider.foundationdb.FDBQueriedRecord;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.provider.foundationdb.IndexScanParameters;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.IndexKeyValueToPartialRecord;
 import com.apple.foundationdb.record.query.plan.PlanOrderingKey;
 import com.apple.foundationdb.record.query.plan.explain.ExplainTokens;
diff --git a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/IndexGenerator.java b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/IndexGenerator.java
index c1cb834997..640de6b93f 100644
--- a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/IndexGenerator.java
+++ b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/IndexGenerator.java
@@ -21,7 +21,6 @@
 package com.apple.foundationdb.relational.recordlayer.query;
 
 import com.apple.foundationdb.annotation.API;
-
 import com.apple.foundationdb.record.RecordCoreException;
 import com.apple.foundationdb.record.metadata.IndexOptions;
 import com.apple.foundationdb.record.metadata.IndexPredicate;
@@ -50,7 +49,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.expressions.SelectExpression;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.AndPredicate;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.QueryPredicate;
-import com.apple.foundationdb.record.query.plan.cascades.properties.ReferencesAndDependenciesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.values.AggregateValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.ArithmeticValue;
@@ -102,6 +100,7 @@
 import static com.apple.foundationdb.record.metadata.Key.Expressions.field;
 import static com.apple.foundationdb.record.metadata.Key.Expressions.function;
 import static com.apple.foundationdb.record.metadata.Key.Expressions.keyWithValue;
+import static com.apple.foundationdb.record.query.plan.cascades.properties.ReferencesAndDependenciesProperty.referencesAndDependencies;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
 
@@ -131,7 +130,7 @@ public final class IndexGenerator {
 
     private IndexGenerator(@Nonnull RelationalExpression relationalExpression, boolean useLegacyBasedExtremumEver) {
         collectQuantifiers(relationalExpression);
-        final var partialOrder = ReferencesAndDependenciesProperty.evaluate(Reference.of(relationalExpression));
+        final var partialOrder = referencesAndDependencies().evaluate(Reference.of(relationalExpression));
         relationalExpressions =
                 TopologicalSort.anyTopologicalOrderPermutation(partialOrder)
                         .orElseThrow(() -> new RelationalException("graph has cycles", ErrorCode.UNSUPPORTED_OPERATION).toUncheckedWrappedException())
@@ -151,7 +150,7 @@ public RecordLayerIndex generate(@Nonnull String indexName, boolean isUnique, @N
 
         collectQuantifiers(relationalExpression);
 
-        final var partialOrder = ReferencesAndDependenciesProperty.evaluate(Reference.of(relationalExpression));
+        final var partialOrder = referencesAndDependencies().evaluate(Reference.of(relationalExpression));
         final var expressionRefs =
                 TopologicalSort.anyTopologicalOrderPermutation(partialOrder)
                         .orElseThrow(() -> new RecordCoreException("graph has cycles")).stream().map(Reference::get).collect(toList());
diff --git a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/PlanGenerator.java b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/PlanGenerator.java
index 5148944328..c9a73f6eef 100644
--- a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/PlanGenerator.java
+++ b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/PlanGenerator.java
@@ -21,7 +21,6 @@
 package com.apple.foundationdb.relational.recordlayer.query;
 
 import com.apple.foundationdb.annotation.API;
-
 import com.apple.foundationdb.record.IndexFetchMethod;
 import com.apple.foundationdb.record.PlanHashable;
 import com.apple.foundationdb.record.PlanSerializationContext;
@@ -35,7 +34,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.CascadesCostModel;
 import com.apple.foundationdb.record.query.plan.cascades.CascadesPlanner;
 import com.apple.foundationdb.record.query.plan.cascades.SemanticException;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan;
@@ -43,8 +41,8 @@
 import com.apple.foundationdb.record.util.pair.NonnullPair;
 import com.apple.foundationdb.relational.api.Options;
 import com.apple.foundationdb.relational.api.exceptions.ErrorCode;
-import com.apple.foundationdb.relational.api.exceptions.UncheckedRelationalException;
 import com.apple.foundationdb.relational.api.exceptions.RelationalException;
+import com.apple.foundationdb.relational.api.exceptions.UncheckedRelationalException;
 import com.apple.foundationdb.relational.api.metrics.RelationalMetric;
 import com.apple.foundationdb.relational.continuation.CompiledStatement;
 import com.apple.foundationdb.relational.continuation.TypedQueryArgument;
@@ -57,7 +55,6 @@
 import com.apple.foundationdb.relational.recordlayer.util.ExceptionUtil;
 import com.apple.foundationdb.relational.util.Assert;
 import com.apple.foundationdb.relational.util.RelationalLoggingUtil;
-
 import com.google.common.base.VerifyException;
 import com.google.common.collect.Maps;
 import com.google.protobuf.InvalidProtocolBufferException;
@@ -73,6 +70,8 @@
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty.usedTypes;
+
 @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
 @API(API.Status.EXPERIMENTAL)
 public final class PlanGenerator {
@@ -291,7 +290,7 @@ private QueryPlan.PhysicalQueryPlan generatePhysicalPlanForExecuteContinuation(@
             throw new PlanValidator.PlanValidationException("cannot continue query due to mismatch between serialized and actual plan hash");
         }
 
-        final var planTypes = UsedTypesProperty.evaluate(recordQueryPlan);
+        final var planTypes = usedTypes().evaluate(recordQueryPlan);
         final var typeRepositoryBuilder = TypeRepository.newBuilder();
         planTypes.forEach(typeRepositoryBuilder::addTypeIfNeeded);
         final var typeRepository = typeRepositoryBuilder.build();
diff --git a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlan.java b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlan.java
index d196162add..bbc0aba0ff 100644
--- a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlan.java
+++ b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlan.java
@@ -38,15 +38,14 @@
 import com.apple.foundationdb.record.query.plan.cascades.debug.Debugger;
 import com.apple.foundationdb.record.query.plan.cascades.debug.Stats;
 import com.apple.foundationdb.record.query.plan.cascades.debug.StatsMaps;
-import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.PlannerGraphVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.expressions.RelationalExpression;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.CompatibleTypeEvolutionPredicate;
 import com.apple.foundationdb.record.query.plan.cascades.predicates.DatabaseObjectDependenciesPredicate;
-import com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty;
+import com.apple.foundationdb.record.query.plan.cascades.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
 import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository;
 import com.apple.foundationdb.record.query.plan.cascades.typing.Typed;
-import com.apple.foundationdb.record.query.plan.explain.ExplainPlanVisitor;
 import com.apple.foundationdb.record.query.plan.plans.QueryResult;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryDeletePlan;
 import com.apple.foundationdb.record.query.plan.plans.RecordQueryInsertPlan;
@@ -103,6 +102,8 @@
 import java.util.Set;
 import java.util.function.Supplier;
 
+import static com.apple.foundationdb.record.query.plan.cascades.properties.UsedTypesProperty.usedTypes;
+
 public abstract class QueryPlan extends Plan<RelationalResultSet> implements Typed {
 
     protected QueryPlan(@Nonnull final String query) {
@@ -334,12 +335,12 @@ private RelationalResultSet executeExplain(@Nonnull ContinuationImpl parsedConti
                         ), plannerMetricsMetadata);
             }
 
-            final var plannerGraph = Objects.requireNonNull(recordQueryPlan.acceptPropertyVisitor(PlannerGraphProperty.forExplain()));
+            final var plannerGraph = Objects.requireNonNull(recordQueryPlan.acceptVisitor(PlannerGraphVisitor.forExplain()));
             return new IteratorResultSet(metaData, Collections.singleton(new ArrayRow(
                     explain(),
                     planHashSupplier.get(),
-                    PlannerGraphProperty.exportToDot(plannerGraph),
-                    PlannerGraphProperty.exportToGml(plannerGraph, Map.of()),
+                    PlannerGraphVisitor.exportToDot(plannerGraph),
+                    PlannerGraphVisitor.exportToGml(plannerGraph, Map.of()),
                     continuationInfo,
                     plannerMetrics)).iterator(), 0);
         }
@@ -584,7 +585,7 @@ public PhysicalQueryPlan optimize(@Nonnull CascadesPlanner planner, @Nonnull Pla
             }
             return planContext.getMetricsCollector().clock(RelationalMetric.RelationalEvent.OPTIMIZE_PLAN, () -> {
                 final TypeRepository.Builder builder = TypeRepository.newBuilder();
-                final Set<Type> usedTypes = UsedTypesProperty.evaluate(relationalExpression);
+                final Set<Type> usedTypes = usedTypes().evaluate(relationalExpression);
                 usedTypes.forEach(builder::addTypeIfNeeded);
                 final var evaluationContext = context.getEvaluationContext();
                 final var typedEvaluationContext = EvaluationContext.forBindingsAndTypeRepository(evaluationContext.getBindings(), builder.build());
@@ -604,7 +605,7 @@ public PhysicalQueryPlan optimize(@Nonnull CascadesPlanner planner, @Nonnull Pla
                 // The plan itself can introduce new types. Collect those and include them in the type repository stored with the PhysicalQueryPlan
                 final RecordQueryPlan recordQueryPlan = planResult.getPlan();
 
-                Set<Type> planTypes = UsedTypesProperty.evaluate(recordQueryPlan);
+                Set<Type> planTypes = usedTypes().evaluate(recordQueryPlan);
                 planTypes.forEach(builder::addTypeIfNeeded);
                 optimizedPlan = Optional.of(
                         new PhysicalQueryPlan(recordQueryPlan, statsMaps, builder.build(),