You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@phoenix.apache.org by ap...@apache.org on 2026/06/08 15:44:24 UTC

(phoenix) 03/08: [WIP] Split projection optimizations into SERVER PROJECTION FILTER BY in EXPLAIN

This is an automated email from the ASF dual-hosted git repository.

asf-gitbox-commits pushed a commit to branch PHOENIX-7876-feature
in repository https://gitbox.apache.org/repos/asf/phoenix.git

commit 6d0a0ec8f53cc223708ad6fde1b88788a8fda3e0
Author: Andrew Purtell <ap...@apache.org>
AuthorDate: Fri Jun 5 22:25:32 2026 -0700

    [WIP] Split projection optimizations into SERVER PROJECTION FILTER BY in EXPLAIN
    
    Rename the FIRST KEY ONLY / EMPTY COLUMN ONLY projection-optimization lines to
    SERVER PROJECTION FILTER BY ... and split the previously conflated
    "SERVER FILTER BY FIRST KEY ONLY AND <predicate>" line into a projection line
    plus a separate SERVER FILTER BY <predicate> line. Narrow the serverWhereFilter
    attribute to hold only the value predicate and add serverFirstKeyOnlyProjection /
    serverEmptyColumnOnlyProjection booleans to ExplainPlanAttributes, with matching
    assertion helpers in ExplainPlanTestUtil. Update affected UT/IT assertions to the
    fluent ExplainPlanTestUtil API where practical and rebase the remaining full-text
    plan assertions.
---
 .../phoenix/compile/ExplainPlanAttributes.java     |  57 ++++++--
 .../org/apache/phoenix/iterate/ExplainTable.java   |  46 ++++---
 .../apache/phoenix/end2end/BaseAggregateIT.java    |   8 +-
 .../end2end/BaseAggregateWithRegionMoves2IT.java   |   8 +-
 .../end2end/BaseAggregateWithRegionMovesIT.java    |   4 +-
 .../org/apache/phoenix/end2end/BaseOrderByIT.java  |   2 +-
 .../end2end/BaseOrderByWithRegionMovesIT.java      |   2 +-
 .../end2end/BaseTenantSpecificViewIndexIT.java     |   5 +-
 .../org/apache/phoenix/end2end/BaseViewIT.java     |  10 +-
 .../phoenix/end2end/CostBasedDecisionIT.java       |  44 +++---
 .../CountDistinctApproximateHyperLogLogIT.java     |   3 +-
 .../org/apache/phoenix/end2end/DerivedTableIT.java |  22 ++-
 .../org/apache/phoenix/end2end/EmptyColumnIT.java  |   2 +-
 .../end2end/ExplainPlanWithStatsDisabledIT.java    |  20 ++-
 .../phoenix/end2end/FlappingLocalIndexIT.java      |   8 +-
 .../apache/phoenix/end2end/IndexExtendedIT.java    |   5 +-
 .../org/apache/phoenix/end2end/IndexToolIT.java    |   7 +-
 .../java/org/apache/phoenix/end2end/KeyOnlyIT.java |   2 +-
 .../phoenix/end2end/LocalIndexSplitMergeIT.java    |  10 +-
 .../apache/phoenix/end2end/QueryWithLimitIT.java   |   2 +-
 .../apache/phoenix/end2end/QueryWithOffsetIT.java  |   3 +-
 .../phoenix/end2end/QueryWithTableSampleIT.java    |  14 +-
 .../org/apache/phoenix/end2end/ReverseScanIT.java  |   6 +-
 .../phoenix/end2end/SequenceBulkAllocationIT.java  |   2 +-
 .../org/apache/phoenix/end2end/SequenceIT.java     |   2 +-
 .../phoenix/end2end/SortMergeJoinMoreIT.java       |   6 +-
 .../phoenix/end2end/TenantSpecificViewIndexIT.java |  20 ++-
 .../org/apache/phoenix/end2end/UnionAllIT.java     |  12 +-
 .../phoenix/end2end/UserDefinedFunctionsIT.java    |   5 +-
 .../it/java/org/apache/phoenix/end2end/ViewIT.java |  14 +-
 .../apache/phoenix/end2end/index/BaseIndexIT.java  |  26 ++--
 .../end2end/index/BaseIndexWithRegionMovesIT.java  |  26 ++--
 .../index/ChildViewsUseParentViewIndexIT.java      |   7 +-
 .../end2end/index/GlobalIndexCheckerIT.java        |  11 +-
 .../index/GlobalIndexCheckerWithRegionMovesIT.java |  11 +-
 .../end2end/index/GlobalIndexOptimizationIT.java   |  35 +++--
 .../apache/phoenix/end2end/index/IndexUsageIT.java |  36 +++--
 .../apache/phoenix/end2end/index/LocalIndexIT.java |  57 ++++----
 .../phoenix/end2end/index/MutableIndexIT.java      |  18 ++-
 .../phoenix/end2end/index/SaltedIndexIT.java       |  22 ++-
 .../apache/phoenix/end2end/index/ViewIndexIT.java  |   4 +-
 .../end2end/join/HashJoinGlobalIndexIT.java        |  80 +++++------
 .../phoenix/end2end/join/HashJoinLocalIndexIT.java | 107 +++++++--------
 .../phoenix/end2end/join/HashJoinMoreIT.java       |   4 +-
 .../phoenix/end2end/join/HashJoinNoIndexIT.java    |  57 ++++----
 .../end2end/join/SortMergeJoinGlobalIndexIT.java   |  17 ++-
 .../end2end/join/SortMergeJoinLocalIndexIT.java    |  20 ++-
 .../end2end/join/SortMergeJoinNoIndexIT.java       |   6 +-
 .../phoenix/schema/stats/BaseStatsCollectorIT.java |   7 +-
 .../phoenix/compile/JoinQueryCompilerTest.java     |   6 +-
 .../apache/phoenix/compile/QueryCompilerTest.java  |  37 +++--
 .../compile/StatementHintsCompilationTest.java     |   3 +-
 .../TenantSpecificViewIndexCompileTest.java        | 113 ++++++---------
 .../org/apache/phoenix/query/QueryPlanTest.java    |  14 +-
 .../phoenix/query/explain/ExplainPlanTest.java     | 152 +++++++++++----------
 .../phoenix/query/explain/ExplainPlanTestUtil.java |  39 ++++++
 56 files changed, 650 insertions(+), 616 deletions(-)

diff --git a/phoenix-core-client/src/main/java/org/apache/phoenix/compile/ExplainPlanAttributes.java b/phoenix-core-client/src/main/java/org/apache/phoenix/compile/ExplainPlanAttributes.java
index af0feeccc6..9f69b2bc73 100644
--- a/phoenix-core-client/src/main/java/org/apache/phoenix/compile/ExplainPlanAttributes.java
+++ b/phoenix-core-client/src/main/java/org/apache/phoenix/compile/ExplainPlanAttributes.java
@@ -36,13 +36,13 @@ import org.apache.phoenix.schema.PColumn;
   "keyRanges", "scanTimeRangeMin", "scanTimeRangeMax", "splitsChunk", "useRoundRobinIterator",
   "samplingRate", "hexStringRVCOffset", "iteratorTypeAndScanSize", "estimatedRows",
   "estimatedSizeInBytes", "indexName", "indexKind", "saltBuckets", "regionsPlanned",
-  "serverWhereFilter", "serverDistinctFilter", "serverMergeColumns",
-  "serverArrayElementProjection", "serverAggregate", "serverGroupByLimit", "serverSortedBy",
-  "serverOffset", "serverRowLimit", "clientFilterBy", "clientAggregate", "clientDistinctFilter",
-  "clientAfterAggregate", "clientSortAlgo", "clientSortedBy", "clientOffset", "clientRowLimit",
-  "clientSequenceCount", "clientCursorName", "rhsJoinQueryExplainPlan", "subPlans",
-  "dynamicServerFilter", "afterJoinFilter", "joinScannerLimit", "sortMergeSkipMerge",
-  "regionLocations", "numRegionLocationLookups" })
+  "serverFirstKeyOnlyProjection", "serverEmptyColumnOnlyProjection", "serverWhereFilter",
+  "serverDistinctFilter", "serverMergeColumns", "serverArrayElementProjection", "serverAggregate",
+  "serverGroupByLimit", "serverSortedBy", "serverOffset", "serverRowLimit", "clientFilterBy",
+  "clientAggregate", "clientDistinctFilter", "clientAfterAggregate", "clientSortAlgo",
+  "clientSortedBy", "clientOffset", "clientRowLimit", "clientSequenceCount", "clientCursorName",
+  "rhsJoinQueryExplainPlan", "subPlans", "dynamicServerFilter", "afterJoinFilter",
+  "joinScannerLimit", "sortMergeSkipMerge", "regionLocations", "numRegionLocationLookups" })
 public class ExplainPlanAttributes {
 
   // Plan identity and scan-level metadata
@@ -69,6 +69,8 @@ public class ExplainPlanAttributes {
   private final Integer regionsPlanned;
 
   // Server-side operations
+  private final boolean serverFirstKeyOnlyProjection;
+  private final boolean serverEmptyColumnOnlyProjection;
   private final String serverWhereFilter;
   private final String serverDistinctFilter;
   private final Set<PColumn> serverMergeColumns;
@@ -125,6 +127,8 @@ public class ExplainPlanAttributes {
     this.indexKind = null;
     this.saltBuckets = null;
     this.regionsPlanned = null;
+    this.serverFirstKeyOnlyProjection = false;
+    this.serverEmptyColumnOnlyProjection = false;
     this.serverWhereFilter = null;
     this.serverDistinctFilter = null;
     this.serverMergeColumns = null;
@@ -159,7 +163,8 @@ public class ExplainPlanAttributes {
     Long scanTimeRangeMax, Integer splitsChunk, boolean useRoundRobinIterator, Double samplingRate,
     String hexStringRVCOffset, String iteratorTypeAndScanSize, Long estimatedRows,
     Long estimatedSizeInBytes, String indexName, String indexKind, Integer saltBuckets,
-    Integer regionsPlanned, String serverWhereFilter, String serverDistinctFilter,
+    Integer regionsPlanned, boolean serverFirstKeyOnlyProjection,
+    boolean serverEmptyColumnOnlyProjection, String serverWhereFilter, String serverDistinctFilter,
     Set<PColumn> serverMergeColumns, boolean serverArrayElementProjection, String serverAggregate,
     Integer serverGroupByLimit, String serverSortedBy, Integer serverOffset, Long serverRowLimit,
     String clientFilterBy, String clientAggregate, String clientDistinctFilter,
@@ -188,6 +193,8 @@ public class ExplainPlanAttributes {
     this.indexKind = indexKind;
     this.saltBuckets = saltBuckets;
     this.regionsPlanned = regionsPlanned;
+    this.serverFirstKeyOnlyProjection = serverFirstKeyOnlyProjection;
+    this.serverEmptyColumnOnlyProjection = serverEmptyColumnOnlyProjection;
     this.serverWhereFilter = serverWhereFilter;
     this.serverDistinctFilter = serverDistinctFilter;
     this.serverMergeColumns = serverMergeColumns;
@@ -293,6 +300,14 @@ public class ExplainPlanAttributes {
     return regionsPlanned;
   }
 
+  public boolean isServerFirstKeyOnlyProjection() {
+    return serverFirstKeyOnlyProjection;
+  }
+
+  public boolean isServerEmptyColumnOnlyProjection() {
+    return serverEmptyColumnOnlyProjection;
+  }
+
   public String getServerWhereFilter() {
     return serverWhereFilter;
   }
@@ -427,6 +442,8 @@ public class ExplainPlanAttributes {
     private String indexKind;
     private Integer saltBuckets;
     private Integer regionsPlanned;
+    private boolean serverFirstKeyOnlyProjection;
+    private boolean serverEmptyColumnOnlyProjection;
     private String serverWhereFilter;
     private String serverDistinctFilter;
     private Set<PColumn> serverMergeColumns;
@@ -479,6 +496,9 @@ public class ExplainPlanAttributes {
       this.indexKind = explainPlanAttributes.getIndexKind();
       this.saltBuckets = explainPlanAttributes.getSaltBuckets();
       this.regionsPlanned = explainPlanAttributes.getRegionsPlanned();
+      this.serverFirstKeyOnlyProjection = explainPlanAttributes.isServerFirstKeyOnlyProjection();
+      this.serverEmptyColumnOnlyProjection =
+        explainPlanAttributes.isServerEmptyColumnOnlyProjection();
       this.serverWhereFilter = explainPlanAttributes.getServerWhereFilter();
       this.serverDistinctFilter = explainPlanAttributes.getServerDistinctFilter();
       this.serverMergeColumns = explainPlanAttributes.getServerMergeColumns();
@@ -603,6 +623,18 @@ public class ExplainPlanAttributes {
       return this;
     }
 
+    public ExplainPlanAttributesBuilder
+      setServerFirstKeyOnlyProjection(boolean serverFirstKeyOnlyProjection) {
+      this.serverFirstKeyOnlyProjection = serverFirstKeyOnlyProjection;
+      return this;
+    }
+
+    public ExplainPlanAttributesBuilder
+      setServerEmptyColumnOnlyProjection(boolean serverEmptyColumnOnlyProjection) {
+      this.serverEmptyColumnOnlyProjection = serverEmptyColumnOnlyProjection;
+      return this;
+    }
+
     public ExplainPlanAttributesBuilder setServerWhereFilter(String serverWhereFilter) {
       this.serverWhereFilter = serverWhereFilter;
       return this;
@@ -745,10 +777,11 @@ public class ExplainPlanAttributes {
         tableName, keyRanges, scanTimeRangeMin, scanTimeRangeMax, splitsChunk,
         useRoundRobinIterator, samplingRate, hexStringRVCOffset, iteratorTypeAndScanSize,
         estimatedRows, estimatedSizeInBytes, indexName, indexKind, saltBuckets, regionsPlanned,
-        serverWhereFilter, serverDistinctFilter, serverMergeColumns, serverArrayElementProjection,
-        serverAggregate, serverGroupByLimit, serverSortedBy, serverOffset, serverRowLimit,
-        clientFilterBy, clientAggregate, clientDistinctFilter, clientAfterAggregate, clientSortAlgo,
-        clientSortedBy, clientOffset, clientRowLimit, clientSequenceCount, clientCursorName,
+        serverFirstKeyOnlyProjection, serverEmptyColumnOnlyProjection, serverWhereFilter,
+        serverDistinctFilter, serverMergeColumns, serverArrayElementProjection, serverAggregate,
+        serverGroupByLimit, serverSortedBy, serverOffset, serverRowLimit, clientFilterBy,
+        clientAggregate, clientDistinctFilter, clientAfterAggregate, clientSortAlgo, clientSortedBy,
+        clientOffset, clientRowLimit, clientSequenceCount, clientCursorName,
         rhsJoinQueryExplainPlan, subPlans, dynamicServerFilter, afterJoinFilter, joinScannerLimit,
         sortMergeSkipMerge, regionLocations, numRegionLocationLookups);
     }
diff --git a/phoenix-core-client/src/main/java/org/apache/phoenix/iterate/ExplainTable.java b/phoenix-core-client/src/main/java/org/apache/phoenix/iterate/ExplainTable.java
index 9a936dcda8..5dcb0e077c 100644
--- a/phoenix-core-client/src/main/java/org/apache/phoenix/iterate/ExplainTable.java
+++ b/phoenix-core-client/src/main/java/org/apache/phoenix/iterate/ExplainTable.java
@@ -24,7 +24,6 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
-import java.util.NoSuchElementException;
 import java.util.Set;
 import org.apache.hadoop.hbase.HRegionLocation;
 import org.apache.hadoop.hbase.client.Consistency;
@@ -54,7 +53,6 @@ import org.apache.phoenix.query.QueryServicesOptions;
 import org.apache.phoenix.schema.PColumn;
 import org.apache.phoenix.schema.PTable;
 import org.apache.phoenix.schema.PTableType;
-import org.apache.phoenix.schema.RowKeySchema;
 import org.apache.phoenix.schema.SortOrder;
 import org.apache.phoenix.schema.TableRef;
 import org.apache.phoenix.schema.types.PDataType;
@@ -72,6 +70,11 @@ public abstract class ExplainTable {
     Collections.singletonList(KeyRange.EVERYTHING_RANGE);
   public static final String POINT_LOOKUP_ON_STRING = "POINT LOOKUP ON ";
   public static final String REGION_LOCATIONS = " (region locations = ";
+  public static final String SERVER_PROJECTION_FILTER_BY_FIRST_KEY_ONLY =
+    "SERVER PROJECTION FILTER BY FIRST KEY ONLY";
+  public static final String SERVER_PROJECTION_FILTER_BY_EMPTY_COLUMN_ONLY =
+    "SERVER PROJECTION FILTER BY EMPTY COLUMN ONLY";
+  public static final String SERVER_FILTER_BY = "SERVER FILTER BY ";
 
   protected final StatementContext context;
   protected final TableRef tableRef;
@@ -183,9 +186,10 @@ public abstract class ExplainTable {
     }
     PTable table = tableRef.getTable();
     String idxName = table.getName().getString();
-    if (table.getIndexType() == PTable.IndexType.LOCAL
-      && table.getViewIndexId() != null
-      && idxName.contains(QueryConstants.CHILD_VIEW_INDEX_NAME_SEPARATOR)) {
+    if (
+      table.getIndexType() == PTable.IndexType.LOCAL && table.getViewIndexId() != null
+        && idxName.contains(QueryConstants.CHILD_VIEW_INDEX_NAME_SEPARATOR)
+    ) {
       int lastIdx = idxName.lastIndexOf(QueryConstants.CHILD_VIEW_INDEX_NAME_SEPARATOR);
       idxName = idxName.substring(lastIdx + 1);
     }
@@ -195,8 +199,7 @@ public abstract class ExplainTable {
       PTable.IndexType idxType = table.getIndexType();
       if (idxType == PTable.IndexType.LOCAL) {
         indexKindStr = "LOCAL";
-      } else if (context.isUncoveredIndex()
-        || idxType == PTable.IndexType.UNCOVERED_GLOBAL) {
+      } else if (context.isUncoveredIndex() || idxType == PTable.IndexType.UNCOVERED_GLOBAL) {
         indexKindStr = "UNCOVERED GLOBAL";
       } else if (idxType == PTable.IndexType.GLOBAL) {
         indexKindStr = "GLOBAL";
@@ -276,23 +279,26 @@ public abstract class ExplainTable {
         whereFilterStr = Bytes.toString(expBytes);
       }
     }
-    if (whereFilterStr != null) {
-      String serverWhereFilter =
-        "SERVER FILTER BY " + (firstKeyOnlyFilter == null ? "" : "FIRST KEY ONLY AND ")
-          + (emptyColumnOnlyFilter == null ? "" : "EMPTY COLUMN ONLY AND ") + whereFilterStr;
-      planSteps.add("    " + serverWhereFilter);
+    // The FIRST KEY ONLY / EMPTY COLUMN ONLY projection optimizations and the actual value
+    // predicate are emitted on separate lines. The projection lines read as predicates but are
+    // really column-projection optimizations, so they carry the PROJECTION marker, while the
+    // value predicate (if any) keeps the plain SERVER FILTER BY form.
+    if (firstKeyOnlyFilter != null) {
+      planSteps.add("    " + SERVER_PROJECTION_FILTER_BY_FIRST_KEY_ONLY);
       if (explainPlanAttributesBuilder != null) {
-        explainPlanAttributesBuilder.setServerWhereFilter(serverWhereFilter);
+        explainPlanAttributesBuilder.setServerFirstKeyOnlyProjection(true);
       }
-    } else if (firstKeyOnlyFilter != null) {
-      planSteps.add("    SERVER FILTER BY FIRST KEY ONLY");
+    }
+    if (emptyColumnOnlyFilter != null) {
+      planSteps.add("    " + SERVER_PROJECTION_FILTER_BY_EMPTY_COLUMN_ONLY);
       if (explainPlanAttributesBuilder != null) {
-        explainPlanAttributesBuilder.setServerWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        explainPlanAttributesBuilder.setServerEmptyColumnOnlyProjection(true);
       }
-    } else if (emptyColumnOnlyFilter != null) {
-      planSteps.add("    SERVER FILTER BY EMPTY COLUMN ONLY");
+    }
+    if (whereFilterStr != null) {
+      planSteps.add("    " + SERVER_FILTER_BY + whereFilterStr);
       if (explainPlanAttributesBuilder != null) {
-        explainPlanAttributesBuilder.setServerWhereFilter("SERVER FILTER BY EMPTY COLUMN ONLY");
+        explainPlanAttributesBuilder.setServerWhereFilter(whereFilterStr);
       }
     }
     if (distinctFilter != null) {
@@ -463,6 +469,7 @@ public abstract class ExplainTable {
     }
   }
 
+  @SuppressWarnings("rawtypes")
   private void appendPKColumnValue(StringBuilder buf, byte[] range, Boolean isNull, int slotIndex,
     boolean changeViewIndexId) {
     if (Boolean.TRUE.equals(isNull)) {
@@ -494,6 +501,7 @@ public abstract class ExplainTable {
     }
   }
 
+  @SuppressWarnings("rawtypes")
   private Long getViewIndexValue(PDataType type, byte[] range) {
     boolean useLongViewIndex = MetaDataUtil.getViewIndexIdDataType().equals(type);
     Object s = type.toObject(range);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateIT.java
index fde20a6130..717e48850c 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateIT.java
@@ -522,7 +522,7 @@ public abstract class BaseAggregateIT extends ParallelStatsDisabledIT {
     assertEquals(
       " ['000001111122222','333334444455555',0,*] - ['000001111122222','333334444455555',0,1]",
       explainPlanAttributes.getKeyRanges());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals(
       "SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [MATCH_STATUS, EXTERNAL_DATASOURCE_KEY]",
       explainPlanAttributes.getServerAggregate());
@@ -571,7 +571,7 @@ public abstract class BaseAggregateIT extends ParallelStatsDisabledIT {
     assertEquals("REVERSE", explainPlanAttributes.getClientSortedBy());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [K1]",
       explainPlanAttributes.getServerAggregate());
     assertFalse("Explain plan regionLocation attribute should not be empty",
@@ -628,7 +628,7 @@ public abstract class BaseAggregateIT extends ParallelStatsDisabledIT {
     assertEquals("REVERSE", explainPlanAttributes.getClientSortedBy());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [K1]",
       explainPlanAttributes.getServerAggregate());
     assertFalse("Explain plan regionLocation attribute should not be empty",
@@ -694,7 +694,7 @@ public abstract class BaseAggregateIT extends ParallelStatsDisabledIT {
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [K1]",
       explainPlanAttributes.getServerAggregate());
     TestUtil.analyzeTable(conn, tableName);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateWithRegionMoves2IT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateWithRegionMoves2IT.java
index 6ae7869cfe..6dc1866c5e 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateWithRegionMoves2IT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateWithRegionMoves2IT.java
@@ -146,7 +146,7 @@ public class BaseAggregateWithRegionMoves2IT extends ParallelStatsDisabledWithRe
     assertEquals(
       " ['000001111122222','333334444455555',0,*] - ['000001111122222','333334444455555',0,1]",
       explainPlanAttributes.getKeyRanges());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals(
       "SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [MATCH_STATUS, EXTERNAL_DATASOURCE_KEY]",
       explainPlanAttributes.getServerAggregate());
@@ -197,7 +197,7 @@ public class BaseAggregateWithRegionMoves2IT extends ParallelStatsDisabledWithRe
     assertEquals("REVERSE", explainPlanAttributes.getClientSortedBy());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [K1]",
       explainPlanAttributes.getServerAggregate());
   }
@@ -256,7 +256,7 @@ public class BaseAggregateWithRegionMoves2IT extends ParallelStatsDisabledWithRe
     assertEquals("REVERSE", explainPlanAttributes.getClientSortedBy());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [K1]",
       explainPlanAttributes.getServerAggregate());
   }
@@ -469,7 +469,7 @@ public class BaseAggregateWithRegionMoves2IT extends ParallelStatsDisabledWithRe
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [K1]",
       explainPlanAttributes.getServerAggregate());
     TestUtil.analyzeTable(conn, tableName);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateWithRegionMovesIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateWithRegionMovesIT.java
index 621a3d3380..79244ab702 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateWithRegionMovesIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseAggregateWithRegionMovesIT.java
@@ -371,7 +371,7 @@ public abstract class BaseAggregateWithRegionMovesIT
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [K1]",
       explainPlanAttributes.getServerAggregate());
     TestUtil.analyzeTable(conn, tableName);
@@ -408,7 +408,7 @@ public abstract class BaseAggregateWithRegionMovesIT
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [K1]",
       explainPlanAttributes.getServerAggregate());
     TestUtil.analyzeTable(conn, tableName);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseOrderByIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseOrderByIT.java
index 62e7a9271e..e8d19f8ba3 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseOrderByIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseOrderByIT.java
@@ -296,7 +296,7 @@ public abstract class BaseOrderByIT extends ParallelStatsDisabledIT {
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY K2 = 'ABC'", explainPlanAttributes.getServerWhereFilter());
+    assertEquals("K2 = 'ABC'", explainPlanAttributes.getServerWhereFilter());
     assertEquals("SERVER AGGREGATE INTO DISTINCT ROWS BY [K2, VAL1, VAL2]",
       explainPlanAttributes.getServerAggregate());
     assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseOrderByWithRegionMovesIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseOrderByWithRegionMovesIT.java
index bef4c8aace..a96d6e639f 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseOrderByWithRegionMovesIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseOrderByWithRegionMovesIT.java
@@ -368,7 +368,7 @@ public abstract class BaseOrderByWithRegionMovesIT extends ParallelStatsDisabled
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY K2 = 'ABC'", explainPlanAttributes.getServerWhereFilter());
+    assertEquals("K2 = 'ABC'", explainPlanAttributes.getServerWhereFilter());
     assertEquals("SERVER AGGREGATE INTO DISTINCT ROWS BY [K2, VAL1, VAL2]",
       explainPlanAttributes.getServerAggregate());
     assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseTenantSpecificViewIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseTenantSpecificViewIndexIT.java
index 539d1316ed..0963df72c6 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseTenantSpecificViewIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseTenantSpecificViewIndexIT.java
@@ -19,6 +19,7 @@ package org.apache.phoenix.end2end;
 
 import static org.apache.phoenix.thirdparty.com.google.common.collect.Sets.newHashSet;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.sql.Connection;
 import java.sql.DriverManager;
@@ -210,7 +211,7 @@ public abstract class BaseTenantSpecificViewIndexIT extends SplitSystemCatalogIT
       expectedTableName = "_IDX_" + tableName;
     }
     assertEquals(iteratorTypeAndScanSize, explainPlanAttributes.getIteratorTypeAndScanSize());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(clientSortAlgo, explainPlanAttributes.getClientSortAlgo());
     assertEquals(expectedTableName, explainPlanAttributes.getTableName());
@@ -238,7 +239,7 @@ public abstract class BaseTenantSpecificViewIndexIT extends SplitSystemCatalogIT
       .unwrap(PhoenixPreparedStatement.class).optimizeQuery().getExplainPlan();
     ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(SchemaUtil.getTableName(SchemaUtil.getSchemaNameFromFullName(viewName), indexName)
       + "(" + tableName + ")", explainPlanAttributes.getTableName());
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseViewIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseViewIT.java
index 2ca630f113..6f041f13c2 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseViewIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/BaseViewIT.java
@@ -207,14 +207,14 @@ public abstract class BaseViewIT extends ParallelStatsEnabledIT {
     String clientSortAlgo;
     String expectedTableName;
     String keyRanges;
-    String serverFilterBy;
+    boolean firstKeyOnly;
 
     if (localIndex) {
       iteratorTypeAndScanSize = "PARALLEL " + (saltBuckets == null ? 1 : saltBuckets) + "-WAY";
       expectedTableName = fullTableName;
       keyRanges = "[1,51]";
       clientSortAlgo = "CLIENT MERGE SORT";
-      serverFilterBy = "SERVER FILTER BY FIRST KEY ONLY";
+      firstKeyOnly = true;
     } else {
       iteratorTypeAndScanSize =
         saltBuckets == null ? "PARALLEL 1-WAY" : "PARALLEL " + saltBuckets + "-WAY";
@@ -224,14 +224,14 @@ public abstract class BaseViewIT extends ParallelStatsEnabledIT {
         : " [0," + Short.MIN_VALUE + ",51] - [" + (saltBuckets - 1) + "," + Short.MIN_VALUE
           + ",51]";
       clientSortAlgo = saltBuckets == null ? null : "CLIENT MERGE SORT";
-      serverFilterBy = null;
+      firstKeyOnly = false;
     }
     assertEquals(iteratorTypeAndScanSize, explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(expectedTableName, explainPlanAttributes.getTableName());
     assertEquals(clientSortAlgo, explainPlanAttributes.getClientSortAlgo());
     assertEquals(keyRanges, explainPlanAttributes.getKeyRanges());
-    assertEquals(serverFilterBy, explainPlanAttributes.getServerWhereFilter());
+    assertEquals(firstKeyOnly, explainPlanAttributes.isServerFirstKeyOnlyProjection());
 
     String viewIndexName2 = "I_" + generateUniqueName();
     if (localIndex) {
@@ -284,7 +284,7 @@ public abstract class BaseViewIT extends ParallelStatsEnabledIT {
     assertEquals(iteratorTypeAndScanSize, explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(keyRanges, explainPlanAttributes.getKeyRanges());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals(clientSortAlgo, explainPlanAttributes.getClientSortAlgo());
 
     conn.close();
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/CostBasedDecisionIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/CostBasedDecisionIT.java
index 2acfd94ca7..fa08004c32 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/CostBasedDecisionIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/CostBasedDecisionIT.java
@@ -149,8 +149,8 @@ public class CostBasedDecisionIT extends BaseTest {
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(indexName + "(" + tableName + ")", explainPlanAttributes.getTableName());
       assertEquals(" [1]", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY AND \"ROWKEY\" <= 'z'",
-        explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
+      assertEquals("\"ROWKEY\" <= 'z'", explainPlanAttributes.getServerWhereFilter());
       assertEquals("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"C1\"]",
         explainPlanAttributes.getServerAggregate());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
@@ -185,8 +185,7 @@ public class CostBasedDecisionIT extends BaseTest {
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(indexName2 + "(" + tableName + ")", explainPlanAttributes.getTableName());
       assertEquals(" [2,*] - [2,9,000]", explainPlanAttributes.getKeyRanges());
-      assertEquals(
-        "SERVER FILTER BY ((\"C1\" >= 10 AND \"C1\" <= 20) AND TO_INTEGER(\"C3\") < 5000)",
+      assertEquals("((\"C1\" >= 10 AND \"C1\" <= 20) AND TO_INTEGER(\"C3\") < 5000)",
         explainPlanAttributes.getServerWhereFilter());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
 
@@ -210,7 +209,7 @@ public class CostBasedDecisionIT extends BaseTest {
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(indexName1 + "(" + tableName + ")", explainPlanAttributes.getTableName());
       assertEquals(" [1,10] - [1,20]", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY (\"C2\" < 9000 AND \"C3\" < 5000)",
+      assertEquals("(\"C2\" < 9000 AND \"C3\" < 5000)",
         explainPlanAttributes.getServerWhereFilter());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
     } finally {
@@ -352,11 +351,13 @@ public class CostBasedDecisionIT extends BaseTest {
       verifyQueryPlan(query,
         "UNION ALL OVER 2 QUERIES\n" + "    CLIENT PARALLEL 1-WAY RANGE SCAN OVER " + indexName
           + "(" + tableName + ") [1]\n" + "        SERVER MERGE [0.C2]\n"
-          + "        SERVER FILTER BY FIRST KEY ONLY AND \"ROWKEY\" <= 'z'\n"
+          + "        SERVER PROJECTION FILTER BY FIRST KEY ONLY\n"
+          + "        SERVER FILTER BY \"ROWKEY\" <= 'z'\n"
           + "        SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"C1\"]\n"
           + "    CLIENT MERGE SORT\n" + "    CLIENT PARALLEL 1-WAY RANGE SCAN OVER " + indexName
           + "(" + tableName + ") [1]\n" + "        SERVER MERGE [0.C2]\n"
-          + "        SERVER FILTER BY FIRST KEY ONLY AND \"ROWKEY\" >= 'a'\n"
+          + "        SERVER PROJECTION FILTER BY FIRST KEY ONLY\n"
+          + "        SERVER FILTER BY \"ROWKEY\" >= 'a'\n"
           + "        SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"C1\"]\n"
           + "    CLIENT MERGE SORT");
     } finally {
@@ -405,11 +406,12 @@ public class CostBasedDecisionIT extends BaseTest {
       verifyQueryPlan(query,
         "CLIENT PARALLEL 626-WAY RANGE SCAN OVER " + indexName + "(" + tableName
           + ") [1,'X0'] - [1,'X1']\n" + "    SERVER MERGE [0.C2]\n"
-          + "    SERVER FILTER BY FIRST KEY ONLY\n" + "    SERVER SORTED BY [\"T1.:ROWKEY\"]\n"
-          + "CLIENT MERGE SORT\n" + "    PARALLEL INNER-JOIN TABLE 0\n"
-          + "        CLIENT PARALLEL 1-WAY RANGE SCAN OVER " + indexName + "(" + tableName
-          + ") [1]\n" + "            SERVER MERGE [0.C2]\n"
-          + "            SERVER FILTER BY FIRST KEY ONLY AND \"ROWKEY\" <= 'z'\n"
+          + "    SERVER PROJECTION FILTER BY FIRST KEY ONLY\n"
+          + "    SERVER SORTED BY [\"T1.:ROWKEY\"]\n" + "CLIENT MERGE SORT\n"
+          + "    PARALLEL INNER-JOIN TABLE 0\n" + "        CLIENT PARALLEL 1-WAY RANGE SCAN OVER "
+          + indexName + "(" + tableName + ") [1]\n" + "            SERVER MERGE [0.C2]\n"
+          + "            SERVER PROJECTION FILTER BY FIRST KEY ONLY\n"
+          + "            SERVER FILTER BY \"ROWKEY\" <= 'z'\n"
           + "            SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"C1\"]\n"
           + "        CLIENT MERGE SORT\n"
           + "    DYNAMIC SERVER FILTER BY \"T1.:ROWKEY\" IN (T2.MRK)");
@@ -435,13 +437,13 @@ public class CostBasedDecisionIT extends BaseTest {
       String hintedQuery = query.replaceFirst("SELECT",
         "SELECT  /*+ INDEX(" + tableName + " " + tableName + "_idx) */");
       String dataPlan = "[C1]";
-      String indexPlan =
-        "SERVER FILTER BY FIRST KEY ONLY AND (\"ROWKEY\" >= 1 AND \"ROWKEY\" <= 10)";
+      String indexPlan = "(\"ROWKEY\" >= 1 AND \"ROWKEY\" <= 10)";
 
       // Use the index table plan that opts out order-by when stats are not available.
       ExplainPlan plan = conn.prepareStatement(query).unwrap(PhoenixPreparedStatement.class)
         .optimizeQuery().getExplainPlan();
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals(indexPlan, explainPlanAttributes.getServerWhereFilter());
 
       PreparedStatement stmt =
@@ -466,6 +468,7 @@ public class CostBasedDecisionIT extends BaseTest {
       plan = conn.prepareStatement(hintedQuery).unwrap(PhoenixPreparedStatement.class)
         .optimizeQuery().getExplainPlan();
       explainPlanAttributes = plan.getPlanStepsAsAttributes();
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals(indexPlan, explainPlanAttributes.getServerWhereFilter());
     } finally {
       conn.close();
@@ -508,13 +511,13 @@ public class CostBasedDecisionIT extends BaseTest {
       assertEquals("SORT-MERGE-JOIN (INNER)", explainPlanAttributes.getAbstractExplainPlan());
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
-      assertEquals("SERVER FILTER BY COL1 < 200", explainPlanAttributes.getServerWhereFilter());
+      assertEquals("COL1 < 200", explainPlanAttributes.getServerWhereFilter());
       assertEquals(testTable500, explainPlanAttributes.getTableName());
       assertEquals("CLIENT AGGREGATE INTO SINGLE ROW", explainPlanAttributes.getClientAggregate());
       ExplainPlanAttributes rhsTable = explainPlanAttributes.getRhsJoinQueryExplainPlan();
       assertEquals("PARALLEL 1-WAY", rhsTable.getIteratorTypeAndScanSize());
       assertEquals("FULL SCAN ", rhsTable.getExplainScanType());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", rhsTable.getServerWhereFilter());
+      assertTrue(rhsTable.isServerFirstKeyOnlyProjection());
       assertEquals(testTable1000, rhsTable.getTableName());
     }
   }
@@ -680,7 +683,14 @@ public class CostBasedDecisionIT extends BaseTest {
     Connection conn = DriverManager.getConnection(getUrl(), props);
     ResultSet rs = conn.createStatement().executeQuery("explain " + query);
     String plan = QueryUtil.getExplainPlan(rs);
-    assertTrue("Expected '" + expected + "' in the plan:\n" + plan + ".", plan.contains(expected));
+    // These assertions verify cost-based plan structure (scan type, join strategy, ordering). The
+    // per-scan INDEX and REGIONS PLANNED annotations carry guidepost-derived region counts that are
+    // covered directly by the attribute-based tests, so strip them here to keep these structural
+    // substring checks stable.
+    String normalizedPlan = plan.replaceAll("(?m)^ *INDEX [^\n]*\n", "")
+      .replaceAll("(?m)^ *REGIONS PLANNED [^\n]*\n", "");
+    assertTrue("Expected '" + expected + "' in the plan:\n" + plan + ".",
+      normalizedPlan.contains(expected));
   }
 
   private static String initTestTableValues(int rows) throws Exception {
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/CountDistinctApproximateHyperLogLogIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/CountDistinctApproximateHyperLogLogIT.java
index 193e0bf0fc..c8a131cc80 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/CountDistinctApproximateHyperLogLogIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/CountDistinctApproximateHyperLogLogIT.java
@@ -19,6 +19,7 @@ package org.apache.phoenix.end2end;
 
 import static org.apache.phoenix.util.TestUtil.TEST_PROPERTIES;
 import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
 import java.sql.*;
 import java.util.Properties;
@@ -130,7 +131,7 @@ public class CountDistinctApproximateHyperLogLogIT extends ParallelStatsDisabled
       assertEquals(tableName, explainPlanAttributes.getTableName());
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals("SERVER AGGREGATE INTO SINGLE ROW", explainPlanAttributes.getServerAggregate());
     }
   }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/DerivedTableIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/DerivedTableIT.java
index d6cde17cf0..d35960fae9 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/DerivedTableIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/DerivedTableIT.java
@@ -114,28 +114,38 @@ public class DerivedTableIT extends ParallelStatsDisabledIT {
     testCases.add(new String[][] {
       { "CREATE INDEX " + dynamicTableName + "_DERIVED_IDX ON " + dynamicTableName
         + " (a_byte) INCLUDE (A_STRING, B_STRING)" },
-      { "CLIENT PARALLEL 1-WAY FULL SCAN OVER " + dynamicTableName + "_DERIVED_IDX \n"
+      { "CLIENT PARALLEL 1-WAY FULL SCAN OVER " + dynamicTableName + "_DERIVED_IDX\n"
         + "    SERVER AGGREGATE INTO DISTINCT ROWS BY [\"A_STRING\", \"B_STRING\"]\n"
         + "CLIENT MERGE SORT\n" + "CLIENT SORTED BY [\"B_STRING\"]\n" + "CLIENT SORTED BY [A]\n"
         + "CLIENT AGGREGATE INTO DISTINCT ROWS BY [A]\n" + "CLIENT SORTED BY [A DESC]",
 
-        "CLIENT PARALLEL 1-WAY FULL SCAN OVER " + dynamicTableName + "_DERIVED_IDX \n"
+        "CLIENT PARALLEL 1-WAY FULL SCAN OVER " + dynamicTableName + "_DERIVED_IDX\n"
           + "    SERVER AGGREGATE INTO DISTINCT ROWS BY [\"A_STRING\", \"B_STRING\"]\n"
           + "CLIENT MERGE SORT\n" + "CLIENT AGGREGATE INTO ORDERED DISTINCT ROWS BY [A]\n"
           + "CLIENT DISTINCT ON [COLLECTDISTINCT(B)]\n" + "CLIENT SORTED BY [A DESC]" } });
     testCases.add(new String[][] { {},
-      { "CLIENT PARALLEL 4-WAY FULL SCAN OVER " + dynamicTableName + " \n"
+      { "CLIENT PARALLEL 4-WAY FULL SCAN OVER " + dynamicTableName + "\n"
         + "    SERVER AGGREGATE INTO DISTINCT ROWS BY [A_STRING, B_STRING]\n"
         + "CLIENT MERGE SORT\n" + "CLIENT SORTED BY [B_STRING]\n" + "CLIENT SORTED BY [A]\n"
         + "CLIENT AGGREGATE INTO DISTINCT ROWS BY [A]\n" + "CLIENT SORTED BY [A DESC]",
 
-        "CLIENT PARALLEL 4-WAY FULL SCAN OVER " + dynamicTableName + " \n"
+        "CLIENT PARALLEL 4-WAY FULL SCAN OVER " + dynamicTableName + "\n"
           + "    SERVER AGGREGATE INTO DISTINCT ROWS BY [A_STRING, B_STRING]\n"
           + "CLIENT MERGE SORT\n" + "CLIENT AGGREGATE INTO ORDERED DISTINCT ROWS BY [A]\n"
           + "CLIENT DISTINCT ON [COLLECTDISTINCT(B)]\n" + "CLIENT SORTED BY [A DESC]" } });
     return testCases;
   }
 
+  /**
+   * Removes the per-scan {@code INDEX} and {@code REGIONS PLANNED} annotation lines so these
+   * structural plan assertions stay stable; those attributes are covered by the attribute-based
+   * tests and {@code REGIONS PLANNED} carries an environment-dependent region count.
+   */
+  private static String stripScanAnnotations(String plan) {
+    return plan.replaceAll("(?m)^ *INDEX [^\n]*\n", "")
+      .replaceAll("(?m)^ *REGIONS PLANNED [^\n]*\n", "");
+  }
+
   @Test
   public void testDerivedTableWithWhere() throws Exception {
     Properties props = PropertiesUtil.deepCopy(TEST_PROPERTIES);
@@ -389,7 +399,7 @@ public class DerivedTableIT extends ParallelStatsDisabledIT {
       LOGGER.info("Explain plan output: {}", explainPlanOutput);
       String[] splitExplainPlan = explainPlanOutput.split("\\n \\(region locations = \\[region=");
       String[] secondSplitExplainPlan = splitExplainPlan[1].split("]\\)");
-      assertEquals(plans[0], splitExplainPlan[0] + secondSplitExplainPlan[1]);
+      assertEquals(plans[0], stripScanAnnotations(splitExplainPlan[0] + secondSplitExplainPlan[1]));
 
       // distinct b (groupby a, b) groupby a orderby a
       query = "SELECT DISTINCT COLLECTDISTINCT(t.b) FROM (SELECT b_string b, a_string a FROM "
@@ -416,7 +426,7 @@ public class DerivedTableIT extends ParallelStatsDisabledIT {
       LOGGER.info("Explain plan output: {}", explainPlanOutput);
       splitExplainPlan = explainPlanOutput.split("\\n \\(region locations = \\[region=");
       secondSplitExplainPlan = splitExplainPlan[1].split("]\\)");
-      assertEquals(plans[1], splitExplainPlan[0] + secondSplitExplainPlan[1]);
+      assertEquals(plans[1], stripScanAnnotations(splitExplainPlan[0] + secondSplitExplainPlan[1]));
 
       // (orderby) groupby
       query = "SELECT t.a_string, count(*) FROM (SELECT * FROM " + tableName
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/EmptyColumnIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/EmptyColumnIT.java
index 45ba6fc22d..d52749615d 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/EmptyColumnIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/EmptyColumnIT.java
@@ -748,7 +748,7 @@ public class EmptyColumnIT extends ParallelStatsDisabledIT {
         EnvironmentEdgeManager.injectEdge(injectEdge);
         String distinctQuery = "SELECT DISTINCT id1 FROM " + dataTableName;
         ExplainPlanAttributes attributes = getExplainAttributes(conn, distinctQuery);
-        assertPlan(attributes).serverWhereFilter("SERVER FILTER BY EMPTY COLUMN ONLY");
+        assertPlan(attributes).serverEmptyColumnOnlyProjection(true);
         assertNotNull(attributes.getServerDistinctFilter());
         try (ResultSet rs = conn.createStatement().executeQuery(distinctQuery)) {
           // all the rows should have been masked
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/ExplainPlanWithStatsDisabledIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/ExplainPlanWithStatsDisabledIT.java
index 7b771c8e1d..cfb7731f07 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/ExplainPlanWithStatsDisabledIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/ExplainPlanWithStatsDisabledIT.java
@@ -259,7 +259,7 @@ public class ExplainPlanWithStatsDisabledIT extends ParallelStatsDisabledIT {
       assertPlan(conn, query).scanType("RANGE SCAN").table("FOO")
         .keyRanges(
           " [X'00','a',~'2016-01-28 23:59:59.999'] -" + " [X'13','a',~'2016-01-28 00:00:00.000']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+        .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT");
     }
   }
 
@@ -279,7 +279,7 @@ public class ExplainPlanWithStatsDisabledIT extends ParallelStatsDisabledIT {
       assertPlan(conn, query).useRoundRobinIterator(true).scanType("RANGE SCAN").table(tableName)
         .keyRanges(
           " [X'00','a',~'2016-01-28 23:59:59.999'] -" + " [X'13','a',~'2016-01-28 00:00:00.000']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .serverFirstKeyOnlyProjection(true);
     }
   }
 
@@ -347,8 +347,7 @@ public class ExplainPlanWithStatsDisabledIT extends ParallelStatsDisabledIT {
         .optimizeQuery().getExplainPlan();
       ExplainPlanAttributes planAttributes = plan.getPlanStepsAsAttributes();
       assertPlan(planAttributes).scanType("RANGE SCAN").table(tableName).keyRanges(" [*] - ['b']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
+        .serverFirstKeyOnlyProjection(true).serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
       assertEquals(2, planAttributes.getNumRegionLocationLookups());
 
       query = "select count(*) from " + tableName + " where PK1 <= 'cd'";
@@ -359,8 +358,7 @@ public class ExplainPlanWithStatsDisabledIT extends ParallelStatsDisabledIT {
         .getExplainPlan();
       planAttributes = plan.getPlanStepsAsAttributes();
       assertPlan(planAttributes).scanType("RANGE SCAN").table(tableName).keyRanges(" [*] - ['cd']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
+        .serverFirstKeyOnlyProjection(true).serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
       assertEquals(3, planAttributes.getNumRegionLocationLookups());
 
       query = "select count(*) from " + tableName + " where PK1 LIKE 'ef%'";
@@ -371,7 +369,7 @@ public class ExplainPlanWithStatsDisabledIT extends ParallelStatsDisabledIT {
         .getExplainPlan();
       planAttributes = plan.getPlanStepsAsAttributes();
       assertPlan(planAttributes).scanType("RANGE SCAN").table(tableName)
-        .keyRanges(" ['ef'] - ['eg']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .keyRanges(" ['ef'] - ['eg']").serverFirstKeyOnlyProjection(true)
         .serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
       assertEquals(1, planAttributes.getNumRegionLocationLookups());
 
@@ -383,8 +381,7 @@ public class ExplainPlanWithStatsDisabledIT extends ParallelStatsDisabledIT {
         .getExplainPlan();
       planAttributes = plan.getPlanStepsAsAttributes();
       assertPlan(planAttributes).scanType("RANGE SCAN").table(tableName).keyRanges(" ['de'] - [*]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
+        .serverFirstKeyOnlyProjection(true).serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
       assertEquals(1, planAttributes.getNumRegionLocationLookups());
     }
   }
@@ -483,8 +480,7 @@ public class ExplainPlanWithStatsDisabledIT extends ParallelStatsDisabledIT {
           .optimizeQuery().getExplainPlan();
         ExplainPlanAttributes planAttributes = plan.getPlanStepsAsAttributes();
         assertPlan(planAttributes).scanType("RANGE SCAN").table(tableName).keyRanges(" ['ab12']")
-          .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-          .serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
+          .serverFirstKeyOnlyProjection(true).serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
         assertEquals(1, planAttributes.getNumRegionLocationLookups());
       }
 
@@ -512,7 +508,7 @@ public class ExplainPlanWithStatsDisabledIT extends ParallelStatsDisabledIT {
           .optimizeQuery().getExplainPlan();
         ExplainPlanAttributes planAttributes = plan.getPlanStepsAsAttributes();
         assertPlan(planAttributes).scanType("RANGE SCAN").table(tableName).keyRanges(" ['de12']")
-          .serverWhereFilter("SERVER FILTER BY COL1 = 'col101'");
+          .serverWhereFilter("COL1 = 'col101'");
         assertEquals(1, planAttributes.getNumRegionLocationLookups());
       }
     }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/FlappingLocalIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/FlappingLocalIndexIT.java
index d84c3f6bb6..30b5da008d 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/FlappingLocalIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/FlappingLocalIndexIT.java
@@ -189,7 +189,7 @@ public class FlappingLocalIndexIT extends BaseLocalIndexIT {
       assertEquals(indexTableName + "(" + indexPhysicalTableName + ")",
         explainPlanAttributes.getTableName());
       assertEquals(" [1,'a'] - [1,'b']", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
       assertEquals(trimmedRegionLocations, explainPlanAttributes.getRegionLocations().size());
 
@@ -218,7 +218,7 @@ public class FlappingLocalIndexIT extends BaseLocalIndexIT {
       assertEquals(indexTableName + "(" + indexPhysicalTableName + ")",
         explainPlanAttributes.getTableName());
       assertEquals(" [1,'a']", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
 
       rs = conn1.createStatement().executeQuery(query);
@@ -242,7 +242,7 @@ public class FlappingLocalIndexIT extends BaseLocalIndexIT {
       assertEquals(indexTableName + "(" + indexPhysicalTableName + ")",
         explainPlanAttributes.getTableName());
       assertEquals(" [1,*] - [1,'z']", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
       assertEquals("[\"K3\"]", explainPlanAttributes.getServerSortedBy());
 
@@ -272,7 +272,7 @@ public class FlappingLocalIndexIT extends BaseLocalIndexIT {
       assertEquals(indexTableName + "(" + indexPhysicalTableName + ")",
         explainPlanAttributes.getTableName());
       assertEquals(" [1]", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
       assertNull(explainPlanAttributes.getServerSortedBy());
 
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/IndexExtendedIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/IndexExtendedIT.java
index d633c064e9..c8f1ef665c 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/IndexExtendedIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/IndexExtendedIT.java
@@ -184,8 +184,7 @@ public class IndexExtendedIT extends BaseTest {
       assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
       // assert we are pulling from data table.
       assertEquals(dataTableFullName, explainPlanAttributes.getTableName());
-      assertEquals("SERVER FILTER BY UPPER(NAME, 'en_US') = 'UNAME2'",
-        explainPlanAttributes.getServerWhereFilter());
+      assertEquals("UPPER(NAME, 'en_US') = 'UNAME2'", explainPlanAttributes.getServerWhereFilter());
 
       ResultSet rs = stmt1.executeQuery(selectSql);
       assertTrue(rs.next());
@@ -265,7 +264,7 @@ public class IndexExtendedIT extends BaseTest {
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(indexTableFullName, explainPlanAttributes.getTableName());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
 
       ResultSet rs = conn.createStatement().executeQuery(query);
       assertTrue(rs.next());
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/IndexToolIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/IndexToolIT.java
index 948607a24f..d2d034e088 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/IndexToolIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/IndexToolIT.java
@@ -319,8 +319,7 @@ public class IndexToolIT extends BaseTest {
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(dataTableFullName, explainPlanAttributes.getTableName().replaceAll(":", "."));
-      assertEquals(
-        "SERVER FILTER BY (LPAD(UPPER(NAME, 'en_US'), 8, 'x') || '_xyz') = 'xxUNAME2_xyz'",
+      assertEquals("(LPAD(UPPER(NAME, 'en_US'), 8, 'x') || '_xyz') = 'xxUNAME2_xyz'",
         explainPlanAttributes.getServerWhereFilter().replaceAll(":", "."));
 
       ResultSet rs = conn.createStatement().executeQuery(selectSql);
@@ -782,8 +781,8 @@ public class IndexToolIT extends BaseTest {
 
       // assert we are pulling from data table.
       ExplainPlanAttributes dataAttributes = getExplainAttributes(conn, selectSql);
-      assertPlan(dataAttributes).scanType("FULL SCAN").serverWhereFilter(
-        "SERVER FILTER BY (LPAD(UPPER(NAME, 'en_US'), 8, 'x') || '_xyz') = 'xxUNAME2_xyz'");
+      assertPlan(dataAttributes).scanType("FULL SCAN")
+        .serverWhereFilter("(LPAD(UPPER(NAME, 'en_US'), 8, 'x') || '_xyz') = 'xxUNAME2_xyz'");
       // Table names are case-sensitive and (under namespace mapping) carry a ':' separator, so
       // compare against the normalized ('.') form rather than via tableContains().
       String dataScanTable = dataAttributes.getTableName() == null
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/KeyOnlyIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/KeyOnlyIT.java
index e500cb4021..5f8f935e36 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/KeyOnlyIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/KeyOnlyIT.java
@@ -151,7 +151,7 @@ public class KeyOnlyIT extends ParallelStatsEnabledIT {
     assertEquals("SERIAL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals(1, explainPlanAttributes.getServerRowLimit().intValue());
     assertEquals(1, explainPlanAttributes.getClientRowLimit().intValue());
   }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/LocalIndexSplitMergeIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/LocalIndexSplitMergeIT.java
index e654fe0c19..eabea6596d 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/LocalIndexSplitMergeIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/LocalIndexSplitMergeIT.java
@@ -152,8 +152,7 @@ public class LocalIndexSplitMergeIT extends BaseTest {
         assertEquals(fullIndexName + "(" + indexPhysicalTableName + ")",
           explainPlanAttributes.getTableName());
         assertEquals(" [1]", explainPlanAttributes.getKeyRanges());
-        assertEquals("SERVER FILTER BY FIRST KEY ONLY",
-          explainPlanAttributes.getServerWhereFilter());
+        assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
         assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
 
         query = "SELECT t_id,k1,k3 FROM " + tableName;
@@ -167,8 +166,7 @@ public class LocalIndexSplitMergeIT extends BaseTest {
         assertEquals(fullIndexName + "_2(" + indexPhysicalTableName + ")",
           explainPlanAttributes.getTableName());
         assertEquals(" [2]", explainPlanAttributes.getKeyRanges());
-        assertEquals("SERVER FILTER BY FIRST KEY ONLY",
-          explainPlanAttributes.getServerWhereFilter());
+        assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
         assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
 
         rs = conn1.createStatement().executeQuery(query);
@@ -253,7 +251,7 @@ public class LocalIndexSplitMergeIT extends BaseTest {
       assertEquals(fullIndexName + "(" + indexPhysicalTableName + ")",
         explainPlanAttributes.getTableName());
       assertEquals(" [1]", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
 
       query = "SELECT t_id,k1,k3 FROM " + tableName;
@@ -265,7 +263,7 @@ public class LocalIndexSplitMergeIT extends BaseTest {
       assertEquals(fullIndexName + "_2(" + indexPhysicalTableName + ")",
         explainPlanAttributes.getTableName());
       assertEquals(" [2]", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
 
       rs = conn1.createStatement().executeQuery(query);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithLimitIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithLimitIT.java
index 2278f7341c..c5d06ea46d 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithLimitIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithLimitIT.java
@@ -97,7 +97,7 @@ public class QueryWithLimitIT extends BaseTest {
       assertEquals("SERIAL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(tableName, explainPlanAttributes.getTableName());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals(1, explainPlanAttributes.getServerRowLimit().intValue());
       assertEquals(1, explainPlanAttributes.getClientRowLimit().intValue());
     } finally {
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithOffsetIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithOffsetIT.java
index 65ec34ff08..8bab202020 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithOffsetIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithOffsetIT.java
@@ -134,8 +134,7 @@ public class QueryWithOffsetIT extends ParallelStatsDisabledIT {
     ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY EMPTY COLUMN ONLY",
-      explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerEmptyColumnOnlyProjection());
     if (!isSalted) {
       assertEquals("SERIAL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals(offset, explainPlanAttributes.getServerOffset().intValue());
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithTableSampleIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithTableSampleIT.java
index ddbf213c45..04068fee05 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithTableSampleIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/QueryWithTableSampleIT.java
@@ -212,7 +212,7 @@ public class QueryWithTableSampleIT extends ParallelStatsEnabledIT {
       prepareTableWithValues(conn, 100);
       String query = "SELECT i1, i2 FROM " + tableName + " tablesample (45) ";
       assertPlan(conn, query).iteratorType("PARALLEL").scanType("FULL SCAN").samplingRate(0.45d)
-        .table(tableName).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .table(tableName).serverFirstKeyOnlyProjection(true);
     }
   }
 
@@ -227,9 +227,9 @@ public class QueryWithTableSampleIT extends ParallelStatsEnabledIT {
           + tableName + " tablesample (2) where i2<6000";
       assertPlan(conn, query).abstractExplainPlan("UNION ALL OVER 2 QUERIES").scanType("RANGE SCAN")
         .table(tableName).keyRanges(" [*] - [2]").samplingRate(1.0d)
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").rhs().scanType("FULL SCAN")
-        .table(tableName).samplingRate(0.02d)
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND I2 < 6000").end();
+        .serverFirstKeyOnlyProjection(true).rhs().scanType("FULL SCAN").table(tableName)
+        .samplingRate(0.02d).serverFirstKeyOnlyProjection(true).serverWhereFilter("I2 < 6000")
+        .end();
     } finally {
       conn.close();
     }
@@ -245,12 +245,10 @@ public class QueryWithTableSampleIT extends ParallelStatsEnabledIT {
         + joinedTableName + " as B tablesample (75) where A.i1=B.i1";
 
       assertPlan(conn, query).scanType("FULL SCAN").table(tableName).samplingRate(0.45d)
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .serverAggregate("SERVER AGGREGATE INTO SINGLE ROW")
+        .serverFirstKeyOnlyProjection(true).serverAggregate("SERVER AGGREGATE INTO SINGLE ROW")
         .dynamicServerFilter("DYNAMIC SERVER FILTER BY A.I1 IN (B.I1)").subPlanCount(1).subPlan(0)
         .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0 (SKIP MERGE)").scanType("FULL SCAN")
-        .table(joinedTableName).samplingRate(0.75d)
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+        .table(joinedTableName).samplingRate(0.75d).serverFirstKeyOnlyProjection(true).end();
     } finally {
       conn.close();
     }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/ReverseScanIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/ReverseScanIT.java
index 2fcf0c6a3e..64e1d94f40 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/ReverseScanIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/ReverseScanIT.java
@@ -88,8 +88,8 @@ public class ReverseScanIT extends ParallelStatsDisabledIT {
       assertEquals("REVERSE", explainPlanAttributes.getClientSortedBy());
       assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(tableName, explainPlanAttributes.getTableName());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY AND ENTITY_ID >= '00A323122312312'",
-        explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
+      assertEquals("ENTITY_ID >= '00A323122312312'", explainPlanAttributes.getServerWhereFilter());
 
       PreparedStatement statement = conn.prepareStatement("SELECT entity_id FROM " + tableName
         + " WHERE organization_id = ? AND entity_id >= ? ORDER BY organization_id DESC, entity_id DESC");
@@ -193,7 +193,7 @@ public class ReverseScanIT extends ParallelStatsDisabledIT {
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(indexName, explainPlanAttributes.getTableName());
       assertEquals(" [not null]", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals(1, explainPlanAttributes.getServerRowLimit().intValue());
       assertEquals(1, explainPlanAttributes.getClientRowLimit().intValue());
     }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/SequenceBulkAllocationIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/SequenceBulkAllocationIT.java
index 85133397d4..d57a9ce059 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/SequenceBulkAllocationIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/SequenceBulkAllocationIT.java
@@ -831,7 +831,7 @@ public class SequenceBulkAllocationIT extends ParallelStatsDisabledIT {
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals(1, explainPlanAttributes.getClientSequenceCount().intValue());
   }
 
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/SequenceIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/SequenceIT.java
index 3cc3a0510d..0837d75f49 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/SequenceIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/SequenceIT.java
@@ -830,7 +830,7 @@ public class SequenceIT extends ParallelStatsDisabledIT {
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(tableName, explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals(1, explainPlanAttributes.getClientSequenceCount().intValue());
 
     ResultSet rs = conn.createStatement().executeQuery(
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/SortMergeJoinMoreIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/SortMergeJoinMoreIT.java
index bfb01ff0f9..0116d31e1a 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/SortMergeJoinMoreIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/SortMergeJoinMoreIT.java
@@ -428,15 +428,15 @@ public class SortMergeJoinMoreIT extends ParallelStatsDisabledIT {
 
         assertPlan(conn, q).abstractExplainPlan("SORT-MERGE-JOIN (INNER)").sortMergeSkipMerge(true)
           .iteratorType("PARALLEL").scanType("SKIP SCAN ON 2 RANGES").table(eventCountTableName)
-          .keyRanges(lhsKeyRanges).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+          .keyRanges(lhsKeyRanges).serverFirstKeyOnlyProjection(true)
           .serverDistinctFilter("SERVER DISTINCT PREFIX FILTER OVER [BUCKET, TIMESTAMP, LOCATION]")
           .serverAggregate(
             "SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [BUCKET, TIMESTAMP, LOCATION]")
           .clientSortAlgo("CLIENT MERGE SORT").clientSortedBy("[BUCKET, TIMESTAMP]")
           .clientAggregate("CLIENT AGGREGATE INTO ORDERED DISTINCT ROWS BY [E.BUCKET, E.TIMESTAMP]")
           .rhs().iteratorType("PARALLEL").scanType("SKIP SCAN ON 2 RANGES").table(t[i])
-          .keyRanges(rhsKeyRanges)
-          .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND SRC_LOCATION = DST_LOCATION")
+          .keyRanges(rhsKeyRanges).serverFirstKeyOnlyProjection(true)
+          .serverWhereFilter("SRC_LOCATION = DST_LOCATION")
           .serverDistinctFilter(
             "SERVER DISTINCT PREFIX FILTER OVER [BUCKET, \"TIMESTAMP\", SRC_LOCATION, DST_LOCATION]")
           .serverAggregate(
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/TenantSpecificViewIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/TenantSpecificViewIndexIT.java
index 35614d565d..0a8ef6a425 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/TenantSpecificViewIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/TenantSpecificViewIndexIT.java
@@ -224,7 +224,7 @@ public class TenantSpecificViewIndexIT extends BaseTenantSpecificViewIndexIT {
     explainPlanAttributes = plan.getPlanStepsAsAttributes();
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     if (localIndex) {
       assertEquals(fullIndexName + "("
         + SchemaUtil.getPhysicalTableName(Bytes.toBytes(tableName), isNamespaceMapped).toString()
@@ -366,10 +366,10 @@ public class TenantSpecificViewIndexIT extends BaseTenantSpecificViewIndexIT {
       String exptectedIndexName = SchemaUtil.getTableName(SCHEMA1, "IDX");
       String expectedPlanFormat = "CLIENT SERIAL 1-WAY RANGE SCAN OVER " + exptectedIndexName
         + " ['tenant1        ','001','%s 00:00:00.001'] - ['tenant1        ','001','%s 00:00:00.000']"
-        + "\n" + "    SERVER FILTER BY FIRST KEY ONLY" + "\n" + "    SERVER 501 ROW LIMIT" + "\n"
-        + "CLIENT 501 ROW LIMIT";
+        + "\n" + "    SERVER PROJECTION FILTER BY FIRST KEY ONLY" + "\n"
+        + "    SERVER 501 ROW LIMIT" + "\n" + "CLIENT 501 ROW LIMIT";
       assertEquals(String.format(expectedPlanFormat, "2011-01-01", "2016-10-31"),
-        QueryUtil.getExplainPlan(rs));
+        stripScanAnnotations(QueryUtil.getExplainPlan(rs)));
 
       query = "EXPLAIN SELECT PARENT_ID FROM " + viewName + " WHERE PARENT_TYPE='001' "
         + " AND (CREATED_DATE >= to_date('2011-01-01') AND CREATED_DATE <= to_date('2016-01-01'))"
@@ -378,10 +378,20 @@ public class TenantSpecificViewIndexIT extends BaseTenantSpecificViewIndexIT {
 
       rs = viewConn.createStatement().executeQuery(query);
       assertEquals(String.format(expectedPlanFormat, "2012-10-21", "2016-01-01"),
-        QueryUtil.getExplainPlan(rs));
+        stripScanAnnotations(QueryUtil.getExplainPlan(rs)));
     }
   }
 
+  /**
+   * Removes the per-scan {@code INDEX} and {@code REGIONS PLANNED} annotation lines so this plan
+   * assertion stays stable; those attributes are covered by the attribute-based tests and
+   * {@code REGIONS PLANNED} carries an environment-dependent region count.
+   */
+  private static String stripScanAnnotations(String plan) {
+    return plan.replaceAll("(?m)^ *INDEX [^\n]*\n", "")
+      .replaceAll("(?m)^ *REGIONS PLANNED [^\n]*\n", "");
+  }
+
   @Test
   public void testCurrentTimeWithViewIndexes() throws Exception {
 
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/UnionAllIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/UnionAllIT.java
index 208e18f88e..e468e6a7ba 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/UnionAllIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/UnionAllIT.java
@@ -671,7 +671,7 @@ public class UnionAllIT extends ParallelStatsDisabledIT {
       Statement stmt = conn.createStatement();
       stmt.setMaxRows(2);
       ResultSet rs = stmt.executeQuery("explain " + ddl);
-      assertEquals(limitPlan, QueryUtil.getExplainPlan(rs));
+      assertEquals(limitPlan, stripScanAnnotations(QueryUtil.getExplainPlan(rs)));
 
       ddl = "select a_string, col1 from " + tableName1 + " union all select a_string, col1 from "
         + tableName2;
@@ -689,6 +689,16 @@ public class UnionAllIT extends ParallelStatsDisabledIT {
     }
   }
 
+  /**
+   * Removes the per-scan {@code INDEX} and {@code REGIONS PLANNED} annotation lines so this
+   * structural plan assertion stays stable; those attributes are covered by the attribute-based
+   * assertions above and {@code REGIONS PLANNED} carries an environment-dependent region count.
+   */
+  private static String stripScanAnnotations(String plan) {
+    return plan.replaceAll("(?m)^ *INDEX [^\n]*\n", "")
+      .replaceAll("(?m)^ *REGIONS PLANNED [^\n]*\n", "");
+  }
+
   @Test
   public void testBug2295() throws Exception {
     String tableName1 = generateUniqueName();
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/UserDefinedFunctionsIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/UserDefinedFunctionsIT.java
index 4f174bb2b2..6e76342fac 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/UserDefinedFunctionsIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/UserDefinedFunctionsIT.java
@@ -28,6 +28,7 @@ import static org.apache.phoenix.util.TestUtil.JOIN_ITEM_TABLE_FULL_NAME;
 import static org.apache.phoenix.util.TestUtil.JOIN_SUPPLIER_TABLE_FULL_NAME;
 import static org.apache.phoenix.util.TestUtil.LOCALHOST;
 import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -848,7 +849,7 @@ public class UserDefinedFunctionsIT extends BaseOwnClusterIT {
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals("IDX", explainPlanAttributes.getTableName());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
 
     ResultSet rs = stmt.executeQuery(query);
     assertTrue(rs.next());
@@ -865,7 +866,7 @@ public class UserDefinedFunctionsIT extends BaseOwnClusterIT {
     assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals("IDX2(T5)", explainPlanAttributes.getTableName());
     assertEquals(" [1,'kcoj']", explainPlanAttributes.getKeyRanges());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
 
     rs = stmt.executeQuery(query);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/ViewIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/ViewIT.java
index c58946caae..73055cec08 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/ViewIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/ViewIT.java
@@ -528,7 +528,7 @@ public class ViewIT extends SplitSystemCatalogIT {
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("SKIP SCAN ON 4 KEYS ", explainPlanAttributes.getExplainScanType());
-      assertEquals("SERVER FILTER BY (\"S2\" = 'bas' AND \"S1\" = 'foo')",
+      assertEquals("(\"S2\" = 'bas' AND \"S1\" = 'foo')",
         explainPlanAttributes.getServerWhereFilter());
 
       // Assert that in either case (local & global) that index from
@@ -990,10 +990,8 @@ public class ViewIT extends SplitSystemCatalogIT {
         assertEquals(viewIndexFullName1 + "(" + fullTableName + ")",
           explainPlanAttributes.getTableName());
         assertEquals(" [1,51]", explainPlanAttributes.getKeyRanges());
-        assertTrue(
-          explainPlanAttributes.getServerWhereFilter().equals("SERVER FILTER BY FIRST KEY ONLY")
-            || explainPlanAttributes.getServerWhereFilter()
-              .equals("SERVER FILTER BY EMPTY COLUMN ONLY"));
+        assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection()
+          || explainPlanAttributes.isServerEmptyColumnOnlyProjection());
         assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
       } else {
         assertEquals(viewIndexPhysicalName, explainPlanAttributes.getTableName());
@@ -1042,10 +1040,8 @@ public class ViewIT extends SplitSystemCatalogIT {
         .getExplainPlan();
       explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
-      assertTrue(
-        explainPlanAttributes.getServerWhereFilter().equals("SERVER FILTER BY FIRST KEY ONLY")
-          || explainPlanAttributes.getServerWhereFilter()
-            .equals("SERVER FILTER BY EMPTY COLUMN ONLY"));
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection()
+        || explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       if (localIndex) {
         physicalTableName = fullTableName;
         assertEquals("PARALLEL " + (saltBuckets == null ? 1 : saltBuckets) + "-WAY",
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/BaseIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/BaseIndexIT.java
index 48b64bc1cc..8e85bdaff1 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/BaseIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/BaseIndexIT.java
@@ -158,9 +158,9 @@ public abstract class BaseIndexIT extends ParallelStatsDisabledIT {
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       if (!uncovered) {
         // Optimizer would not select the uncovered index for this query
-        assertEquals(
-          columnEncoded ? "SERVER FILTER BY FIRST KEY ONLY" : "SERVER FILTER BY EMPTY COLUMN ONLY",
-          explainPlanAttributes.getServerWhereFilter());
+        assertTrue(columnEncoded
+          ? explainPlanAttributes.isServerFirstKeyOnlyProjection()
+          : explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       }
 
       if (localIndex) {
@@ -588,9 +588,9 @@ public abstract class BaseIndexIT extends ParallelStatsDisabledIT {
         .optimizeQuery().getExplainPlan();
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-      assertEquals(
-        columnEncoded ? "SERVER FILTER BY FIRST KEY ONLY" : "SERVER FILTER BY EMPTY COLUMN ONLY",
-        explainPlanAttributes.getServerWhereFilter());
+      assertTrue(columnEncoded
+        ? explainPlanAttributes.isServerFirstKeyOnlyProjection()
+        : explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       if (localIndex) {
         assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
         assertEquals(fullIndexName + "(" + fullTableName + ")",
@@ -619,9 +619,9 @@ public abstract class BaseIndexIT extends ParallelStatsDisabledIT {
         .getExplainPlan();
       explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-      assertEquals(
-        columnEncoded ? "SERVER FILTER BY FIRST KEY ONLY" : "SERVER FILTER BY EMPTY COLUMN ONLY",
-        explainPlanAttributes.getServerWhereFilter());
+      assertTrue(columnEncoded
+        ? explainPlanAttributes.isServerFirstKeyOnlyProjection()
+        : explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       if (localIndex) {
         assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
         assertEquals(fullIndexName + "(" + fullTableName + ")",
@@ -973,9 +973,9 @@ public abstract class BaseIndexIT extends ParallelStatsDisabledIT {
       ExplainPlan plan = conn.prepareStatement(query).unwrap(PhoenixPreparedStatement.class)
         .optimizeQuery().getExplainPlan();
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
-      assertEquals(
-        columnEncoded ? "SERVER FILTER BY FIRST KEY ONLY" : "SERVER FILTER BY EMPTY COLUMN ONLY",
-        explainPlanAttributes.getServerWhereFilter());
+      assertTrue(columnEncoded
+        ? explainPlanAttributes.isServerFirstKeyOnlyProjection()
+        : explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       if (localIndex) {
         assertEquals("PARALLEL 2-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
         assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
@@ -1552,7 +1552,7 @@ public abstract class BaseIndexIT extends ParallelStatsDisabledIT {
           .serverMergeColumns(
             "[A.VARCHAR_COL1, A.CHAR_COL1, A.DECIMAL_COL1, A.DATE1, B.VARCHAR_COL2, B.CHAR_COL2,"
               + " B.INT_COL2, B.DECIMAL_COL2, B.DATE2]")
-          .serverWhereFilter("SERVER FILTER BY A.\"LONG_COL1\" = 2");
+          .serverWhereFilter("A.\"LONG_COL1\" = 2");
         rs = stmt.executeQuery(query);
         assertTrue(rs.next());
         // Test the projector thoroughly
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/BaseIndexWithRegionMovesIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/BaseIndexWithRegionMovesIT.java
index 0aeff042aa..c15b00d43f 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/BaseIndexWithRegionMovesIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/BaseIndexWithRegionMovesIT.java
@@ -174,9 +174,9 @@ public abstract class BaseIndexWithRegionMovesIT extends ParallelStatsDisabledWi
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       if (!uncovered) {
         // Optimizer would not select the uncovered index for this query
-        assertEquals(
-          columnEncoded ? "SERVER FILTER BY FIRST KEY ONLY" : "SERVER FILTER BY EMPTY COLUMN ONLY",
-          explainPlanAttributes.getServerWhereFilter());
+        assertTrue(columnEncoded
+          ? explainPlanAttributes.isServerFirstKeyOnlyProjection()
+          : explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       }
 
       if (localIndex) {
@@ -646,9 +646,9 @@ public abstract class BaseIndexWithRegionMovesIT extends ParallelStatsDisabledWi
         .optimizeQuery().getExplainPlan();
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-      assertEquals(
-        columnEncoded ? "SERVER FILTER BY FIRST KEY ONLY" : "SERVER FILTER BY EMPTY COLUMN ONLY",
-        explainPlanAttributes.getServerWhereFilter());
+      assertTrue(columnEncoded
+        ? explainPlanAttributes.isServerFirstKeyOnlyProjection()
+        : explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       if (localIndex) {
         assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
         assertEquals(fullTableName, explainPlanAttributes.getTableName());
@@ -678,9 +678,9 @@ public abstract class BaseIndexWithRegionMovesIT extends ParallelStatsDisabledWi
         .getExplainPlan();
       explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-      assertEquals(
-        columnEncoded ? "SERVER FILTER BY FIRST KEY ONLY" : "SERVER FILTER BY EMPTY COLUMN ONLY",
-        explainPlanAttributes.getServerWhereFilter());
+      assertTrue(columnEncoded
+        ? explainPlanAttributes.isServerFirstKeyOnlyProjection()
+        : explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       if (localIndex) {
         assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
         assertEquals(fullTableName, explainPlanAttributes.getTableName());
@@ -1058,9 +1058,9 @@ public abstract class BaseIndexWithRegionMovesIT extends ParallelStatsDisabledWi
       ExplainPlan plan = conn.prepareStatement(query).unwrap(PhoenixPreparedStatement.class)
         .optimizeQuery().getExplainPlan();
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
-      assertEquals(
-        columnEncoded ? "SERVER FILTER BY FIRST KEY ONLY" : "SERVER FILTER BY EMPTY COLUMN ONLY",
-        explainPlanAttributes.getServerWhereFilter());
+      assertTrue(columnEncoded
+        ? explainPlanAttributes.isServerFirstKeyOnlyProjection()
+        : explainPlanAttributes.isServerEmptyColumnOnlyProjection());
       if (localIndex) {
         assertEquals("PARALLEL 2-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
         assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
@@ -1678,7 +1678,7 @@ public abstract class BaseIndexWithRegionMovesIT extends ParallelStatsDisabledWi
           .serverMergeColumns(
             "[A.VARCHAR_COL1, A.CHAR_COL1, A.DECIMAL_COL1, A.DATE1, B.VARCHAR_COL2, B.CHAR_COL2,"
               + " B.INT_COL2, B.DECIMAL_COL2, B.DATE2]")
-          .serverWhereFilter("SERVER FILTER BY A.\"LONG_COL1\" = 2");
+          .serverWhereFilter("A.\"LONG_COL1\" = 2");
         rs = stmt.executeQuery(query);
         assertTrue(rs.next());
         moveRegionsOfTable(fullTableName);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/ChildViewsUseParentViewIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/ChildViewsUseParentViewIndexIT.java
index 9b84aad8f7..ff8fba51e0 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/ChildViewsUseParentViewIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/ChildViewsUseParentViewIndexIT.java
@@ -169,7 +169,7 @@ public class ChildViewsUseParentViewIndexIT extends ParallelStatsDisabledIT {
       .optimizeQuery().getExplainPlan();
     ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SKIP SCAN ON 3 KEYS ", explainPlanAttributes.getExplainScanType());
     assertEquals("_IDX_" + baseTableName, explainPlanAttributes.getTableName());
     String childViewScanKey = isChildView ? ",'Y'" : "";
@@ -197,8 +197,7 @@ public class ChildViewsUseParentViewIndexIT extends ParallelStatsDisabledIT {
       .optimizeQuery().getExplainPlan();
     ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-    assertEquals(
-      "SERVER FILTER BY (A4 IN ('1','2','3') AND ((A1 = 'X' AND A2 = 'Y') AND A3 = 'Z'))",
+    assertEquals("(A4 IN ('1','2','3') AND ((A1 = 'X' AND A2 = 'Y') AND A3 = 'Z'))",
       explainPlanAttributes.getServerWhereFilter());
     assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
     assertEquals(baseTableName, explainPlanAttributes.getTableName());
@@ -277,7 +276,7 @@ public class ChildViewsUseParentViewIndexIT extends ParallelStatsDisabledIT {
       .optimizeQuery().getExplainPlan();
     ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
     assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-    assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+    assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
     assertEquals("SKIP SCAN ON 5 RANGES ", explainPlanAttributes.getExplainScanType());
     assertEquals("_IDX_" + baseTableName, explainPlanAttributes.getTableName());
     assertEquals(
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexCheckerIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexCheckerIT.java
index e9f4832144..3c18f82aec 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexCheckerIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexCheckerIT.java
@@ -1567,11 +1567,12 @@ public class GlobalIndexCheckerIT extends BaseTest {
       // Verify that we will read from the index table with a first-key-only/empty-column filter
       ExplainPlanAttributes attributes = getExplainAttributes(conn, selectSql);
       assertPlan(attributes).scanType("RANGE SCAN").table(indexName);
-      String expectedFilter =
-        String.format("SERVER FILTER BY %s ONLY AND", encoded ? "FIRST KEY" : "EMPTY COLUMN");
-      assertTrue("serverWhereFilter=" + attributes.getServerWhereFilter(),
-        attributes.getServerWhereFilter() != null
-          && attributes.getServerWhereFilter().contains(expectedFilter));
+      assertTrue("expected a first-key/empty-column projection, plan=" + attributes,
+        encoded
+          ? attributes.isServerFirstKeyOnlyProjection()
+          : attributes.isServerEmptyColumnOnlyProjection());
+      assertNotNull("serverWhereFilter=" + attributes.getServerWhereFilter(),
+        attributes.getServerWhereFilter());
       try (ResultSet rs = conn.createStatement().executeQuery(selectSql)) {
         assertTrue(rs.next());
         assertEquals("b", rs.getString("id"));
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexCheckerWithRegionMovesIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexCheckerWithRegionMovesIT.java
index 2806197b17..2f8074e301 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexCheckerWithRegionMovesIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexCheckerWithRegionMovesIT.java
@@ -1527,11 +1527,12 @@ public class GlobalIndexCheckerWithRegionMovesIT extends BaseTest {
       // Verify that we will read from the index table with a first-key-only/empty-column filter
       ExplainPlanAttributes attributes = getExplainAttributes(conn, selectSql);
       assertPlan(attributes).scanType("RANGE SCAN").table(indexName);
-      String expectedFilter =
-        String.format("SERVER FILTER BY %s ONLY AND", encoded ? "FIRST KEY" : "EMPTY COLUMN");
-      assertTrue("serverWhereFilter=" + attributes.getServerWhereFilter(),
-        attributes.getServerWhereFilter() != null
-          && attributes.getServerWhereFilter().contains(expectedFilter));
+      assertTrue("expected a first-key/empty-column projection, plan=" + attributes,
+        encoded
+          ? attributes.isServerFirstKeyOnlyProjection()
+          : attributes.isServerEmptyColumnOnlyProjection());
+      assertNotNull("serverWhereFilter=" + attributes.getServerWhereFilter(),
+        attributes.getServerWhereFilter());
       try (ResultSet rs = conn.createStatement().executeQuery(selectSql)) {
         assertTrue(rs.next());
         moveRegionsOfTable(dataTableName);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexOptimizationIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexOptimizationIT.java
index a9a43e3204..58b2bd435e 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexOptimizationIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/GlobalIndexOptimizationIT.java
@@ -82,7 +82,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       }
       assertMutationPlan(conn1, query).abstractExplainPlan("DELETE ROWS CLIENT SELECT")
         .scanType("RANGE SCAN").table(indexTableName + "L(" + dataTableName + ")")
-        .keyRanges(" [1,*] - [1,100]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .keyRanges(" [1,*] - [1,100]").serverFirstKeyOnlyProjection(true)
         .clientSortAlgo("CLIENT MERGE SORT");
       ResultSet rs = conn1.createStatement().executeQuery("SELECT COUNT(*) FROM " + dataTableName);
       rs.next();
@@ -154,7 +154,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       String query = "SELECT /*+ INDEX(" + dataTableName + " " + indexTableName + ")*/ * FROM "
         + dataTableName + " where v1='a'";
       assertPlan(conn1, query).scanType("RANGE SCAN").table(indexTableName).keyRanges(" ['a']")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true);
 
       ResultSet rs = conn1.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -172,7 +172,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       query = "SELECT /*+ INDEX(" + dataTableName + " " + indexTableName + ")*/ * FROM "
         + dataTableName + " where v1='a'";
       assertPlan(conn1, query).scanType("RANGE SCAN").table(indexTableName).keyRanges(" ['a']")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true);
 
       rs = conn1.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -192,8 +192,8 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       query = "SELECT /*+ INDEX(" + dataTableName + " " + indexTableName + ")*/ * FROM "
         + dataTableName + " where v1='a' limit 1";
       assertPlan(conn1, query).iteratorType("SERIAL").scanType("RANGE SCAN").table(indexTableName)
-        .keyRanges(" ['a']").serverMergeColumns("[0.K3]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverRowLimit(1L).clientRowLimit(1);
+        .keyRanges(" ['a']").serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
+        .serverRowLimit(1L).clientRowLimit(1);
 
       rs = conn1.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -208,8 +208,8 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
         + ")*/ t_id, k1, k2, k3, V1 from " + dataTableFullName
         + "  where v1<='z' and k3 > 1 order by V1,t_id";
       assertPlan(conn1, query).scanType("RANGE SCAN").table(indexTableName)
-        .keyRanges(" [*] - ['z']").serverMergeColumns("[0.K3]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND \"K3\" > 1");
+        .keyRanges(" [*] - ['z']").serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
+        .serverWhereFilter("\"K3\" > 1");
 
       rs = conn1.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -237,12 +237,12 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
         + "), NO_INDEX_SERVER_MERGE */ t_id, k1, k2, k3, V1 from " + dataTableFullName
         + "  where v1<='z' and k3 > 1 order by V1,t_id";
       ExplainPlanAssert skipScanJoinPlan = assertPlan(conn1, query).scanType("FULL SCAN")
-        .table(dataTableName).serverWhereFilter("SERVER FILTER BY K3 > 1")
+        .table(dataTableName).serverWhereFilter("K3 > 1")
         .serverSortedBy("[" + dataTableName + ".V1, " + dataTableName + ".T_ID]")
         .clientSortAlgo("CLIENT MERGE SORT");
       skipScanJoinPlan.subPlanCount(1).subPlan(0).abstractExplainPlan("SKIP-SCAN-JOIN TABLE 0")
         .scanType("RANGE SCAN").table(indexTableName).keyRanges(" [*] - ['z']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+        .serverFirstKeyOnlyProjection(true).end();
       // The dynamic server filter references compiler-generated positional aliases ($N.$N) whose
       // numbers are not stable, so match the structural shape of the attribute with a regex.
       String dynamicServerFilter = skipScanJoinPlan.attributes().getDynamicServerFilter();
@@ -279,8 +279,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       query = "SELECT /*+ INDEX(" + dataTableName + " " + indexTableName + ")*/ t_id, V1, k3 from "
         + dataTableFullName + "  where v1 <='z' group by v1,t_id, k3";
       assertPlan(conn1, query).scanType("RANGE SCAN").table(indexTableName)
-        .keyRanges(" [*] - ['z']").serverMergeColumns("[0.K3]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .keyRanges(" [*] - ['z']").serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
         .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"V1\", \"T_ID\", \"K3\"]")
         .clientSortAlgo("CLIENT MERGE SORT");
 
@@ -308,8 +307,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
         + dataTableFullName + " where v1 <='z'  group by v1 order by v1";
 
       assertPlan(conn1, query).scanType("RANGE SCAN").table(indexTableName)
-        .keyRanges(" [*] - ['z']").serverMergeColumns("[0.K3]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .keyRanges(" [*] - ['z']").serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
         .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"V1\"]");
 
       rs = conn1.createStatement().executeQuery(query);
@@ -343,8 +341,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       String query = "SELECT /*+ INDEX(" + dataTableName + " " + indexTableName
         + ")*/ k1,k2,k3,v1 FROM " + dataTableName + " where v1='a'";
       assertPlan(conn1, query).scanType("RANGE SCAN").table(indexTableName)
-        .keyRanges(" ['tid1','a']").serverMergeColumns("[0.K3]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .keyRanges(" ['tid1','a']").serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true);
 
       ResultSet rs = conn1.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -397,7 +394,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
 
       assertPlan(conn1, query).scanType("SKIP SCAN ON 2 KEYS").table("_IDX_" + dataTableName)
         .keyRanges(" [" + Short.MIN_VALUE + ",1] - [" + Short.MIN_VALUE + ",2]")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true);
 
       rs = conn1.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -435,7 +432,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       String query = "SELECT /*+ INDEX(" + dataTableName + " " + indexTableName
         + ")*/ t_id, k1, k2, V1 FROM " + dataTableName + " where v1='a'";
       assertPlan(conn1, query).scanType("RANGE SCAN").table(indexTableName).keyRanges(" ['a']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .serverFirstKeyOnlyProjection(true);
 
       ResultSet rs = conn1.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -451,7 +448,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       // No INDEX hint specified
       query = "SELECT t_id, k1, k2, k3, V1 FROM " + dataTableName + " where v1='a'";
       assertPlan(conn1, query).scanType("FULL SCAN").table(dataTableName)
-        .serverWhereFilter("SERVER FILTER BY V1 = 'a'");
+        .serverWhereFilter("V1 = 'a'");
 
       rs = conn1.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -502,7 +499,7 @@ public class GlobalIndexOptimizationIT extends ParallelStatsDisabledIT {
       query =
         "SELECT t_id, k1, k2, k3, V1 from " + dataTableFullName + "  where k3 > 1 order by V1,t_id";
       assertPlan(conn1, query).scanType("FULL SCAN").table(dataTableName)
-        .serverWhereFilter("SERVER FILTER BY K3 > 1").serverSortedBy("[V1, T_ID]")
+        .serverWhereFilter("K3 > 1").serverSortedBy("[V1, T_ID]")
         .clientSortAlgo("CLIENT MERGE SORT");
 
       rs = conn1.createStatement().executeQuery(query);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexUsageIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexUsageIT.java
index 6d88aa6d08..674e84d43d 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexUsageIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexUsageIT.java
@@ -137,7 +137,7 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
         .optimizeQuery().getExplainPlan();
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals(
         "SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY "
           + "[TO_BIGINT(\"(A.INT_COL1 + B.INT_COL2)\")]",
@@ -200,7 +200,7 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       assertEquals("SERVER DISTINCT PREFIX FILTER OVER [TO_BIGINT(\"(A.INT_COL1 + 1)\")]",
         explainPlanAttributes.getServerDistinctFilter());
       assertEquals(
@@ -267,7 +267,7 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       if (localIndex) {
         assertEquals("INDEX_TEST." + indexName + "(" + fullDataTableName + ")",
           explainPlanAttributes.getTableName());
@@ -327,7 +327,7 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
         .optimizeQuery().getExplainPlan();
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       if (localIndex) {
         assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
         assertEquals("INDEX_TEST." + indexName + "(" + fullDataTableName + ")",
@@ -527,14 +527,12 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
           explainPlanAttributes.getTableName());
         assertEquals(" [1,2]", explainPlanAttributes.getKeyRanges());
         assertEquals("CLIENT MERGE SORT", explainPlanAttributes.getClientSortAlgo());
-        assertEquals("SERVER FILTER BY FIRST KEY ONLY",
-          explainPlanAttributes.getServerWhereFilter());
+        assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       } else {
         assertEquals("FULL SCAN ", explainPlanAttributes.getExplainScanType());
         assertEquals(fullDataTableName, explainPlanAttributes.getTableName());
         assertNull(explainPlanAttributes.getClientSortAlgo());
-        assertEquals("SERVER FILTER BY (A.INT_COL1 + 1) = 2",
-          explainPlanAttributes.getServerWhereFilter());
+        assertEquals("(A.INT_COL1 + 1) = 2", explainPlanAttributes.getServerWhereFilter());
       }
 
       ResultSet rs = conn.createStatement().executeQuery(sql);
@@ -615,7 +613,7 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
       explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       if (local) {
         assertEquals(indexName2 + "(" + dataTableName + ")", explainPlanAttributes.getTableName());
         assertEquals(" [" + (2) + ",'foo2_bar2']", explainPlanAttributes.getKeyRanges());
@@ -687,7 +685,7 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
       assertEquals(indexName2, explainPlanAttributes.getTableName());
       assertEquals(" [1,'abc_cab','foo']", explainPlanAttributes.getKeyRanges());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
 
       rs = conn.createStatement().executeQuery(query);
       assertTrue(rs.next());
@@ -697,8 +695,8 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
       conn.createStatement().execute("ALTER VIEW " + viewName + " DROP COLUMN s4");
       // i2 cannot be used since s4 has been dropped from the view, so i1 will be used
       assertPlan(conn, query).scanType("RANGE SCAN").tableContains(indexName1).keyRanges(" [1]")
-        .serverWhereFilter(
-          "SERVER FILTER BY FIRST KEY ONLY AND ((\"S2\" || '_' || \"S3\") = 'abc_cab' AND \"S1\" = 'foo')");
+        .serverFirstKeyOnlyProjection(true)
+        .serverWhereFilter("((\"S2\" || '_' || \"S3\") = 'abc_cab' AND \"S1\" = 'foo')");
       rs = conn.createStatement().executeQuery(query);
       assertTrue(rs.next());
       assertEquals("abc_cab", rs.getString(1));
@@ -787,7 +785,7 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
       ExplainPlanAttributes explainPlanAttributes = plan.getPlanStepsAsAttributes();
       assertEquals("PARALLEL 1-WAY", explainPlanAttributes.getIteratorTypeAndScanSize());
       assertEquals("RANGE SCAN ", explainPlanAttributes.getExplainScanType());
-      assertEquals("SERVER FILTER BY FIRST KEY ONLY", explainPlanAttributes.getServerWhereFilter());
+      assertTrue(explainPlanAttributes.isServerFirstKeyOnlyProjection());
       if (localIndex) {
         assertEquals(indexName + "(" + dataTableName + ")", explainPlanAttributes.getTableName());
         assertEquals(" [1,'id:id1']", explainPlanAttributes.getKeyRanges());
@@ -861,16 +859,14 @@ public class IndexUsageIT extends ParallelStatsDisabledIT {
       if (localIndex) {
         assertPlan(conn, query).scanType("RANGE SCAN")
           .tableContains(indexName + "(" + tableName + ")").keyRanges(" [1,'1David']")
-          .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-          .subPlanCount(1).subPlan(0).scanType("RANGE SCAN")
-          .tableContains(indexName + "(" + tableName + ")").keyRanges(" [1]")
-          .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
+          .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1)
+          .subPlan(0).scanType("RANGE SCAN").tableContains(indexName + "(" + tableName + ")")
+          .keyRanges(" [1]").serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT")
           .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0 (SKIP MERGE)").end();
       } else {
         assertPlan(conn, query).scanType("RANGE SCAN").tableContains(indexName)
-          .keyRanges(" ['1David']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-          .subPlanCount(1).subPlan(0).scanType("FULL SCAN").tableContains(indexName)
-          .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+          .keyRanges(" ['1David']").serverFirstKeyOnlyProjection(true).subPlanCount(1).subPlan(0)
+          .scanType("FULL SCAN").tableContains(indexName).serverFirstKeyOnlyProjection(true)
           .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0 (SKIP MERGE)").end();
       }
 
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/LocalIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/LocalIndexIT.java
index fffacd4fc3..59a141176b 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/LocalIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/LocalIndexIT.java
@@ -443,21 +443,20 @@ public class LocalIndexIT extends BaseLocalIndexIT {
     assertPlan(conn, "SELECT v2 FROM " + tableName + " WHERE pk1 = 3 AND pk2 = 4")
       .iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
       .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,3,4]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+      .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT");
 
     // 3. same prefix length, but there's a column not on the index
     assertPlan(conn, "SELECT v2 FROM " + tableName + " WHERE pk1 = 3 AND pk2 = 4 AND v3 = 1")
       .iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN").table(physicalTableName.toString())
-      .keyRanges(" [3,4]").serverWhereFilter("SERVER FILTER BY V3 = 1");
+      .keyRanges(" [3,4]").serverWhereFilter("V3 = 1");
 
     // 4. Longer prefix on the index, use it.
     assertPlan(conn,
       "SELECT v2 FROM " + tableName + " WHERE pk1 = 3 AND pk2 = 4 AND v1 = 3 AND v3 = 1")
         .iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
         .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,3,4,3]")
-        .serverMergeColumns("[0.V3]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND \"V3\" = 1")
-        .clientSortAlgo("CLIENT MERGE SORT");
+        .serverMergeColumns("[0.V3]").serverFirstKeyOnlyProjection(true)
+        .serverWhereFilter("\"V3\" = 1").clientSortAlgo("CLIENT MERGE SORT");
   }
 
   @Test
@@ -486,7 +485,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
     assertPlan(conn, "SELECT pk1, pk2, pk3, v1 FROM " + tableName + " WHERE pk1 = 2 AND pk3 = 3")
       .iteratorType("PARALLEL").scanType("RANGE SCAN")
       .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,2,3]")
-      .serverMergeColumns("[0.V1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .serverMergeColumns("[0.V1]").serverFirstKeyOnlyProjection(true)
       .clientSortAlgo("CLIENT MERGE SORT");
   }
 
@@ -513,7 +512,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
     // 1. COUNT(*) should still use the index - fewer bytes to scan
     assertPlan(conn, "SELECT COUNT(*) FROM " + tableName).iteratorType("PARALLEL 1-WAY")
       .scanType("RANGE SCAN").table(fullIndexName + "(" + indexPhysicalTableName + ")")
-      .keyRanges(" [1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO SINGLE ROW");
 
     // 2. All column projected, no filtering by indexed column, not using the index
@@ -523,8 +522,8 @@ public class LocalIndexIT extends BaseLocalIndexIT {
     // 3. if the index can avoid a sort operation, use it
     assertPlan(conn, "SELECT * FROM " + tableName + " ORDER BY v2").iteratorType("PARALLEL 1-WAY")
       .scanType("RANGE SCAN").table(fullIndexName + "(" + indexPhysicalTableName + ")")
-      .keyRanges(" [1]").serverMergeColumns("[0.V1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+      .keyRanges(" [1]").serverMergeColumns("[0.V1]").serverFirstKeyOnlyProjection(true)
+      .clientSortAlgo("CLIENT MERGE SORT");
 
     // 4. but can't use the index if not ORDERing by a prefix of the index key.
     assertPlan(conn, "SELECT * FROM " + tableName + " ORDER BY v3").iteratorType("PARALLEL 1-WAY")
@@ -535,45 +534,41 @@ public class LocalIndexIT extends BaseLocalIndexIT {
     assertPlan(conn, "SELECT * FROM " + tableName + " WHERE v2 = 2 ORDER BY v3")
       .iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
       .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,2]")
-      .serverMergeColumns("[0.V1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .serverMergeColumns("[0.V1]").serverFirstKeyOnlyProjection(true)
       .clientSortAlgo("CLIENT MERGE SORT");
 
     // 6. Filtering by a non-indexed column will not use the index
     assertPlan(conn, "SELECT * FROM " + tableName + " WHERE v1 = 3").iteratorType("PARALLEL 1-WAY")
-      .scanType("FULL SCAN").table(physicalTableName.toString())
-      .serverWhereFilter("SERVER FILTER BY V1 = 3.0");
+      .scanType("FULL SCAN").table(physicalTableName.toString()).serverWhereFilter("V1 = 3.0");
 
     // 7. Also don't use an index if not filtering on a prefix of the key
     assertPlan(conn, "SELECT * FROM " + tableName + " WHERE v3 = 1").iteratorType("PARALLEL 1-WAY")
-      .scanType("FULL SCAN").table(physicalTableName.toString())
-      .serverWhereFilter("SERVER FILTER BY V3 = 1");
+      .scanType("FULL SCAN").table(physicalTableName.toString()).serverWhereFilter("V3 = 1");
 
     // 8. Filtering along a prefix of the index key can use the index
     assertPlan(conn, "SELECT * FROM " + tableName + " WHERE v2 = 2").iteratorType("PARALLEL 1-WAY")
       .scanType("RANGE SCAN").table(fullIndexName + "(" + indexPhysicalTableName + ")")
-      .keyRanges(" [1,2]").serverMergeColumns("[0.V1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+      .keyRanges(" [1,2]").serverMergeColumns("[0.V1]").serverFirstKeyOnlyProjection(true)
+      .clientSortAlgo("CLIENT MERGE SORT");
 
     // 9. Make sure a gap in the index columns still uses the index as long as a prefix is specified
     assertPlan(conn, "SELECT * FROM " + tableName + " WHERE v2 = 2 AND v4 = 4")
       .iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
       .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,2]")
-      .serverMergeColumns("[0.V1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND TO_INTEGER(\"V4\") = 4")
-      .clientSortAlgo("CLIENT MERGE SORT");
+      .serverMergeColumns("[0.V1]").serverFirstKeyOnlyProjection(true)
+      .serverWhereFilter("TO_INTEGER(\"V4\") = 4").clientSortAlgo("CLIENT MERGE SORT");
 
     // 10. Use index even when also filtering on non-indexed column
     assertPlan(conn, "SELECT * FROM " + tableName + " WHERE v2 = 2 AND v1 = 3")
       .iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
       .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,2]")
-      .serverMergeColumns("[0.V1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND \"V1\" = 3.0")
-      .clientSortAlgo("CLIENT MERGE SORT");
+      .serverMergeColumns("[0.V1]").serverFirstKeyOnlyProjection(true)
+      .serverWhereFilter("\"V1\" = 3.0").clientSortAlgo("CLIENT MERGE SORT");
 
     // 11. Another case of not using a prefix of the index key
     assertPlan(conn, "SELECT * FROM " + tableName + " WHERE v1 = 3 AND v3 = 1 AND v4 = 1")
       .iteratorType("PARALLEL 1-WAY").scanType("FULL SCAN").table(physicalTableName.toString())
-      .serverWhereFilter("SERVER FILTER BY (V1 = 3.0 AND V3 = 1 AND V4 = 1)");
+      .serverWhereFilter("(V1 = 3.0 AND V3 = 1 AND V4 = 1)");
   }
 
   @Test
@@ -780,7 +775,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
       String query = "SELECT * FROM " + tableName + " ORDER BY V1";
       assertPlan(conn1, query).scanType("RANGE SCAN")
         .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1]")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
         .clientSortAlgo("CLIENT MERGE SORT");
 
       ResultSet rs = conn1.createStatement().executeQuery(query);
@@ -799,7 +794,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
       query = "SELECT * FROM " + tableName + " ORDER BY V1 DESC NULLS LAST";
       assertPlan(conn1, query).scanType("RANGE SCAN").clientSortedBy("REVERSE")
         .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1]")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
         .clientSortAlgo("CLIENT MERGE SORT");
 
       rs = conn1.createStatement().executeQuery(query);
@@ -840,7 +835,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
       String query = "SELECT V1 FROM " + tableName + " ORDER BY V1 DESC NULLS LAST";
       assertPlan(conn1, query).scanType("RANGE SCAN").clientSortedBy("REVERSE")
         .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+        .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT");
 
       ResultSet rs = conn1.createStatement().executeQuery(query);
       String v = "zz";
@@ -885,7 +880,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
       String query = "SELECT t_id, k1, k2, k3, V1 FROM " + tableName + " where v1='a'";
       assertPlan(conn1, query).scanType("RANGE SCAN")
         .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,'a']")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
         .clientSortAlgo("CLIENT MERGE SORT");
 
       rs = conn1.createStatement().executeQuery(query);
@@ -904,7 +899,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
       query = "SELECT t_id, k1, k2, k3, V1 from " + tableName + "  where v1<='z' order by V1,t_id";
       assertPlan(conn1, query).scanType("RANGE SCAN")
         .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,*] - [1,'z']")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
         .clientSortAlgo("CLIENT MERGE SORT");
 
       rs = conn1.createStatement().executeQuery(query);
@@ -936,7 +931,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
       query = "SELECT t_id, V1, k3 from " + tableName + "  where v1 <='z' group by v1,t_id, k3";
       assertPlan(conn1, query).scanType("RANGE SCAN")
         .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,*] - [1,'z']")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
         .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"V1\", \"T_ID\", \"K3\"]")
         .clientSortAlgo("CLIENT MERGE SORT");
 
@@ -962,7 +957,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
 
       assertPlan(conn1, query).scanType("RANGE SCAN")
         .table(fullIndexName + "(" + indexPhysicalTableName + ")").keyRanges(" [1,*] - [1,'z']")
-        .serverMergeColumns("[0.K3]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.K3]").serverFirstKeyOnlyProjection(true)
         .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"V1\"]")
         .clientSortAlgo("CLIENT MERGE SORT");
 
@@ -1009,7 +1004,7 @@ public class LocalIndexIT extends BaseLocalIndexIT {
     assertPlan(conn1, query).iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
       .table(
         SchemaUtil.getPhysicalTableName(Bytes.toBytes(indexTableName), isNamespaceMapped) + "2")
-      .keyRanges(" ['a']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+      .keyRanges(" ['a']").serverFirstKeyOnlyProjection(true);
     conn1.close();
   }
 
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/MutableIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/MutableIndexIT.java
index 450eafbce8..9e6abe6131 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/MutableIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/MutableIndexIT.java
@@ -408,13 +408,12 @@ public class MutableIndexIT extends ParallelStatsDisabledIT {
       if (localIndex) {
         assertPlan(conn, query).iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
           .table(fullIndexName + "(" + fullTableName + ")").keyRanges(" [1]")
-          .serverWhereFilter(
-            "SERVER FILTER BY " + (columnEncoded ? "FIRST KEY" : "EMPTY COLUMN") + " ONLY")
-          .clientSortAlgo("CLIENT MERGE SORT");
+          .serverFirstKeyOnlyProjection(columnEncoded)
+          .serverEmptyColumnOnlyProjection(!columnEncoded).clientSortAlgo("CLIENT MERGE SORT");
       } else {
         assertPlan(conn, query).iteratorType("PARALLEL 1-WAY").scanType("FULL SCAN")
-          .table(fullIndexName).serverWhereFilter(
-            "SERVER FILTER BY " + (columnEncoded ? "FIRST KEY" : "EMPTY COLUMN") + " ONLY");
+          .table(fullIndexName).serverFirstKeyOnlyProjection(columnEncoded)
+          .serverEmptyColumnOnlyProjection(!columnEncoded);
       }
       // make sure the data table looks like what we expect
       rs = conn.createStatement().executeQuery(query);
@@ -537,13 +536,12 @@ public class MutableIndexIT extends ParallelStatsDisabledIT {
       if (localIndex) {
         assertPlan(conn, query).iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
           .table(fullIndexName + "(" + fullTableName + ")").keyRanges(" [1]")
-          .serverWhereFilter(
-            "SERVER FILTER BY " + (columnEncoded ? "FIRST KEY" : "EMPTY COLUMN") + " ONLY")
-          .clientSortAlgo("CLIENT MERGE SORT");
+          .serverFirstKeyOnlyProjection(columnEncoded)
+          .serverEmptyColumnOnlyProjection(!columnEncoded).clientSortAlgo("CLIENT MERGE SORT");
       } else {
         assertPlan(conn, query).iteratorType("PARALLEL 1-WAY").scanType("FULL SCAN")
-          .table(fullIndexName).serverWhereFilter(
-            "SERVER FILTER BY " + (columnEncoded ? "FIRST KEY" : "EMPTY COLUMN") + " ONLY");
+          .table(fullIndexName).serverFirstKeyOnlyProjection(columnEncoded)
+          .serverEmptyColumnOnlyProjection(!columnEncoded);
       }
 
       // check that the data table matches as expected
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/SaltedIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/SaltedIndexIT.java
index c908e50b92..cb220f1c6f 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/SaltedIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/SaltedIndexIT.java
@@ -160,15 +160,14 @@ public class SaltedIndexIT extends ParallelStatsDisabledIT {
 
     if (indexSaltBuckets == null) {
       assertPlan(conn, query).iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
-        .table(indexTableFullName).keyRanges(" [~'y']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .table(indexTableFullName).keyRanges(" [~'y']").serverFirstKeyOnlyProjection(true);
     } else {
       assertPlan(conn, query).iteratorType("PARALLEL 4-WAY").scanType("RANGE SCAN")
         .table(indexTableFullName)
         .keyRanges(" [X'00',~'y'] - ["
           + PVarbinary.INSTANCE.toStringLiteral(new byte[] { (byte) (indexSaltBuckets - 1) })
           + ",~'y']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+        .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT");
     }
 
     // Will use index, so rows returned in DESC order.
@@ -185,15 +184,14 @@ public class SaltedIndexIT extends ParallelStatsDisabledIT {
     assertFalse(rs.next());
     if (indexSaltBuckets == null) {
       assertPlan(conn, query).iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
-        .table(indexTableFullName).keyRanges(" [*] - [~'x']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .table(indexTableFullName).keyRanges(" [*] - [~'x']").serverFirstKeyOnlyProjection(true);
     } else {
       assertPlan(conn, query).iteratorType("PARALLEL 4-WAY").scanType("RANGE SCAN")
         .table(indexTableFullName)
         .keyRanges(" [X'00',*] - ["
           + PVarbinary.INSTANCE.toStringLiteral(new byte[] { (byte) (indexSaltBuckets - 1) })
           + ",~'x']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+        .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT");
     }
 
     // Use data table, since point lookup trumps order by
@@ -220,11 +218,11 @@ public class SaltedIndexIT extends ParallelStatsDisabledIT {
     assertFalse(rs.next());
     if (tableSaltBuckets == null) {
       assertPlan(conn, query).iteratorType("PARALLEL 1-WAY").scanType("FULL SCAN")
-        .table(dataTableFullName).serverWhereFilter("SERVER FILTER BY V >= 'x'").serverRowLimit(2L)
+        .table(dataTableFullName).serverWhereFilter("V >= 'x'").serverRowLimit(2L)
         .clientRowLimit(2);
     } else {
       assertPlan(conn, query).iteratorType("PARALLEL 3-WAY").scanType("FULL SCAN")
-        .table(dataTableFullName).serverWhereFilter("SERVER FILTER BY V >= 'x'").serverRowLimit(2L)
+        .table(dataTableFullName).serverWhereFilter("V >= 'x'").serverRowLimit(2L)
         .clientSortAlgo("CLIENT MERGE SORT").clientRowLimit(2);
     }
 
@@ -232,12 +230,12 @@ public class SaltedIndexIT extends ParallelStatsDisabledIT {
     query = "SELECT * FROM " + dataTableFullName + " ORDER BY v DESC LIMIT 1";
     if (indexSaltBuckets == null) {
       assertPlan(conn, query).iteratorType("SERIAL 1-WAY").scanType("FULL SCAN")
-        .table(indexTableFullName).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .serverRowLimit(1L).clientRowLimit(1);
+        .table(indexTableFullName).serverFirstKeyOnlyProjection(true).serverRowLimit(1L)
+        .clientRowLimit(1);
     } else {
       assertPlan(conn, query).iteratorType("PARALLEL 4-WAY").scanType("FULL SCAN")
-        .table(indexTableFullName).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .serverRowLimit(1L).clientSortAlgo("CLIENT MERGE SORT").clientRowLimit(1);
+        .table(indexTableFullName).serverFirstKeyOnlyProjection(true).serverRowLimit(1L)
+        .clientSortAlgo("CLIENT MERGE SORT").clientRowLimit(1);
     }
   }
 }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/ViewIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/ViewIndexIT.java
index 6da69d4316..7566387a62 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/ViewIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/ViewIndexIT.java
@@ -259,8 +259,8 @@ public class ViewIndexIT extends SplitSystemCatalogIT {
       assertPlan(conn1, sql).iteratorType("PARALLEL 1-WAY").scanType("RANGE SCAN")
         .table(fullIndexName + "("
           + SchemaUtil.getPhysicalTableName(Bytes.toBytes(fullTableName), isNamespaceMapped) + ")")
-        .keyRanges(" [1,'10',100]").serverMergeColumns("[0.V1]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+        .keyRanges(" [1,'10',100]").serverMergeColumns("[0.V1]").serverFirstKeyOnlyProjection(true)
+        .clientSortAlgo("CLIENT MERGE SORT");
       ResultSet rs = conn1.prepareStatement(sql).executeQuery();
       assertTrue(rs.next());
       assertFalse(rs.next());
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinGlobalIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinGlobalIndexIT.java
index 8c6c5bc759..e1aa1b19e0 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinGlobalIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinGlobalIndexIT.java
@@ -63,7 +63,7 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"I.0:NAME\"]")
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(idxItem)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
@@ -74,15 +74,14 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"I.:item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").clientSortedBy("[SUM(O.QUANTITY) DESC]").subPlanCount(1)
       .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(idxItem).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .table(idxItem).serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
   protected void assertLeftJoinWithAggPlan3(Connection conn, String query) throws Exception {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"I.item_id\"]")
       .clientSortedBy("[SUM(O.QUANTITY) DESC NULLS LAST, \"I.item_id\"]").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
@@ -92,8 +91,7 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
   protected void assertRightJoinWithAggPlan1(Connection conn, String query) throws Exception {
     String idxItem = getSchemaName() + ".idx_item";
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(idxItem)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(idxItem).serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"I.0:NAME\"]")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0")
       .scanType("FULL SCAN").table(order).end();
@@ -103,8 +101,7 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
   protected void assertRightJoinWithAggPlan2(Connection conn, String query) throws Exception {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"I.item_id\"]")
       .clientSortedBy("[SUM(O.QUANTITY) DESC NULLS LAST, \"I.item_id\"]").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
@@ -124,9 +121,9 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
     String idxItem = getSchemaName() + ".idx_item";
     String idxSupplier = getSchemaName() + ".idx_supplier";
     assertPlan(conn, query).scanType("RANGE SCAN").table(idxItem).keyRanges(" ['T1'] - ['T5']")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").subPlanCount(1).subPlan(0)
+      .serverFirstKeyOnlyProjection(true).subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("RANGE SCAN").table(idxSupplier)
-      .keyRanges(" ['S1'] - ['S5']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .keyRanges(" ['S1'] - ['S5']").serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
@@ -136,8 +133,7 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
     assertPlan(conn, query).scanType("SKIP SCAN ON 2 KEYS").table(idxItem)
       .keyRanges(" ['T1'] - ['T5']").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("SKIP SCAN ON 2 KEYS")
-      .table(idxSupplier).keyRanges(" ['S1'] - ['S5']")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .table(idxSupplier).keyRanges(" ['S1'] - ['S5']").serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
@@ -147,9 +143,9 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
     String idxSupplier = getSchemaName() + ".idx_supplier";
     assertPlan(conn, query).scanType("FULL SCAN").table(idxItem).subPlanCount(2).subPlan(0)
       .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0 (SKIP MERGE)").scanType("FULL SCAN")
-      .table(order).serverWhereFilter("SERVER FILTER BY QUANTITY < 5000").end().subPlan(1)
+      .table(order).serverWhereFilter("QUANTITY < 5000").end().subPlan(1)
       .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 1").scanType("FULL SCAN").table(idxSupplier)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
@@ -159,15 +155,13 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
     assertPlan(conn, query).scanType("FULL SCAN").table(item)
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"I1.item_id\" IN (\"I2.:item_id\")")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
-      .scanType("FULL SCAN").table(idxItem).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-      .end();
+      .scanType("FULL SCAN").table(idxItem).serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
   protected void assertSelfJoinPlan2(Connection conn, String query) throws Exception {
     String idxItem = getSchemaName() + ".idx_item";
-    assertPlan(conn, query).scanType("FULL SCAN").table(idxItem)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(idxItem).serverFirstKeyOnlyProjection(true)
       .serverSortedBy("[\"I1.0:NAME\", \"I2.0:NAME\"]").clientSortAlgo("CLIENT MERGE SORT")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
       .scanType("FULL SCAN").table(idxItem).end();
@@ -182,17 +176,16 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
     if (!noStarJoin) {
       assertPlan(conn, query).scanType("FULL SCAN").table(order).subPlanCount(2).subPlan(0)
         .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(idxCustomer)
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end().subPlan(1)
+        .serverFirstKeyOnlyProjection(true).end().subPlan(1)
         .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 1").scanType("FULL SCAN").table(idxItem)
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+        .serverFirstKeyOnlyProjection(true).end();
     } else {
       assertPlan(conn, query).scanType("FULL SCAN").table(idxItem)
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverSortedBy("[\"O.order_id\"]")
+        .serverFirstKeyOnlyProjection(true).serverSortedBy("[\"O.order_id\"]")
         .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
         .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order)
         .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
-        .scanType("FULL SCAN").table(idxCustomer)
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end().end();
+        .scanType("FULL SCAN").table(idxCustomer).serverFirstKeyOnlyProjection(true).end().end();
     }
   }
 
@@ -207,10 +200,9 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
       .clientSortAlgo("CLIENT MERGE SORT")
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"C.customer_id\" IN (\"O.customer_id\")")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
-      .scanType("FULL SCAN").table(order)
-      .serverWhereFilter("SERVER FILTER BY \"order_id\" != '000000000000003'").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(idxItem).serverWhereFilter("SERVER FILTER BY \"NAME\" != 'T3'").subPlanCount(1)
+      .scanType("FULL SCAN").table(order).serverWhereFilter("\"order_id\" != '000000000000003'")
+      .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
+      .scanType("FULL SCAN").table(idxItem).serverWhereFilter("\"NAME\" != 'T3'").subPlanCount(1)
       .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
       .table(supplier).end().end().end();
   }
@@ -223,7 +215,7 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [I.NAME]")
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(idxItem)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
@@ -234,16 +226,14 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [O.IID]")
       .clientSortAlgo("CLIENT MERGE SORT").clientSortedBy("[SUM(O.QUANTITY) DESC]").subPlanCount(1)
       .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0 (SKIP MERGE)")
-      .scanType("FULL SCAN").table(idxItem).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-      .end();
+      .scanType("FULL SCAN").table(idxItem).serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
   protected void assertSubqueryAggPlan3(Connection conn, String query) throws Exception {
     String idxItem = getSchemaName() + ".idx_item";
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(idxItem)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(idxItem).serverFirstKeyOnlyProjection(true)
       .serverSortedBy("[O.Q DESC NULLS LAST, I.IID]").clientSortAlgo("CLIENT MERGE SORT")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0")
       .scanType("FULL SCAN").table(order)
@@ -255,11 +245,10 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
   protected void assertSubqueryAggPlan4(Connection conn, String query) throws Exception {
     String idxItem = getSchemaName() + ".idx_item";
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(idxItem)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverSortedBy("[O.Q DESC, I.IID]")
-      .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
-      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order)
-      .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"item_id\"]")
+    assertPlan(conn, query).scanType("FULL SCAN").table(idxItem).serverFirstKeyOnlyProjection(true)
+      .serverSortedBy("[O.Q DESC, I.IID]").clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1)
+      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN")
+      .table(order).serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
@@ -273,11 +262,11 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
       .keyRanges(" [*] - ['0000000005']").serverSortedBy("[C.CID, QO.INAME]")
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order)
-      .serverWhereFilter("SERVER FILTER BY \"order_id\" != '000000000000003'").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(idxItem).serverWhereFilter("SERVER FILTER BY \"NAME\" != 'T3'").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(supplier).end().end().end();
+      .serverWhereFilter("\"order_id\" != '000000000000003'").subPlanCount(1).subPlan(0)
+      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(idxItem)
+      .serverWhereFilter("\"NAME\" != 'T3'").subPlanCount(1).subPlan(0)
+      .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(supplier).end()
+      .end().end();
   }
 
   @Override
@@ -314,10 +303,9 @@ public class HashJoinGlobalIndexIT extends HashJoinIT {
     statement.setMaxRows(4);
     ExplainPlanAttributes attributes =
       statement.optimizeQuery().getExplainPlan().getPlanStepsAsAttributes();
-    assertPlan(attributes).scanType("FULL SCAN").table(idxItem)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientRowLimit(4).joinScannerLimit(4L)
-      .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
-      .scanType("FULL SCAN").table(order).end();
+    assertPlan(attributes).scanType("FULL SCAN").table(idxItem).serverFirstKeyOnlyProjection(true)
+      .clientRowLimit(4).joinScannerLimit(4L).subPlanCount(1).subPlan(0)
+      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
   }
 
   @Override
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinLocalIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinLocalIndexIT.java
index a44ac276e9..e83b84ed7c 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinLocalIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinLocalIndexIT.java
@@ -78,9 +78,8 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"I.0:NAME\"]")
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("RANGE SCAN")
-      .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-      .end();
+      .table(itemIndex + "(" + item + ")").keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
+      .clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
   @Override
@@ -92,17 +91,15 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"I.:item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").clientSortedBy("[SUM(O.QUANTITY) DESC]").subPlanCount(1)
       .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("RANGE SCAN")
-      .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-      .end();
+      .table(itemIndex + "(" + item + ")").keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
+      .clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
   @Override
   protected void assertLeftJoinWithAggPlan3(Connection conn, String query) throws Exception {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"I.item_id\"]")
       .clientSortedBy("[SUM(O.QUANTITY) DESC NULLS LAST, \"I.item_id\"]").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
@@ -114,7 +111,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
     String itemIndex = SchemaUtil.getTableName(getSchemaName(), JOIN_ITEM_INDEX);
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
     assertPlan(conn, query).scanType("RANGE SCAN").table(itemIndex + "(" + item + ")")
-      .keyRanges(" [1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"I.0:NAME\"]")
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
@@ -124,8 +121,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
   protected void assertRightJoinWithAggPlan2(Connection conn, String query) throws Exception {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"I.item_id\"]")
       .clientSortedBy("[SUM(O.QUANTITY) DESC NULLS LAST, \"I.item_id\"]").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
@@ -147,12 +143,11 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
     String supplier = getTableName(conn, JOIN_SUPPLIER_TABLE_FULL_NAME);
     String supplierIndex = SchemaUtil.getTableName(getSchemaName(), JOIN_SUPPLIER_INDEX);
     assertPlan(conn, query).scanType("RANGE SCAN").table(itemIndex + "(" + item + ")")
-      .keyRanges(" [1,'T1'] - [1,'T5']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .keyRanges(" [1,'T1'] - [1,'T5']").serverFirstKeyOnlyProjection(true)
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("RANGE SCAN")
       .table(supplierIndex + "(" + supplier + ")").keyRanges(" [1,'S1'] - [1,'S5']")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-      .end();
+      .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
   @Override
@@ -165,8 +160,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .keyRanges(" [1,'T1'] - [1,'T5']").clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1)
       .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("SKIP SCAN ON 2 KEYS")
       .table(supplierIndex + "(" + supplier + ")").keyRanges(" [1,'S1'] - [1,'S5']")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-      .end();
+      .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
   @Override
@@ -180,11 +174,10 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .keyRanges(" [1]").clientSortAlgo("CLIENT MERGE SORT")
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"I.:item_id\" IN (\"O.item_id\")")
       .subPlanCount(2).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0 (SKIP MERGE)")
-      .scanType("FULL SCAN").table(order).serverWhereFilter("SERVER FILTER BY QUANTITY < 5000")
-      .end().subPlan(1).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 1").scanType("RANGE SCAN")
+      .scanType("FULL SCAN").table(order).serverWhereFilter("QUANTITY < 5000").end().subPlan(1)
+      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 1").scanType("RANGE SCAN")
       .table(supplierIndex + "(" + supplier + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-      .end();
+      .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
   @Override
@@ -195,8 +188,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"I1.item_id\" IN (\"I2.:item_id\")")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
       .scanType("RANGE SCAN").table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-      .end();
+      .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
   @Override
@@ -204,7 +196,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     String itemIndex = SchemaUtil.getTableName(getSchemaName(), JOIN_ITEM_INDEX);
     assertPlan(conn, query).scanType("RANGE SCAN").table(itemIndex + "(" + item + ")")
-      .keyRanges(" [1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
       .serverSortedBy("[\"I1.0:NAME\", \"I2.0:NAME\"]").clientSortAlgo("CLIENT MERGE SORT")
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"I1.:item_id\" IN (\"I2.0:supplier_id\")")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
@@ -224,22 +216,20 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       assertPlan(conn, query).scanType("FULL SCAN").table(order).subPlanCount(2).subPlan(0)
         .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("RANGE SCAN")
         .table(customerIndex + "(" + customer + ")").keyRanges(" [1]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-        .end().subPlan(1).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 1").scanType("RANGE SCAN")
-        .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-        .end();
+        .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT").end().subPlan(1)
+        .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 1").scanType("RANGE SCAN")
+        .table(itemIndex + "(" + item + ")").keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
+        .clientSortAlgo("CLIENT MERGE SORT").end();
     } else {
       assertPlan(conn, query).scanType("RANGE SCAN").table(itemIndex + "(" + item + ")")
-        .keyRanges(" [1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .serverSortedBy("[\"O.order_id\"]").clientSortAlgo("CLIENT MERGE SORT")
+        .keyRanges(" [1]").serverFirstKeyOnlyProjection(true).serverSortedBy("[\"O.order_id\"]")
+        .clientSortAlgo("CLIENT MERGE SORT")
         .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"I.:item_id\" IN (\"O.item_id\")")
         .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
         .scanType("FULL SCAN").table(order).subPlanCount(1).subPlan(0)
         .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("RANGE SCAN")
         .table(customerIndex + "(" + customer + ")").keyRanges(" [1]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-        .end().end();
+        .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT").end().end();
     }
   }
 
@@ -255,13 +245,12 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .clientSortAlgo("CLIENT MERGE SORT")
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"C.customer_id\" IN (\"O.customer_id\")")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
-      .scanType("FULL SCAN").table(order)
-      .serverWhereFilter("SERVER FILTER BY \"order_id\" != '000000000000003'").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("RANGE SCAN")
-      .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY \"NAME\" != 'T3'").clientSortAlgo("CLIENT MERGE SORT")
-      .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0")
-      .scanType("FULL SCAN").table(supplier).end().end().end();
+      .scanType("FULL SCAN").table(order).serverWhereFilter("\"order_id\" != '000000000000003'")
+      .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
+      .scanType("RANGE SCAN").table(itemIndex + "(" + item + ")").keyRanges(" [1]")
+      .serverWhereFilter("\"NAME\" != 'T3'").clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1)
+      .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
+      .table(supplier).end().end().end();
   }
 
   @Override
@@ -273,9 +262,8 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [I.NAME]")
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("RANGE SCAN")
-      .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-      .end();
+      .table(itemIndex + "(" + item + ")").keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
+      .clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
   @Override
@@ -288,8 +276,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .clientSortAlgo("CLIENT MERGE SORT").clientSortedBy("[SUM(O.QUANTITY) DESC]").subPlanCount(1)
       .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0 (SKIP MERGE)")
       .scanType("RANGE SCAN").table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT")
-      .end();
+      .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
   @Override
@@ -298,7 +285,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
     String itemIndex = SchemaUtil.getTableName(getSchemaName(), JOIN_ITEM_INDEX);
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
     assertPlan(conn, query).scanType("RANGE SCAN").table(itemIndex + "(" + item + ")")
-      .keyRanges(" [1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
       .serverSortedBy("[O.Q DESC NULLS LAST, I.IID]").clientSortAlgo("CLIENT MERGE SORT")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0")
       .scanType("FULL SCAN").table(order)
@@ -312,10 +299,10 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
     String itemIndex = SchemaUtil.getTableName(getSchemaName(), JOIN_ITEM_INDEX);
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
     assertPlan(conn, query).scanType("RANGE SCAN").table(itemIndex + "(" + item + ")")
-      .keyRanges(" [1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-      .serverSortedBy("[O.Q DESC, I.IID]").clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(order).serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"item_id\"]")
+      .keyRanges(" [1]").serverFirstKeyOnlyProjection(true).serverSortedBy("[O.Q DESC, I.IID]")
+      .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
+      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order)
+      .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
@@ -330,12 +317,12 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       .keyRanges(" [*] - ['0000000005']").serverSortedBy("[C.CID, QO.INAME]")
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order)
-      .serverWhereFilter("SERVER FILTER BY \"order_id\" != '000000000000003'").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("RANGE SCAN")
-      .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY \"NAME\" != 'T3'").clientSortAlgo("CLIENT MERGE SORT")
-      .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0")
-      .scanType("FULL SCAN").table(supplier).end().end().end();
+      .serverWhereFilter("\"order_id\" != '000000000000003'").subPlanCount(1).subPlan(0)
+      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("RANGE SCAN")
+      .table(itemIndex + "(" + item + ")").keyRanges(" [1]").serverWhereFilter("\"NAME\" != 'T3'")
+      .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
+      .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(supplier).end()
+      .end().end();
   }
 
   @Override
@@ -378,8 +365,8 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
     ExplainPlanAttributes attributes =
       statement.optimizeQuery().getExplainPlan().getPlanStepsAsAttributes();
     assertPlan(attributes).scanType("RANGE SCAN").table(itemIndex + "(" + item + ")")
-      .keyRanges(" [1]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-      .clientSortAlgo("CLIENT MERGE SORT").clientRowLimit(4)
+      .keyRanges(" [1]").serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT")
+      .clientRowLimit(4)
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"I.:item_id\" IN (\"O.item_id\")")
       .joinScannerLimit(4L).subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
@@ -451,7 +438,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       assertFalse(rs.next());
       assertPlan(conn, query).scanType("RANGE SCAN")
         .table(supplierIndex + "(" + supplierTable + ")").keyRanges(" [1,'S1']")
-        .serverMergeColumns("[0.PHONE]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.PHONE]").serverFirstKeyOnlyProjection(true)
         .clientSortAlgo("CLIENT MERGE SORT")
         .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"S.:supplier_id\" IN (\"I.0:supplier_id\")")
         .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
@@ -468,7 +455,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       assertFalse(rs.next());
       assertPlan(conn, query).scanType("RANGE SCAN")
         .table(supplierIndex + "(" + supplierTable + ")").keyRanges(" [1,'S1']")
-        .serverMergeColumns("[0.PHONE]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.PHONE]").serverFirstKeyOnlyProjection(true)
         .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"S.PHONE\"]")
         .clientSortAlgo("CLIENT MERGE SORT")
         .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"S.:supplier_id\" IN (\"I.0:supplier_id\")")
@@ -486,7 +473,7 @@ public class HashJoinLocalIndexIT extends HashJoinIT {
       assertFalse(rs.next());
       assertPlan(conn, query).scanType("RANGE SCAN")
         .table(supplierIndex + "(" + supplierTable + ")").keyRanges(" [1,*] - [1,'S3']")
-        .serverMergeColumns("[0.PHONE]").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .serverMergeColumns("[0.PHONE]").serverFirstKeyOnlyProjection(true)
         .serverAggregate("SERVER AGGREGATE INTO SINGLE ROW").subPlanCount(1).subPlan(0)
         .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("RANGE SCAN")
         .table(itemIndex + "(" + itemTable + ")").keyRanges(" [1,*] - [1,'T6']")
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinMoreIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinMoreIT.java
index 16f0144c69..2c04a09961 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinMoreIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinMoreIT.java
@@ -782,12 +782,12 @@ public class HashJoinMoreIT extends ParallelStatsDisabledIT {
 
         assertPlan(conn, q).scanType("SKIP SCAN ON 2 RANGES").table("EVENT_COUNT").keyRanges(
           " [X'00','5SEC',~1462993520000000000,'Tr/Bal'] - [X'01','5SEC',~1462993420000000000,'Tr/Bal']")
-          .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+          .serverFirstKeyOnlyProjection(true)
           .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"E.TIMESTAMP\", E.BUCKET]")
           .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
           .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0 (SKIP MERGE)")
           .scanType("SKIP SCAN ON 2 RANGES").table(t[i]).keyRanges(innerKeyRanges)
-          .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND SRC_LOCATION = DST_LOCATION")
+          .serverFirstKeyOnlyProjection(true).serverWhereFilter("SRC_LOCATION = DST_LOCATION")
           .clientSortAlgo("CLIENT MERGE SORT").end();
 
         ResultSet rs = conn.createStatement().executeQuery(q);
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinNoIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinNoIndexIT.java
index 166cc338ad..104e14f50a 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinNoIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/HashJoinNoIndexIT.java
@@ -73,15 +73,14 @@ public class HashJoinNoIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"I.item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").clientSortedBy("[SUM(O.QUANTITY) DESC]").subPlanCount(1)
       .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(item).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .table(item).serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
   protected void assertLeftJoinWithAggPlan3(Connection conn, String query) throws Exception {
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"I.item_id\"]")
       .clientSortedBy("[SUM(O.QUANTITY) DESC NULLS LAST, \"I.item_id\"]").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
@@ -101,8 +100,7 @@ public class HashJoinNoIndexIT extends HashJoinIT {
   protected void assertRightJoinWithAggPlan2(Connection conn, String query) throws Exception {
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true)
       .serverAggregate("SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [\"I.item_id\"]")
       .clientSortedBy("[SUM(O.QUANTITY) DESC NULLS LAST, \"I.item_id\"]").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(order).end();
@@ -122,9 +120,9 @@ public class HashJoinNoIndexIT extends HashJoinIT {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     String supplier = getTableName(conn, JOIN_SUPPLIER_TABLE_FULL_NAME);
     assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY (NAME >= 'T1' AND NAME <= 'T5')").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(supplier).serverWhereFilter("SERVER FILTER BY (NAME >= 'S1' AND NAME <= 'S5')").end();
+      .serverWhereFilter("(NAME >= 'T1' AND NAME <= 'T5')").subPlanCount(1).subPlan(0)
+      .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(supplier)
+      .serverWhereFilter("(NAME >= 'S1' AND NAME <= 'S5')").end();
   }
 
   @Override
@@ -132,9 +130,9 @@ public class HashJoinNoIndexIT extends HashJoinIT {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     String supplier = getTableName(conn, JOIN_SUPPLIER_TABLE_FULL_NAME);
     assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY (NAME = 'T1' OR NAME = 'T5')").subPlanCount(1).subPlan(0)
+      .serverWhereFilter("(NAME = 'T1' OR NAME = 'T5')").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(supplier)
-      .serverWhereFilter("SERVER FILTER BY (NAME = 'S1' OR NAME = 'S5')").end();
+      .serverWhereFilter("(NAME = 'S1' OR NAME = 'S5')").end();
   }
 
   @Override
@@ -145,9 +143,9 @@ public class HashJoinNoIndexIT extends HashJoinIT {
     assertPlan(conn, query).scanType("FULL SCAN").table(item)
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"I.item_id\" IN (\"O.item_id\")")
       .subPlanCount(2).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0 (SKIP MERGE)")
-      .scanType("FULL SCAN").table(order).serverWhereFilter("SERVER FILTER BY QUANTITY < 5000")
-      .end().subPlan(1).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 1").scanType("FULL SCAN")
-      .table(supplier).end();
+      .scanType("FULL SCAN").table(order).serverWhereFilter("QUANTITY < 5000").end().subPlan(1)
+      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 1").scanType("FULL SCAN").table(supplier)
+      .end();
   }
 
   @Override
@@ -156,7 +154,7 @@ public class HashJoinNoIndexIT extends HashJoinIT {
     assertPlan(conn, query).scanType("FULL SCAN").table(item)
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"I1.item_id\" IN (\"I2.item_id\")")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
-      .scanType("FULL SCAN").table(item).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
@@ -202,12 +200,11 @@ public class HashJoinNoIndexIT extends HashJoinIT {
       .clientSortAlgo("CLIENT MERGE SORT")
       .dynamicServerFilter("DYNAMIC SERVER FILTER BY \"C.customer_id\" IN (\"O.customer_id\")")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
-      .scanType("FULL SCAN").table(order)
-      .serverWhereFilter("SERVER FILTER BY \"order_id\" != '000000000000003'").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(item).serverWhereFilter("SERVER FILTER BY NAME != 'T3'").subPlanCount(1).subPlan(0)
-      .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(supplier).end()
-      .end().end();
+      .scanType("FULL SCAN").table(order).serverWhereFilter("\"order_id\" != '000000000000003'")
+      .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0")
+      .scanType("FULL SCAN").table(item).serverWhereFilter("NAME != 'T3'").subPlanCount(1)
+      .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
+      .table(supplier).end().end().end();
   }
 
   @Override
@@ -228,15 +225,14 @@ public class HashJoinNoIndexIT extends HashJoinIT {
       .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [O.IID]")
       .clientSortAlgo("CLIENT MERGE SORT").clientSortedBy("[SUM(O.QUANTITY) DESC]").subPlanCount(1)
       .subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0 (SKIP MERGE)")
-      .scanType("FULL SCAN").table(item).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
   protected void assertSubqueryAggPlan3(Connection conn, String query) throws Exception {
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+    assertPlan(conn, query).scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true)
       .serverSortedBy("[O.Q DESC NULLS LAST, I.IID]").clientSortAlgo("CLIENT MERGE SORT")
       .subPlanCount(1).subPlan(0).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0")
       .scanType("FULL SCAN").table(order)
@@ -248,11 +244,10 @@ public class HashJoinNoIndexIT extends HashJoinIT {
   protected void assertSubqueryAggPlan4(Connection conn, String query) throws Exception {
     String order = getTableName(conn, JOIN_ORDER_TABLE_FULL_NAME);
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
-    assertPlan(conn, query).scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverSortedBy("[O.Q DESC, I.IID]")
-      .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
-      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order)
-      .serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"item_id\"]")
+    assertPlan(conn, query).scanType("FULL SCAN").table(item).serverFirstKeyOnlyProjection(true)
+      .serverSortedBy("[O.Q DESC, I.IID]").clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1)
+      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN")
+      .table(order).serverAggregate("SERVER AGGREGATE INTO DISTINCT ROWS BY [\"item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
@@ -266,9 +261,9 @@ public class HashJoinNoIndexIT extends HashJoinIT {
       .keyRanges(" [*] - ['0000000005']").serverSortedBy("[C.CID, QO.INAME]")
       .clientSortAlgo("CLIENT MERGE SORT").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(order)
-      .serverWhereFilter("SERVER FILTER BY \"order_id\" != '000000000000003'").subPlanCount(1)
-      .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(item).serverWhereFilter("SERVER FILTER BY NAME != 'T3'").subPlanCount(1).subPlan(0)
+      .serverWhereFilter("\"order_id\" != '000000000000003'").subPlanCount(1).subPlan(0)
+      .abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("FULL SCAN").table(item)
+      .serverWhereFilter("NAME != 'T3'").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN").table(supplier).end()
       .end().end();
   }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinGlobalIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinGlobalIndexIT.java
index 633b91424f..108be15272 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinGlobalIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinGlobalIndexIT.java
@@ -61,13 +61,13 @@ public class SortMergeJoinGlobalIndexIT extends SortMergeJoinIT {
     String itemIndex = getSchemaName() + ".idx_item";
     String supplierIndex = getSchemaName() + ".idx_supplier";
     assertPlan(conn, query).abstractExplainPlan("SORT-MERGE-JOIN (LEFT)").scanType("FULL SCAN")
-      .table(supplierIndex).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .table(supplierIndex).serverFirstKeyOnlyProjection(true)
       .serverSortedBy("[\"S.:supplier_id\"]").clientSortAlgo("CLIENT MERGE SORT")
       .sortMergeSkipMerge(false).rhs().abstractExplainPlan("SORT-MERGE-JOIN (INNER)")
       .scanType("FULL SCAN").table(itemIndex).serverSortedBy("[\"I.:item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").sortMergeSkipMerge(true)
       .clientSortedBy("[\"I.0:supplier_id\"]").rhs().scanType("FULL SCAN").table(order)
-      .serverWhereFilter("SERVER FILTER BY QUANTITY < 5000").serverSortedBy("[\"O.item_id\"]")
+      .serverWhereFilter("QUANTITY < 5000").serverSortedBy("[\"O.item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end().end();
   }
 
@@ -75,10 +75,9 @@ public class SortMergeJoinGlobalIndexIT extends SortMergeJoinIT {
   protected void assertSelfJoinPlan(Connection conn, String query) throws Exception {
     String itemIndex = getSchemaName() + ".idx_item";
     assertPlan(conn, query).abstractExplainPlan("SORT-MERGE-JOIN (INNER)").scanType("FULL SCAN")
-      .table(itemIndex).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-      .serverSortedBy("[\"I1.:item_id\"]").clientSortAlgo("CLIENT MERGE SORT")
-      .sortMergeSkipMerge(false).rhs().scanType("FULL SCAN").table(itemIndex)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverSortedBy("[\"I2.:item_id\"]")
+      .table(itemIndex).serverFirstKeyOnlyProjection(true).serverSortedBy("[\"I1.:item_id\"]")
+      .clientSortAlgo("CLIENT MERGE SORT").sortMergeSkipMerge(false).rhs().scanType("FULL SCAN")
+      .table(itemIndex).serverFirstKeyOnlyProjection(true).serverSortedBy("[\"I2.:item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
@@ -93,9 +92,9 @@ public class SortMergeJoinGlobalIndexIT extends SortMergeJoinIT {
     ExplainPlanAttributes attributes =
       statement.optimizeQuery().getExplainPlan().getPlanStepsAsAttributes();
     assertPlan(attributes).abstractExplainPlan("SORT-MERGE-JOIN (INNER)").scanType("FULL SCAN")
-      .table(itemIndex).serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-      .serverSortedBy("[\"I.:item_id\"]").clientSortAlgo("CLIENT MERGE SORT")
-      .sortMergeSkipMerge(false).clientRowLimit(4).rhs().scanType("FULL SCAN").table(order)
+      .table(itemIndex).serverFirstKeyOnlyProjection(true).serverSortedBy("[\"I.:item_id\"]")
+      .clientSortAlgo("CLIENT MERGE SORT").sortMergeSkipMerge(false).clientRowLimit(4).rhs()
+      .scanType("FULL SCAN").table(order)
       .serverSortedBy(queryIndex == 0 ? "[\"O.item_id\"]" : "[\"item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end();
   }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinLocalIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinLocalIndexIT.java
index 272fee7a49..8b3cd696eb 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinLocalIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinLocalIndexIT.java
@@ -64,13 +64,13 @@ public class SortMergeJoinLocalIndexIT extends SortMergeJoinIT {
     String supplierIndex = SchemaUtil.getTableName(getSchemaName(), JOIN_SUPPLIER_INDEX);
     assertPlan(conn, query).abstractExplainPlan("SORT-MERGE-JOIN (LEFT)").scanType("RANGE SCAN")
       .table(supplierIndex + "(" + supplier + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverSortedBy("[\"S.:supplier_id\"]")
+      .serverFirstKeyOnlyProjection(true).serverSortedBy("[\"S.:supplier_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").sortMergeSkipMerge(false).rhs()
       .abstractExplainPlan("SORT-MERGE-JOIN (INNER)").scanType("RANGE SCAN")
       .table(itemIndex + "(" + item + ")").keyRanges(" [1]").serverSortedBy("[\"I.:item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").sortMergeSkipMerge(true)
       .clientSortedBy("[\"I.0:supplier_id\"]").rhs().scanType("FULL SCAN").table(order)
-      .serverWhereFilter("SERVER FILTER BY QUANTITY < 5000").serverSortedBy("[\"O.item_id\"]")
+      .serverWhereFilter("QUANTITY < 5000").serverSortedBy("[\"O.item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end().end();
   }
 
@@ -79,11 +79,10 @@ public class SortMergeJoinLocalIndexIT extends SortMergeJoinIT {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     String itemIndex = SchemaUtil.getTableName(getSchemaName(), JOIN_ITEM_INDEX);
     assertPlan(conn, query).abstractExplainPlan("SORT-MERGE-JOIN (INNER)").scanType("RANGE SCAN")
-      .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverSortedBy("[\"I1.:item_id\"]")
-      .clientSortAlgo("CLIENT MERGE SORT").sortMergeSkipMerge(false).rhs().scanType("RANGE SCAN")
-      .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverSortedBy("[\"I2.:item_id\"]")
+      .table(itemIndex + "(" + item + ")").keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
+      .serverSortedBy("[\"I1.:item_id\"]").clientSortAlgo("CLIENT MERGE SORT")
+      .sortMergeSkipMerge(false).rhs().scanType("RANGE SCAN").table(itemIndex + "(" + item + ")")
+      .keyRanges(" [1]").serverFirstKeyOnlyProjection(true).serverSortedBy("[\"I2.:item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end();
   }
 
@@ -99,10 +98,9 @@ public class SortMergeJoinLocalIndexIT extends SortMergeJoinIT {
     ExplainPlanAttributes attributes =
       statement.optimizeQuery().getExplainPlan().getPlanStepsAsAttributes();
     assertPlan(attributes).abstractExplainPlan("SORT-MERGE-JOIN (INNER)").scanType("RANGE SCAN")
-      .table(itemIndex + "(" + item + ")").keyRanges(" [1]")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").serverSortedBy("[\"I.:item_id\"]")
-      .clientSortAlgo("CLIENT MERGE SORT").sortMergeSkipMerge(false).clientRowLimit(4).rhs()
-      .scanType("FULL SCAN").table(order)
+      .table(itemIndex + "(" + item + ")").keyRanges(" [1]").serverFirstKeyOnlyProjection(true)
+      .serverSortedBy("[\"I.:item_id\"]").clientSortAlgo("CLIENT MERGE SORT")
+      .sortMergeSkipMerge(false).clientRowLimit(4).rhs().scanType("FULL SCAN").table(order)
       .serverSortedBy(queryIndex == 0 ? "[\"O.item_id\"]" : "[\"item_id\"]")
       .clientSortAlgo("CLIENT MERGE SORT").end();
   }
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinNoIndexIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinNoIndexIT.java
index 8bf2ac3dfa..3eb29809b5 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinNoIndexIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/join/SortMergeJoinNoIndexIT.java
@@ -64,8 +64,8 @@ public class SortMergeJoinNoIndexIT extends SortMergeJoinIT {
       .table(supplier).sortMergeSkipMerge(false).rhs()
       .abstractExplainPlan("SORT-MERGE-JOIN (INNER)").scanType("FULL SCAN").table(item)
       .sortMergeSkipMerge(true).clientSortedBy("[\"I.supplier_id\"]").rhs().scanType("FULL SCAN")
-      .table(order).serverWhereFilter("SERVER FILTER BY QUANTITY < 5000")
-      .serverSortedBy("[\"O.item_id\"]").clientSortAlgo("CLIENT MERGE SORT").end().end();
+      .table(order).serverWhereFilter("QUANTITY < 5000").serverSortedBy("[\"O.item_id\"]")
+      .clientSortAlgo("CLIENT MERGE SORT").end().end();
   }
 
   @Override
@@ -73,7 +73,7 @@ public class SortMergeJoinNoIndexIT extends SortMergeJoinIT {
     String item = getTableName(conn, JOIN_ITEM_TABLE_FULL_NAME);
     assertPlan(conn, query).abstractExplainPlan("SORT-MERGE-JOIN (INNER)").scanType("FULL SCAN")
       .table(item).sortMergeSkipMerge(false).rhs().scanType("FULL SCAN").table(item)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+      .serverFirstKeyOnlyProjection(true).end();
   }
 
   @Override
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/schema/stats/BaseStatsCollectorIT.java b/phoenix-core/src/it/java/org/apache/phoenix/schema/stats/BaseStatsCollectorIT.java
index 6622f20806..5caec772ae 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/schema/stats/BaseStatsCollectorIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/schema/stats/BaseStatsCollectorIT.java
@@ -267,8 +267,9 @@ public abstract class BaseStatsCollectorIT extends BaseTest {
     assertEquals("PARALLEL 1-WAY", planAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", planAttributes.getExplainScanType());
     assertEquals(physicalTableName, planAttributes.getTableName());
-    assertEquals("SERVER FILTER BY " + (columnEncoded ? "FIRST KEY ONLY" : "EMPTY COLUMN ONLY"),
-      planAttributes.getServerWhereFilter());
+    assertTrue(columnEncoded
+      ? planAttributes.isServerFirstKeyOnlyProjection()
+      : planAttributes.isServerEmptyColumnOnlyProjection());
     conn.close();
   }
 
@@ -296,7 +297,7 @@ public abstract class BaseStatsCollectorIT extends BaseTest {
     assertEquals("PARALLEL 3-WAY", planAttributes.getIteratorTypeAndScanSize());
     assertEquals("FULL SCAN ", planAttributes.getExplainScanType());
     assertEquals(physicalTableName, planAttributes.getTableName());
-    assertEquals("SERVER FILTER BY B.V2 = 'foo'", planAttributes.getServerWhereFilter());
+    assertEquals("B.V2 = 'foo'", planAttributes.getServerWhereFilter());
     assertEquals("CLIENT MERGE SORT", planAttributes.getClientSortAlgo());
 
     long estimatedSizeInBytes = columnEncoded ? 28
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/compile/JoinQueryCompilerTest.java b/phoenix-core/src/test/java/org/apache/phoenix/compile/JoinQueryCompilerTest.java
index 8ee65259d4..07c822230f 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/compile/JoinQueryCompilerTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/compile/JoinQueryCompilerTest.java
@@ -82,13 +82,13 @@ public class JoinQueryCompilerTest extends BaseConnectionlessQueryTest {
         + " s ON s.\"supplier_id\" = i.\"supplier_id\" WHERE i.name LIKE 'T%'";
     // RIGHT JOIN drives the scan over SUPPLIER, with the rest of the join tree nested as sub-plans.
     assertPlan(conn, query).scanType("FULL SCAN").table(JOIN_SUPPLIER_TABLE_DISPLAY_NAME)
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+      .serverFirstKeyOnlyProjection(true)
       .afterJoinFilter("AFTER-JOIN SERVER FILTER BY I.NAME LIKE 'T%'").subPlanCount(1).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
       .table(JOIN_ORDER_TABLE_DISPLAY_NAME).subPlanCount(2).subPlan(0)
       .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 0").scanType("FULL SCAN")
-      .table(JOIN_CUSTOMER_TABLE_DISPLAY_NAME).serverWhereFilter("SERVER FILTER BY NAME LIKE 'C%'")
-      .end().subPlan(1).abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 1").scanType("FULL SCAN")
+      .table(JOIN_CUSTOMER_TABLE_DISPLAY_NAME).serverWhereFilter("NAME LIKE 'C%'").end().subPlan(1)
+      .abstractExplainPlan("PARALLEL LEFT-JOIN TABLE 1").scanType("FULL SCAN")
       .table(JOIN_ITEM_TABLE_DISPLAY_NAME).end().end();
   }
 
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/compile/QueryCompilerTest.java b/phoenix-core/src/test/java/org/apache/phoenix/compile/QueryCompilerTest.java
index 0016d9d4cc..4d38f8edd1 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/compile/QueryCompilerTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/compile/QueryCompilerTest.java
@@ -2548,20 +2548,18 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
       conn.createStatement().execute("CREATE INDEX idx ON t1 (col1 || col2)");
       assertPlan(conn, "SELECT a.k from t1 a where a.col1 || a.col2 = 'foobar'")
         .scanType("RANGE SCAN").table("IDX").keyRanges(" ['foobar']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .serverFirstKeyOnlyProjection(true);
       assertPlan(conn, "SELECT k,j from t3 b join t1 a ON k = j where a.col1 || a.col2 = 'foobar'")
-        .scanType("FULL SCAN").table("T3").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+        .scanType("FULL SCAN").table("T3").serverFirstKeyOnlyProjection(true)
         .dynamicServerFilter("DYNAMIC SERVER FILTER BY B.J IN (\"A.:K\")").subPlanCount(1)
         .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("RANGE SCAN")
-        .table("IDX").keyRanges(" ['foobar']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .end();
+        .table("IDX").keyRanges(" ['foobar']").serverFirstKeyOnlyProjection(true).end();
       assertPlan(conn,
         "SELECT a.k,b.k from t2 b join t1 a ON a.k = b.k where a.col1 || a.col2 = 'foobar'")
-          .scanType("FULL SCAN").table("T2").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
+          .scanType("FULL SCAN").table("T2").serverFirstKeyOnlyProjection(true)
           .dynamicServerFilter("DYNAMIC SERVER FILTER BY B.K IN (\"A.:K\")").subPlanCount(1)
           .subPlan(0).abstractExplainPlan("PARALLEL INNER-JOIN TABLE 0").scanType("RANGE SCAN")
-          .table("IDX").keyRanges(" ['foobar']")
-          .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+          .table("IDX").keyRanges(" ['foobar']").serverFirstKeyOnlyProjection(true).end();
     } finally {
       conn.close();
     }
@@ -7150,7 +7148,7 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
         + " where ts >= TIMESTAMP '2023-02-23 13:30:00'  and ts < TIMESTAMP '2023-02-23 13:40:00'";
       assertPlan(conn, query).scanType("RANGE SCAN").table(indexName)
         .keyRanges(" [~1,677,159,600,000] - [~1,677,159,000,000]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .serverFirstKeyOnlyProjection(true);
     }
   }
 
@@ -7168,7 +7166,7 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
       assertEquals("\\x9E\\x9E\\x9F\\x00", Bytes.toStringBinary(openScan.getStartRow()));
       assertEquals("\\x9E\\xFF", Bytes.toStringBinary(openScan.getStopRow()));
       assertPlan(conn, openQry).scanType("RANGE SCAN").table(tableName)
-        .keyRanges(" [~'aaa'] - [~'a']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .keyRanges(" [~'aaa'] - [~'a']").serverFirstKeyOnlyProjection(true);
 
       String closedQry = "select * from " + tableName + " where k >= 'a' and k <= 'aaa'";
       Scan closedScan =
@@ -7176,7 +7174,7 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
       assertEquals("\\x9E\\x9E\\x9E\\xFF", Bytes.toStringBinary(closedScan.getStartRow()));
       assertEquals("\\x9F\\x00", Bytes.toStringBinary(closedScan.getStopRow()));
       assertPlan(conn, closedQry).scanType("RANGE SCAN").table(tableName)
-        .keyRanges(" [~'aaa'] - [~'a']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .keyRanges(" [~'aaa'] - [~'a']").serverFirstKeyOnlyProjection(true);
     }
   }
 
@@ -7193,10 +7191,9 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
       String query = "select /*+ index(dd ii) */ k1, k2, k3, k4, v1, v2, v3, v4 from dd"
         + " where k4=1 and k2=1 order by k1 asc, v1 asc limit  1";
       assertPlan(conn, query).scanType("RANGE SCAN").table("II").keyRanges(" [1]")
-        .serverMergeColumns("[0.V1, 0.V2, 0.V3, 0.V4]")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND \"K2\" = 1")
-        .serverSortedBy("[\"K1\", \"V1\"]").serverRowLimit(1L).clientRowLimit(1)
-        .clientSortAlgo("CLIENT MERGE SORT");
+        .serverMergeColumns("[0.V1, 0.V2, 0.V3, 0.V4]").serverFirstKeyOnlyProjection(true)
+        .serverWhereFilter("\"K2\" = 1").serverSortedBy("[\"K1\", \"V1\"]").serverRowLimit(1L)
+        .clientRowLimit(1).clientSortAlgo("CLIENT MERGE SORT");
     }
   }
 
@@ -7213,14 +7210,14 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
         + "WHERE K2 = 'XXX' AND " + "V2 >= TIMESTAMP '2023-05-31 23:59:59.000' AND "
         + "V1 <= TIMESTAMP '2023-04-01 00:00:00.000' " + "ORDER BY V2 asc";
       assertPlan(conn, query).scanType("FULL SCAN").table("D")
-        .serverWhereFilter("SERVER FILTER BY (V2 >= TIMESTAMP '2023-05-31 23:59:59.000'"
+        .serverWhereFilter("(V2 >= TIMESTAMP '2023-05-31 23:59:59.000'"
           + " AND V1 <= TIMESTAMP '2023-04-01 00:00:00.000')")
         .serverSortedBy("[D.V2]").clientSortAlgo("CLIENT MERGE SORT")
         .dynamicServerFilter("DYNAMIC SERVER FILTER BY (\"D.K1\", \"D.K2\", \"D.K3\", \"D.K4\")"
           + " IN (($2.$4, $2.$5, $2.$6, $2.$7))")
         .subPlanCount(1).subPlan(0).abstractExplainPlan("SKIP-SCAN-JOIN TABLE 0")
-        .scanType("RANGE SCAN").table("I").keyRanges(" ['XXX']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+        .scanType("RANGE SCAN").table("I").keyRanges(" ['XXX']").serverFirstKeyOnlyProjection(true)
+        .end();
     }
   }
 
@@ -7241,7 +7238,7 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
           + "WHERE K2 = 'XXX' AND " + "V2 >= TIMESTAMP '2023-05-31 23:59:59.000' AND "
           + "V1 <= TIMESTAMP '2023-04-01 00:00:00.000' " + "ORDER BY V2 asc";
       assertPlan(conn, query).scanType("FULL SCAN").table("TAB_PHOENIX_6986")
-        .serverWhereFilter("SERVER FILTER BY (V2 >= TIMESTAMP '2023-05-31 23:59:59.000'"
+        .serverWhereFilter("(V2 >= TIMESTAMP '2023-05-31 23:59:59.000'"
           + " AND V1 <= TIMESTAMP '2023-04-01 00:00:00.000')")
         .serverSortedBy("[TAB_PHOENIX_6986.V2]").clientSortAlgo("CLIENT MERGE SORT")
         .dynamicServerFilter("DYNAMIC SERVER FILTER BY (\"TAB_PHOENIX_6986.K1\","
@@ -7249,7 +7246,7 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
           + " IN (($2.$4, $2.$5, $2.$6, $2.$7))")
         .subPlanCount(1).subPlan(0).abstractExplainPlan("SKIP-SCAN-JOIN TABLE 0")
         .scanType("RANGE SCAN").table("IDX_PHOENIX_6986").keyRanges(" ['XXX']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").end();
+        .serverFirstKeyOnlyProjection(true).end();
     }
   }
 
@@ -7262,7 +7259,7 @@ public class QueryCompilerTest extends BaseConnectionlessQueryTest {
       stmt.execute("create index i on d(v2) include (v3)");
       String query = "select /*+ index(d i) */ * from d where v2=1 and v3=1";
       assertPlan(conn, query).scanType("RANGE SCAN").table("I").keyRanges(" [1]")
-        .serverMergeColumns("[0.V1, 0.V4]").serverWhereFilter("SERVER FILTER BY \"V3\" = 1");
+        .serverMergeColumns("[0.V1, 0.V4]").serverWhereFilter("\"V3\" = 1");
     }
   }
 
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/compile/StatementHintsCompilationTest.java b/phoenix-core/src/test/java/org/apache/phoenix/compile/StatementHintsCompilationTest.java
index 4cdd5dbf92..fcaada4578 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/compile/StatementHintsCompilationTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/compile/StatementHintsCompilationTest.java
@@ -103,7 +103,8 @@ public class StatementHintsCompilationTest extends BaseConnectionlessQueryTest {
     assertPlan(conn, query).scanType("RANGE SCAN").table("EH")
       .keyRanges(" ['111111111111111','foo            ','2012-11-01 00:00:00.000']"
         + " - ['111111111111111','fop            ','2012-11-30 00:00:00.000']")
-      .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY AND (CREATED_DATE >= DATE"
+      .serverFirstKeyOnlyProjection(true)
+      .serverWhereFilter("(CREATED_DATE >= DATE"
         + " '2012-11-01 00:00:00.000' AND CREATED_DATE < DATE '2012-11-30 00:00:00.000')")
       .serverSortedBy("[ORGANIZATION_ID, PARENT_ID, CREATED_DATE DESC, ENTITY_HISTORY_ID]")
       .serverRowLimit(100L).clientSortAlgo("CLIENT MERGE SORT").clientRowLimit(100);
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/compile/TenantSpecificViewIndexCompileTest.java b/phoenix-core/src/test/java/org/apache/phoenix/compile/TenantSpecificViewIndexCompileTest.java
index 02af616cb4..5ea47c2e21 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/compile/TenantSpecificViewIndexCompileTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/compile/TenantSpecificViewIndexCompileTest.java
@@ -17,20 +17,21 @@
  */
 package org.apache.phoenix.compile;
 
+import static org.apache.phoenix.query.explain.ExplainPlanTestUtil.assertPlan;
+import static org.apache.phoenix.query.explain.ExplainPlanTestUtil.getPlanSteps;
 import static org.junit.Assert.assertEquals;
 
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
-import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Calendar;
+import java.util.Collections;
 import java.util.Properties;
 import java.util.TimeZone;
 import org.apache.phoenix.query.BaseConnectionlessQueryTest;
 import org.apache.phoenix.util.DateUtil;
 import org.apache.phoenix.util.PhoenixRuntime;
-import org.apache.phoenix.util.QueryUtil;
 import org.junit.Test;
 
 public class TenantSpecificViewIndexCompileTest extends BaseConnectionlessQueryTest {
@@ -49,11 +50,9 @@ public class TenantSpecificViewIndexCompileTest extends BaseConnectionlessQueryT
     conn.createStatement().execute("CREATE VIEW v(v2 VARCHAR) AS SELECT * FROM t WHERE k1 = 'a'");
     conn.createStatement().execute("CREATE INDEX i1 ON v(v2) INCLUDE(v1)");
 
-    ResultSet rs =
-      conn.createStatement().executeQuery("EXPLAIN SELECT v1,v2 FROM v WHERE v2 > 'a' ORDER BY v2");
-    assertEquals(
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER _IDX_T [-9223372036854775808,'me','a'] - [-9223372036854775808,'me',*]",
-      QueryUtil.getExplainPlan(rs));
+    assertPlan(conn, "SELECT v1,v2 FROM v WHERE v2 > 'a' ORDER BY v2").scanType("RANGE SCAN")
+      .table("_IDX_T").indexName("I1").indexKind("GLOBAL")
+      .keyRanges(" [-9223372036854775808,'me','a'] - [-9223372036854775808,'me',*]");
   }
 
   @Test
@@ -69,35 +68,30 @@ public class TenantSpecificViewIndexCompileTest extends BaseConnectionlessQueryT
 
     // Query without predicate ordered by full row key
     String sql = "SELECT * FROM v1 ORDER BY k1, k2, k3";
-    String expectedExplainOutput = "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(" ['tenant123456789']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Predicate with valid partial PK
     sql = "SELECT * FROM v1 WHERE k1 = 'xyz' ORDER BY k1, k2, k3";
-    expectedExplainOutput = "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(" ['tenant123456789','xyz']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     sql = "SELECT * FROM v1 WHERE k1 > 'xyz' ORDER BY k1, k2, k3";
-    expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xy{'] - ['tenant123456789',*]";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T")
+      .keyRanges(" ['tenant123456789','xy{'] - ['tenant123456789',*]");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     String datePredicate = createStaticDate();
     sql = "SELECT * FROM v1 WHERE k1 = 'xyz' AND k2 = '123456789012345' AND k3 < TO_DATE('"
       + datePredicate + "') ORDER BY k1, k2, k3";
-    expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz','123456789012345',*] - ['tenant123456789','xyz','123456789012345','2015-01-01 08:00:00.000']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(
+      " ['tenant123456789','xyz','123456789012345',*] - ['tenant123456789','xyz','123456789012345','2015-01-01 08:00:00.000']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Predicate without valid partial PK
     sql = "SELECT * FROM v1 WHERE k2 < 'abcde1234567890' ORDER BY k1, k2, k3";
-    expectedExplainOutput = "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789']\n"
-      + "    SERVER FILTER BY K2 < 'abcde1234567890'";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(" ['tenant123456789']")
+      .serverWhereFilter("K2 < 'abcde1234567890'");
     assertOrderByHasBeenOptimizedOut(conn, sql);
   }
 
@@ -113,43 +107,36 @@ public class TenantSpecificViewIndexCompileTest extends BaseConnectionlessQueryT
 
     // Query without predicate ordered by full row key
     String sql = "SELECT * FROM v1 ORDER BY k2, k3";
-    String expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(" ['tenant123456789','xyz']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Query without predicate ordered by full row key, but without column view predicate
     sql = "SELECT * FROM v1 ORDER BY k2, k3";
-    expectedExplainOutput = "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(" ['tenant123456789','xyz']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Predicate with valid partial PK
     sql = "SELECT * FROM v1 WHERE k1 = 'xyz' ORDER BY k2, k3";
-    expectedExplainOutput = "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(" ['tenant123456789','xyz']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     sql = "SELECT * FROM v1 WHERE k2 < 'abcde1234567890' ORDER BY k2, k3";
-    expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz',*] - ['tenant123456789','xyz','abcde1234567890']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T")
+      .keyRanges(" ['tenant123456789','xyz',*] - ['tenant123456789','xyz','abcde1234567890']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Predicate with full PK
     String datePredicate = createStaticDate();
     sql = "SELECT * FROM v1 WHERE k2 = '123456789012345' AND k3 < TO_DATE('" + datePredicate
       + "') ORDER BY k2, k3";
-    expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz','123456789012345',*] - ['tenant123456789','xyz','123456789012345','2015-01-01 08:00:00.000']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(
+      " ['tenant123456789','xyz','123456789012345',*] - ['tenant123456789','xyz','123456789012345','2015-01-01 08:00:00.000']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Predicate with valid partial PK
     sql = "SELECT * FROM v1 WHERE k3 < TO_DATE('" + datePredicate + "') ORDER BY k2, k3";
-    expectedExplainOutput = "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz']\n"
-      + "    SERVER FILTER BY K3 < DATE '" + datePredicate + "'";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(" ['tenant123456789','xyz']")
+      .serverWhereFilter("K3 < DATE '" + datePredicate + "'");
     assertOrderByHasBeenOptimizedOut(conn, sql);
   }
 
@@ -166,30 +153,26 @@ public class TenantSpecificViewIndexCompileTest extends BaseConnectionlessQueryT
 
     // Query without predicate ordered by full row key
     String sql = "SELECT * FROM v1 ORDER BY k3 DESC";
-    String expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz','abcde']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T")
+      .keyRanges(" ['tenant123456789','xyz','abcde']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Query without predicate ordered by full row key, but without column view predicate
     sql = "SELECT * FROM v1 ORDER BY k3 DESC";
-    expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz','abcde']";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T")
+      .keyRanges(" ['tenant123456789','xyz','abcde']");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Query with predicate ordered by full row key
     sql = "SELECT * FROM v1 WHERE k3 <= TO_DATE('" + createStaticDate() + "') ORDER BY k3 DESC";
-    expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['tenant123456789','xyz','abcde',~'2015-01-01 08:00:00.000'] - ['tenant123456789','xyz','abcde',*]";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").table("T").keyRanges(
+      " ['tenant123456789','xyz','abcde',~'2015-01-01 08:00:00.000'] - ['tenant123456789','xyz','abcde',*]");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
     // Query with predicate ordered by full row key with date in reverse order
     sql = "SELECT * FROM v1 WHERE k3 <= TO_DATE('" + createStaticDate() + "') ORDER BY k3";
-    expectedExplainOutput =
-      "CLIENT PARALLEL 1-WAY REVERSE RANGE SCAN OVER T ['tenant123456789','xyz','abcde',~'2015-01-01 08:00:00.000'] - ['tenant123456789','xyz','abcde',*]";
-    assertExplainPlanIsCorrect(conn, sql, expectedExplainOutput);
+    assertPlan(conn, sql).scanType("RANGE SCAN").clientSortedBy("REVERSE").table("T").keyRanges(
+      " ['tenant123456789','xyz','abcde',~'2015-01-01 08:00:00.000'] - ['tenant123456789','xyz','abcde',*]");
     assertOrderByHasBeenOptimizedOut(conn, sql);
 
   }
@@ -208,25 +191,21 @@ public class TenantSpecificViewIndexCompileTest extends BaseConnectionlessQueryT
     conn.createStatement().execute("CREATE VIEW v(v2 VARCHAR) AS SELECT * FROM t WHERE k2 = 'a'");
     conn.createStatement().execute("CREATE INDEX i1 ON v(v2)");
 
-    ResultSet rs = conn.createStatement()
-      .executeQuery("EXPLAIN SELECT v2 FROM v WHERE v2 > 'a' and k2 = 'a' ORDER BY v2,k2");
-    assertEquals(
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER _IDX_T [-9223372036854775808,'me','a'] - [-9223372036854775808,'me',*]\n"
-        + "    SERVER FILTER BY FIRST KEY ONLY",
-      QueryUtil.getExplainPlan(rs));
+    assertPlan(conn, "SELECT v2 FROM v WHERE v2 > 'a' and k2 = 'a' ORDER BY v2,k2")
+      .scanType("RANGE SCAN").table("_IDX_T").indexName("I1").indexKind("GLOBAL")
+      .keyRanges(" [-9223372036854775808,'me','a'] - [-9223372036854775808,'me',*]")
+      .serverFirstKeyOnlyProjection(true);
 
     // Won't use index b/c v1 is not in index, but should optimize out k2 still from the order by
     // K2 will still be referenced in the filter, as these are automatically tacked on to the where
     // clause.
-    rs = conn.createStatement().executeQuery("EXPLAIN SELECT v1 FROM v WHERE v2 > 'a' ORDER BY k2");
-    assertEquals("CLIENT PARALLEL 1-WAY RANGE SCAN OVER T ['me']\n"
-      + "    SERVER FILTER BY (V2 > 'a' AND K2 = 'a')", QueryUtil.getExplainPlan(rs));
+    assertPlan(conn, "SELECT v1 FROM v WHERE v2 > 'a' ORDER BY k2").scanType("RANGE SCAN")
+      .table("T").keyRanges(" ['me']").serverWhereFilter("(V2 > 'a' AND K2 = 'a')");
 
     // If we match K2 against a constant not equal to it's view constant, we should get a degenerate
     // plan
-    rs = conn.createStatement()
-      .executeQuery("EXPLAIN SELECT v1 FROM v WHERE v2 > 'a' and k2='b' ORDER BY k2");
-    assertEquals("DEGENERATE SCAN OVER V", QueryUtil.getExplainPlan(rs));
+    assertEquals(Collections.singletonList("DEGENERATE SCAN OVER V"),
+      getPlanSteps(conn, "SELECT v1 FROM v WHERE v2 > 'a' and k2='b' ORDER BY k2"));
   }
 
   @Test
@@ -246,11 +225,9 @@ public class TenantSpecificViewIndexCompileTest extends BaseConnectionlessQueryT
 
     // Confirm that a read-only view on an updatable view still optimizes out the read-only parts of
     // the updatable view
-    ResultSet rs = conn.createStatement()
-      .executeQuery("EXPLAIN SELECT v2 FROM v2 WHERE v3 > 'a' and k2 = 'a' ORDER BY v3,k2");
-    assertEquals(
-      "CLIENT PARALLEL 1-WAY RANGE SCAN OVER _IDX_T [-9223372036854775808,'me','a'] - [-9223372036854775808,'me',*]",
-      QueryUtil.getExplainPlan(rs));
+    assertPlan(conn, "SELECT v2 FROM v2 WHERE v3 > 'a' and k2 = 'a' ORDER BY v3,k2")
+      .scanType("RANGE SCAN").table("_IDX_T").indexName("I2").indexKind("GLOBAL")
+      .keyRanges(" [-9223372036854775808,'me','a'] - [-9223372036854775808,'me',*]");
   }
 
   // -----------------------------------------------------------------
@@ -265,12 +242,6 @@ public class TenantSpecificViewIndexCompileTest extends BaseConnectionlessQueryT
     return conn;
   }
 
-  private void assertExplainPlanIsCorrect(Connection conn, String sql, String expectedExplainOutput)
-    throws SQLException {
-    ResultSet rs = conn.createStatement().executeQuery("EXPLAIN " + sql);
-    assertEquals(expectedExplainOutput, QueryUtil.getExplainPlan(rs));
-  }
-
   private void assertOrderByHasBeenOptimizedOut(Connection conn, String sql) throws SQLException {
     PreparedStatement stmt = conn.prepareStatement(sql);
     QueryPlan plan = PhoenixRuntime.getOptimizedQueryPlan(stmt);
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/query/QueryPlanTest.java b/phoenix-core/src/test/java/org/apache/phoenix/query/QueryPlanTest.java
index a783ccc0a1..286f3581af 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/query/QueryPlanTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/query/QueryPlanTest.java
@@ -59,11 +59,11 @@ public class QueryPlanTest extends BaseConnectionlessQueryTest {
 
     assertPlan(conn, "SELECT * FROM TENANT_VIEW WHERE username = 'Joe' LIMIT 1")
       .scanType("RANGE SCAN").table("BASE_MULTI_TENANT_TABLE").keyRanges(" ['tenantId']")
-      .serverWhereFilter("SERVER FILTER BY USERNAME = 'Joe'").serverRowLimit(1L).clientRowLimit(1);
+      .serverWhereFilter("USERNAME = 'Joe'").serverRowLimit(1L).clientRowLimit(1);
 
     assertPlan(conn, "SELECT * FROM TENANT_VIEW WHERE col = 'Joe' LIMIT 1").scanType("RANGE SCAN")
-      .table("BASE_MULTI_TENANT_TABLE").keyRanges(" ['tenantId']")
-      .serverWhereFilter("SERVER FILTER BY COL = 'Joe'").serverRowLimit(1L).clientRowLimit(1);
+      .table("BASE_MULTI_TENANT_TABLE").keyRanges(" ['tenantId']").serverWhereFilter("COL = 'Joe'")
+      .serverRowLimit(1L).clientRowLimit(1);
   }
 
   @Test
@@ -82,7 +82,7 @@ public class QueryPlanTest extends BaseConnectionlessQueryTest {
       assertPlan(conn, query).scanType("RANGE SCAN").table("FOO")
         .keyRanges(
           " [X'00','a',~'2016-01-28 23:59:59.999'] -" + " [X'13','a',~'2016-01-28 00:00:00.000']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY").clientSortAlgo("CLIENT MERGE SORT");
+        .serverFirstKeyOnlyProjection(true).clientSortAlgo("CLIENT MERGE SORT");
     } finally {
       conn.close();
     }
@@ -107,7 +107,7 @@ public class QueryPlanTest extends BaseConnectionlessQueryTest {
       assertPlan(conn, query).useRoundRobinIterator(true).scanType("RANGE SCAN").table(tableName)
         .keyRanges(
           " [X'00','a',~'2016-01-28 23:59:59.999'] -" + " [X'13','a',~'2016-01-28 00:00:00.000']")
-        .serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY");
+        .serverFirstKeyOnlyProjection(true);
     } finally {
       conn.close();
     }
@@ -126,8 +126,8 @@ public class QueryPlanTest extends BaseConnectionlessQueryTest {
       // The SERIAL hint is ignored for a non-rowkey ORDER BY, so the iterator stays PARALLEL and a
       // server sort + client merge sort are planned.
       assertPlan(conn, query).iteratorType("PARALLEL").scanType("RANGE SCAN").table("FOO")
-        .keyRanges(" ['a']").serverWhereFilter("SERVER FILTER BY FIRST KEY ONLY")
-        .serverSortedBy("[B, C]").clientSortAlgo("CLIENT MERGE SORT");
+        .keyRanges(" ['a']").serverFirstKeyOnlyProjection(true).serverSortedBy("[B, C]")
+        .clientSortAlgo("CLIENT MERGE SORT");
     } finally {
       conn.close();
     }
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/query/explain/ExplainPlanTest.java b/phoenix-core/src/test/java/org/apache/phoenix/query/explain/ExplainPlanTest.java
index f653d3d69d..46facbc4d9 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/query/explain/ExplainPlanTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/query/explain/ExplainPlanTest.java
@@ -93,12 +93,12 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
       conn.createStatement().execute("CREATE SEQUENCE IF NOT EXISTS " + SEQ);
       conn.createStatement().execute("CREATE TABLE IF NOT EXISTS " + IDX_BASE
         + " (k VARCHAR NOT NULL PRIMARY KEY, a INTEGER, b INTEGER)");
-      conn.createStatement()
-        .execute("CREATE INDEX IF NOT EXISTS " + GLOBAL_IDX + " ON " + IDX_BASE + " (a) INCLUDE(b)");
+      conn.createStatement().execute(
+        "CREATE INDEX IF NOT EXISTS " + GLOBAL_IDX + " ON " + IDX_BASE + " (a) INCLUDE(b)");
       conn.createStatement()
         .execute("CREATE LOCAL INDEX IF NOT EXISTS " + LOCAL_IDX + " ON " + IDX_BASE + " (a)");
-      conn.createStatement()
-        .execute("CREATE UNCOVERED INDEX IF NOT EXISTS " + UNCOVERED_IDX + " ON " + IDX_BASE + " (a)");
+      conn.createStatement().execute(
+        "CREATE UNCOVERED INDEX IF NOT EXISTS " + UNCOVERED_IDX + " ON " + IDX_BASE + " (a)");
       conn.createStatement()
         .execute("CREATE TABLE IF NOT EXISTS " + MT_BASE + " (" + "  tenant_id VARCHAR(8) NOT NULL,"
           + "  userid INTEGER NOT NULL," + "  username VARCHAR NOT NULL," + "  col VARCHAR"
@@ -125,7 +125,7 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
       text("CLIENT PARALLEL <N>-WAY POINT LOOKUP ON 1 KEY OVER ATABLE", "    INDEX ATABLE",
         "    REGIONS PLANNED <N>", "    SERVER FILTER BY (X_INTEGER = 2 AND A_INTEGER < 5)"),
       scanAttrs("POINT LOOKUP ON 1 KEY ", "ATABLE", null).put("serverWhereFilter",
-        "SERVER FILTER BY (X_INTEGER = 2 AND A_INTEGER < 5)"));
+        "(X_INTEGER = 2 AND A_INTEGER < 5)"));
   }
 
   @Test
@@ -144,8 +144,9 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     verifyQuery("rangeScan",
       "SELECT a_string FROM atable WHERE organization_id = '00D000000000001'"
         + " AND entity_id > '00E00000000002' AND entity_id < '00E00000000008'",
-      text("CLIENT PARALLEL <N>-WAY RANGE SCAN OVER ATABLE"
-        + " ['00D000000000001','00E00000000002!'] - ['00D000000000001','00E00000000008 ']",
+      text(
+        "CLIENT PARALLEL <N>-WAY RANGE SCAN OVER ATABLE"
+          + " ['00D000000000001','00E00000000002!'] - ['00D000000000001','00E00000000008 ']",
         "    INDEX ATABLE", "    REGIONS PLANNED <N>"),
       scanAttrs("RANGE SCAN ", "ATABLE",
         " ['00D000000000001','00E00000000002!'] - ['00D000000000001','00E00000000008 ']"));
@@ -155,9 +156,10 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
   public void testSkipScanKeys() throws Exception {
     verifyQuery("skipScanKeys", "SELECT host FROM ptsdb3 WHERE host IN ('na1','na2','na3')",
       text("CLIENT PARALLEL <N>-WAY SKIP SCAN ON 3 KEYS OVER PTSDB3 [~'na3'] - [~'na1']",
-        "    INDEX PTSDB3", "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY"),
-      scanAttrs("SKIP SCAN ON 3 KEYS ", "PTSDB3", " [~'na3'] - [~'na1']").put("serverWhereFilter",
-        "SERVER FILTER BY FIRST KEY ONLY"));
+        "    INDEX PTSDB3", "    REGIONS PLANNED <N>",
+        "    SERVER PROJECTION FILTER BY FIRST KEY ONLY"),
+      scanAttrs("SKIP SCAN ON 3 KEYS ", "PTSDB3", " [~'na3'] - [~'na1']")
+        .put("serverFirstKeyOnlyProjection", true));
   }
 
   @Test
@@ -169,10 +171,11 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
       text(
         "CLIENT PARALLEL <N>-WAY SKIP SCAN ON 6 RANGES OVER PTSDB"
           + " ['na1','a','2013-01-01'] - ['na3','b','2013-01-02']",
-        "    INDEX PTSDB", "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY"),
+        "    INDEX PTSDB", "    REGIONS PLANNED <N>",
+        "    SERVER PROJECTION FILTER BY FIRST KEY ONLY"),
       scanAttrs("SKIP SCAN ON 6 RANGES ", "PTSDB",
-        " ['na1','a','2013-01-01'] - ['na3','b','2013-01-02']").put("serverWhereFilter",
-          "SERVER FILTER BY FIRST KEY ONLY"));
+        " ['na1','a','2013-01-01'] - ['na3','b','2013-01-02']").put("serverFirstKeyOnlyProjection",
+          true));
   }
 
   @Test
@@ -188,9 +191,8 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     verifyQuery("reverseScan",
       "SELECT inst,\"DATE\" FROM ptsdb2 WHERE inst = 'na1' ORDER BY inst DESC, \"DATE\" DESC",
       text("CLIENT PARALLEL <N>-WAY REVERSE RANGE SCAN OVER PTSDB2 ['na1']", "    INDEX PTSDB2",
-        "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY"),
-      scanAttrs("RANGE SCAN ", "PTSDB2", " ['na1']")
-        .put("serverWhereFilter", "SERVER FILTER BY FIRST KEY ONLY")
+        "    REGIONS PLANNED <N>", "    SERVER PROJECTION FILTER BY FIRST KEY ONLY"),
+      scanAttrs("RANGE SCAN ", "PTSDB2", " ['na1']").put("serverFirstKeyOnlyProjection", true)
         .put("clientSortedBy", "REVERSE"));
   }
 
@@ -199,19 +201,19 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     verifyQuery("smallHint",
       "SELECT /*+ SMALL */ host FROM ptsdb3 WHERE host IN ('na1','na2','na3')",
       text("CLIENT PARALLEL <N>-WAY SMALL SKIP SCAN ON 3 KEYS OVER PTSDB3 [~'na3'] - [~'na1']",
-        "    INDEX PTSDB3", "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY"),
+        "    INDEX PTSDB3", "    REGIONS PLANNED <N>",
+        "    SERVER PROJECTION FILTER BY FIRST KEY ONLY"),
       scanAttrs("SKIP SCAN ON 3 KEYS ", "PTSDB3", " [~'na3'] - [~'na1']").put("hint", "SMALL")
-        .put("serverWhereFilter", "SERVER FILTER BY FIRST KEY ONLY"));
+        .put("serverFirstKeyOnlyProjection", true));
   }
 
   @Test
   public void testAggregateSingleRow() throws Exception {
     verifyQuery("aggregateSingleRow", "SELECT count(*) FROM atable",
       text("CLIENT PARALLEL <N>-WAY FULL SCAN OVER ATABLE", "    INDEX ATABLE",
-        "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY",
+        "    REGIONS PLANNED <N>", "    SERVER PROJECTION FILTER BY FIRST KEY ONLY",
         "    SERVER AGGREGATE INTO SINGLE ROW"),
-      scanAttrs("FULL SCAN ", "ATABLE", "")
-        .put("serverWhereFilter", "SERVER FILTER BY FIRST KEY ONLY")
+      scanAttrs("FULL SCAN ", "ATABLE", "").put("serverFirstKeyOnlyProjection", true)
         .put("serverAggregate", "SERVER AGGREGATE INTO SINGLE ROW"));
   }
 
@@ -235,8 +237,7 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
         "    REGIONS PLANNED <N>", "    SERVER FILTER BY A_INTEGER = 1",
         "    SERVER AGGREGATE INTO DISTINCT ROWS BY [ENTITY_ID, ROUND(A_TIME)]",
         "CLIENT MERGE SORT"),
-      scanAttrs("FULL SCAN ", "ATABLE", "")
-        .put("serverWhereFilter", "SERVER FILTER BY A_INTEGER = 1")
+      scanAttrs("FULL SCAN ", "ATABLE", "").put("serverWhereFilter", "A_INTEGER = 1")
         .put("serverAggregate", "SERVER AGGREGATE INTO DISTINCT ROWS BY [ENTITY_ID, ROUND(A_TIME)]")
         .put("clientSortAlgo", "CLIENT MERGE SORT"));
   }
@@ -277,7 +278,7 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
         "    SERVER 10 ROW LIMIT", "CLIENT 10 ROW LIMIT"),
       scanAttrs("RANGE SCAN ", "ATABLE", " ['00D000000000001']")
         .put("serverWhereFilter",
-          "SERVER FILTER BY (ENTITY_ID != '00E00000000002' AND X_INTEGER = 2 AND A_INTEGER < 5)")
+          "(ENTITY_ID != '00E00000000002' AND X_INTEGER = 2 AND A_INTEGER < 5)")
         .put("serverRowLimit", 10).put("clientRowLimit", 10));
   }
 
@@ -295,8 +296,9 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
       "SELECT a_string,b_string FROM atable WHERE organization_id = '000000000000001'"
         + " AND entity_id > '000000000000002' AND entity_id < '000000000000008'"
         + " AND (organization_id,entity_id) <= ('000000000000001','000000000000005')",
-      text("CLIENT PARALLEL <N>-WAY RANGE SCAN OVER ATABLE"
-        + " ['000000000000001','000000000000003'] - ['000000000000001','000000000000005']",
+      text(
+        "CLIENT PARALLEL <N>-WAY RANGE SCAN OVER ATABLE"
+          + " ['000000000000001','000000000000003'] - ['000000000000001','000000000000005']",
         "    INDEX ATABLE", "    REGIONS PLANNED <N>"),
       scanAttrs("RANGE SCAN ", "ATABLE",
         " ['000000000000001','000000000000003'] - ['000000000000001','000000000000005']"));
@@ -314,8 +316,7 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
         "    INDEX ATABLE", "    REGIONS PLANNED <N>",
         "    SERVER FILTER BY (ENTITY_ID > '000000000000002' AND ENTITY_ID < '000000000000008')"),
       scanAttrs("RANGE SCAN ", "ATABLE", " ['000000000000003000000000000005'] - [*]").put(
-        "serverWhereFilter",
-        "SERVER FILTER BY (ENTITY_ID > '000000000000002' AND ENTITY_ID < '000000000000008')"));
+        "serverWhereFilter", "(ENTITY_ID > '000000000000002' AND ENTITY_ID < '000000000000008')"));
   }
 
   @Test
@@ -324,10 +325,11 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
       "SELECT host FROM PTSDB WHERE inst IS NULL AND host IS NOT NULL"
         + " AND \"DATE\" >= to_date('2013-01-01')",
       text("CLIENT PARALLEL <N>-WAY RANGE SCAN OVER PTSDB [null,not null]", "    INDEX PTSDB",
-        "    REGIONS PLANNED <N>",
-        "    SERVER FILTER BY FIRST KEY ONLY AND \"DATE\" >= DATE '2013-01-01 00:00:00.000'"),
-      scanAttrs("RANGE SCAN ", "PTSDB", " [null,not null]").put("serverWhereFilter",
-        "SERVER FILTER BY FIRST KEY ONLY AND \"DATE\" >= DATE '2013-01-01 00:00:00.000'"));
+        "    REGIONS PLANNED <N>", "    SERVER PROJECTION FILTER BY FIRST KEY ONLY",
+        "    SERVER FILTER BY \"DATE\" >= DATE '2013-01-01 00:00:00.000'"),
+      scanAttrs("RANGE SCAN ", "PTSDB", " [null,not null]")
+        .put("serverFirstKeyOnlyProjection", true)
+        .put("serverWhereFilter", "\"DATE\" >= DATE '2013-01-01 00:00:00.000'"));
   }
 
   @Test
@@ -336,11 +338,10 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
       "SELECT host FROM PTSDB WHERE inst IS NOT NULL AND host IS NULL"
         + " AND \"DATE\" >= to_date('2013-01-01')",
       text("CLIENT PARALLEL <N>-WAY RANGE SCAN OVER PTSDB [not null]", "    INDEX PTSDB",
-        "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY AND (HOST IS NULL"
-          + " AND \"DATE\" >= DATE '2013-01-01 00:00:00.000')"),
-      scanAttrs("RANGE SCAN ", "PTSDB", " [not null]").put("serverWhereFilter",
-        "SERVER FILTER BY FIRST KEY ONLY AND (HOST IS NULL"
-          + " AND \"DATE\" >= DATE '2013-01-01 00:00:00.000')"));
+        "    REGIONS PLANNED <N>", "    SERVER PROJECTION FILTER BY FIRST KEY ONLY",
+        "    SERVER FILTER BY (HOST IS NULL" + " AND \"DATE\" >= DATE '2013-01-01 00:00:00.000')"),
+      scanAttrs("RANGE SCAN ", "PTSDB", " [not null]").put("serverFirstKeyOnlyProjection", true)
+        .put("serverWhereFilter", "(HOST IS NULL AND \"DATE\" >= DATE '2013-01-01 00:00:00.000')"));
   }
 
   @Test
@@ -351,10 +352,11 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
       text(
         "CLIENT PARALLEL <N>-WAY SKIP SCAN ON 2 RANGES OVER PTSDB"
           + " ['na','a','2013-01-01'] - ['nb','b','2013-01-02']",
-        "    INDEX PTSDB", "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY"),
+        "    INDEX PTSDB", "    REGIONS PLANNED <N>",
+        "    SERVER PROJECTION FILTER BY FIRST KEY ONLY"),
       scanAttrs("SKIP SCAN ON 2 RANGES ", "PTSDB",
-        " ['na','a','2013-01-01'] - ['nb','b','2013-01-02']").put("serverWhereFilter",
-          "SERVER FILTER BY FIRST KEY ONLY"));
+        " ['na','a','2013-01-01'] - ['nb','b','2013-01-02']").put("serverFirstKeyOnlyProjection",
+          true));
   }
 
   @Test
@@ -362,10 +364,12 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     verifyQuery("skipScanRegexpRanges",
       "SELECT inst,host FROM PTSDB WHERE REGEXP_SUBSTR(INST, '[^-]+', 1) IN ('na1', 'na2','na3')",
       text("CLIENT PARALLEL <N>-WAY SKIP SCAN ON 3 RANGES OVER PTSDB ['na1'] - ['na4']",
-        "    INDEX PTSDB", "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY AND"
-          + " REGEXP_SUBSTR(INST, '[^-]+', 1) IN ('na1','na2','na3')"),
-      scanAttrs("SKIP SCAN ON 3 RANGES ", "PTSDB", " ['na1'] - ['na4']").put("serverWhereFilter",
-        "SERVER FILTER BY FIRST KEY ONLY AND REGEXP_SUBSTR(INST, '[^-]+', 1) IN ('na1','na2','na3')"));
+        "    INDEX PTSDB", "    REGIONS PLANNED <N>",
+        "    SERVER PROJECTION FILTER BY FIRST KEY ONLY",
+        "    SERVER FILTER BY REGEXP_SUBSTR(INST, '[^-]+', 1) IN ('na1','na2','na3')"),
+      scanAttrs("SKIP SCAN ON 3 RANGES ", "PTSDB", " ['na1'] - ['na4']")
+        .put("serverFirstKeyOnlyProjection", true)
+        .put("serverWhereFilter", "REGEXP_SUBSTR(INST, '[^-]+', 1) IN ('na1','na2','na3')"));
   }
 
   @Test
@@ -373,8 +377,9 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     verifyQuery("rangeScanSubstrBounds",
       "SELECT a_string FROM atable WHERE organization_id='000000000000001'"
         + " AND SUBSTR(entity_id,1,3) > '002' AND SUBSTR(entity_id,1,3) <= '003'",
-      text("CLIENT PARALLEL <N>-WAY RANGE SCAN OVER ATABLE"
-        + " ['000000000000001','003            '] - ['000000000000001','004            ']",
+      text(
+        "CLIENT PARALLEL <N>-WAY RANGE SCAN OVER ATABLE"
+          + " ['000000000000001','003            '] - ['000000000000001','004            ']",
         "    INDEX ATABLE", "    REGIONS PLANNED <N>"),
       scanAttrs("RANGE SCAN ", "ATABLE",
         " ['000000000000001','003            '] - ['000000000000001','004            ']"));
@@ -385,9 +390,10 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     verifyQuery("skipScanTwoKeys",
       "SELECT a_string,b_string FROM atable"
         + " WHERE organization_id IN ('000000000000001', '000000000000005')",
-      text("CLIENT PARALLEL <N>-WAY SKIP SCAN ON 2 KEYS OVER ATABLE"
-        + " ['000000000000001'] - ['000000000000005']", "    INDEX ATABLE",
-        "    REGIONS PLANNED <N>"),
+      text(
+        "CLIENT PARALLEL <N>-WAY SKIP SCAN ON 2 KEYS OVER ATABLE"
+          + " ['000000000000001'] - ['000000000000005']",
+        "    INDEX ATABLE", "    REGIONS PLANNED <N>"),
       scanAttrs("SKIP SCAN ON 2 KEYS ", "ATABLE", " ['000000000000001'] - ['000000000000005']"));
   }
 
@@ -408,8 +414,8 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
       "SELECT a_string,b_string FROM atable WHERE organization_id = '000000000000001'"
         + " ORDER BY a_string ASC NULLS FIRST LIMIT 10",
       text("CLIENT PARALLEL <N>-WAY RANGE SCAN OVER ATABLE ['000000000000001']", "    INDEX ATABLE",
-        "    REGIONS PLANNED <N>", "    SERVER TOP 10 ROWS SORTED BY [A_STRING]", "CLIENT MERGE SORT",
-        "CLIENT LIMIT 10"),
+        "    REGIONS PLANNED <N>", "    SERVER TOP 10 ROWS SORTED BY [A_STRING]",
+        "CLIENT MERGE SORT", "CLIENT LIMIT 10"),
       scanAttrs("RANGE SCAN ", "ATABLE", " ['000000000000001']").put("serverSortedBy", "[A_STRING]")
         .put("serverRowLimit", 10).put("clientRowLimit", 10)
         .put("clientSortAlgo", "CLIENT MERGE SORT"));
@@ -435,7 +441,8 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
         + " GROUP BY organization_id,entity_id,ROUND(a_date,'HOUR')"
         + " ORDER BY entity_id NULLS LAST LIMIT 10",
       text("CLIENT PARALLEL <N>-WAY RANGE SCAN OVER ATABLE ['000000000000001']", "    INDEX ATABLE",
-        "    REGIONS PLANNED <N>", "    SERVER AGGREGATE INTO DISTINCT ROWS BY"
+        "    REGIONS PLANNED <N>",
+        "    SERVER AGGREGATE INTO DISTINCT ROWS BY"
           + " [ORGANIZATION_ID, ENTITY_ID, ROUND(A_DATE)]",
         "CLIENT MERGE SORT", "CLIENT 10 ROW LIMIT"),
       scanAttrs("RANGE SCAN ", "ATABLE", " ['000000000000001']")
@@ -453,8 +460,7 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
         "    REGIONS PLANNED <N>", "    SERVER FILTER BY A_INTEGER = 1",
         "    SERVER AGGREGATE INTO DISTINCT ROWS BY [A_STRING, B_STRING]", "CLIENT MERGE SORT",
         "CLIENT FILTER BY MAX(A_STRING) = 'a'", "CLIENT SORTED BY [B_STRING]"),
-      scanAttrs("FULL SCAN ", "ATABLE", "")
-        .put("serverWhereFilter", "SERVER FILTER BY A_INTEGER = 1")
+      scanAttrs("FULL SCAN ", "ATABLE", "").put("serverWhereFilter", "A_INTEGER = 1")
         .put("serverAggregate", "SERVER AGGREGATE INTO DISTINCT ROWS BY [A_STRING, B_STRING]")
         .put("clientFilterBy", "MAX(A_STRING) = 'a'").put("clientSortedBy", "[B_STRING]")
         .put("clientOffset", 0).put("clientSortAlgo", "CLIENT MERGE SORT"));
@@ -502,7 +508,7 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
   public void testHashJoinSemiInSubquery() throws Exception {
     ObjectNode child =
       scanAttrs("FULL SCAN ", "ATABLE", "").put("abstractExplainPlan", "SKIP-SCAN-JOIN TABLE 0")
-        .put("serverWhereFilter", "SERVER FILTER BY A_INTEGER = 1")
+        .put("serverWhereFilter", "A_INTEGER = 1")
         .put("serverAggregate", "SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY [ORGANIZATION_ID]");
     ObjectNode expected = scanAttrs("FULL SCAN ", "ATABLE", "");
     expected.set("subPlans", mapper.createArrayNode().add(child));
@@ -585,9 +591,9 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     verifyMutation("deleteServer", "DELETE FROM atable WHERE entity_id = 'abc'", true,
       text("DELETE ROWS SERVER SELECT", "CLIENT PARALLEL <N>-WAY FULL SCAN OVER ATABLE",
         "    INDEX ATABLE", "    REGIONS PLANNED <N>",
-        "    SERVER FILTER BY FIRST KEY ONLY AND ENTITY_ID = 'abc'"),
+        "    SERVER PROJECTION FILTER BY FIRST KEY ONLY", "    SERVER FILTER BY ENTITY_ID = 'abc'"),
       scanAttrs("FULL SCAN ", "ATABLE", "").put("abstractExplainPlan", "DELETE ROWS SERVER SELECT")
-        .put("serverWhereFilter", "SERVER FILTER BY FIRST KEY ONLY AND ENTITY_ID = 'abc'"));
+        .put("serverFirstKeyOnlyProjection", true).put("serverWhereFilter", "ENTITY_ID = 'abc'"));
   }
 
   @Test
@@ -595,19 +601,19 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     verifyMutation("deleteClient", "DELETE FROM atable WHERE entity_id = 'abc'", false,
       text("DELETE ROWS CLIENT SELECT", "CLIENT PARALLEL <N>-WAY FULL SCAN OVER ATABLE",
         "    INDEX ATABLE", "    REGIONS PLANNED <N>",
-        "    SERVER FILTER BY FIRST KEY ONLY AND ENTITY_ID = 'abc'"),
+        "    SERVER PROJECTION FILTER BY FIRST KEY ONLY", "    SERVER FILTER BY ENTITY_ID = 'abc'"),
       scanAttrs("FULL SCAN ", "ATABLE", "").put("abstractExplainPlan", "DELETE ROWS CLIENT SELECT")
-        .put("serverWhereFilter", "SERVER FILTER BY FIRST KEY ONLY AND ENTITY_ID = 'abc'"));
+        .put("serverFirstKeyOnlyProjection", true).put("serverWhereFilter", "ENTITY_ID = 'abc'"));
   }
 
   @Test
   public void testSequenceNextValue() throws Exception {
     verifyQuery("sequenceNextValue", "SELECT NEXT VALUE FOR " + SEQ + " FROM atable",
       text("CLIENT PARALLEL <N>-WAY FULL SCAN OVER ATABLE", "    INDEX ATABLE",
-        "    REGIONS PLANNED <N>", "    SERVER FILTER BY FIRST KEY ONLY",
+        "    REGIONS PLANNED <N>", "    SERVER PROJECTION FILTER BY FIRST KEY ONLY",
         "CLIENT RESERVE VALUES FROM 1 SEQUENCE"),
-      scanAttrs("FULL SCAN ", "ATABLE", "")
-        .put("serverWhereFilter", "SERVER FILTER BY FIRST KEY ONLY").put("clientSequenceCount", 1));
+      scanAttrs("FULL SCAN ", "ATABLE", "").put("serverFirstKeyOnlyProjection", true)
+        .put("clientSequenceCount", 1));
   }
 
   @Test
@@ -617,8 +623,7 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
         "    SALT BUCKETS 4", "    REGIONS PLANNED <N>", "    SERVER FILTER BY V = 7",
         "CLIENT MERGE SORT"),
       scanAttrs("FULL SCAN ", "EO_SALTED", "").put("saltBuckets", 4)
-        .put("serverWhereFilter", "SERVER FILTER BY V = 7")
-        .put("clientSortAlgo", "CLIENT MERGE SORT"));
+        .put("serverWhereFilter", "V = 7").put("clientSortAlgo", "CLIENT MERGE SORT"));
   }
 
   @Test
@@ -676,8 +681,8 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
   @Test
   public void testRegionsPlannedAlwaysEmitted() throws Exception {
     try (Connection conn = DriverManager.getConnection(getUrl(), defaultProps())) {
-      List<String> steps =
-        ExplainPlanTestUtil.getPlanSteps(conn, "SELECT * FROM atable WHERE organization_id = '00D'");
+      List<String> steps = ExplainPlanTestUtil.getPlanSteps(conn,
+        "SELECT * FROM atable WHERE organization_id = '00D'");
       boolean hasRegionsPlanned = false;
       for (String line : steps) {
         if (line.trim().startsWith("REGIONS PLANNED ")) {
@@ -708,9 +713,8 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
   @Test
   public void testIndexKindLocal() throws Exception {
     try (Connection conn = DriverManager.getConnection(getUrl(), defaultProps())) {
-      ExplainPlan plan = ExplainPlanTestUtil.getExplainPlan(conn,
-        "SELECT /*+ INDEX(" + IDX_BASE + " " + LOCAL_IDX + ") */ a FROM " + IDX_BASE
-          + " WHERE a = 1");
+      ExplainPlan plan = ExplainPlanTestUtil.getExplainPlan(conn, "SELECT /*+ INDEX(" + IDX_BASE
+        + " " + LOCAL_IDX + ") */ a FROM " + IDX_BASE + " WHERE a = 1");
       ExplainPlanAttributes attrs = plan.getPlanStepsAsAttributes();
       // For a local index the INDEX line carries just the index name with the LOCAL kind token,
       // while the OVER clause keeps the disambiguating idx(phys) form.
@@ -724,9 +728,8 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
   @Test
   public void testIndexKindUncoveredGlobal() throws Exception {
     try (Connection conn = DriverManager.getConnection(getUrl(), defaultProps())) {
-      ExplainPlan plan = ExplainPlanTestUtil.getExplainPlan(conn,
-        "SELECT /*+ INDEX(" + IDX_BASE + " " + UNCOVERED_IDX + ") */ a FROM " + IDX_BASE
-          + " WHERE a = 1");
+      ExplainPlan plan = ExplainPlanTestUtil.getExplainPlan(conn, "SELECT /*+ INDEX(" + IDX_BASE
+        + " " + UNCOVERED_IDX + ") */ a FROM " + IDX_BASE + " WHERE a = 1");
       ExplainPlanAttributes attrs = plan.getPlanStepsAsAttributes();
       assertEquals(UNCOVERED_IDX, attrs.getIndexName());
       assertEquals("UNCOVERED GLOBAL", attrs.getIndexKind());
@@ -737,8 +740,7 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
 
   @Test
   public void testTextNormalizerCollapsesRegionsPlanned() {
-    assertEquals(
-      Collections.singletonList("    REGIONS PLANNED <N>"),
+    assertEquals(Collections.singletonList("    REGIONS PLANNED <N>"),
       new ExplainTextNormalizer().normalize(Arrays.asList("    REGIONS PLANNED 20")));
   }
 
@@ -1025,6 +1027,8 @@ public class ExplainPlanTest extends BaseConnectionlessQueryTest {
     n.putNull("indexKind");
     n.putNull("saltBuckets");
     n.putNull("regionsPlanned");
+    n.put("serverFirstKeyOnlyProjection", false);
+    n.put("serverEmptyColumnOnlyProjection", false);
     n.putNull("iteratorTypeAndScanSize");
     n.putNull("samplingRate");
     n.put("useRoundRobinIterator", false);
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/query/explain/ExplainPlanTestUtil.java b/phoenix-core/src/test/java/org/apache/phoenix/query/explain/ExplainPlanTestUtil.java
index 6a969d87f6..0f79f98d34 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/query/explain/ExplainPlanTestUtil.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/query/explain/ExplainPlanTestUtil.java
@@ -141,6 +141,33 @@ public final class ExplainPlanTestUtil {
       return this;
     }
 
+    /** Assert the chosen index/table name reported on the per-scan {@code INDEX <name>} line. */
+    public ExplainPlanAssert indexName(String expected) {
+      assertEquals(at("indexName"), expected, attributes.getIndexName());
+      return this;
+    }
+
+    /**
+     * Assert the index kind token (e.g. {@code "GLOBAL"}, {@code "LOCAL"},
+     * {@code "UNCOVERED GLOBAL"}); {@code null} when the chosen target is a data table.
+     */
+    public ExplainPlanAssert indexKind(String expected) {
+      assertEquals(at("indexKind"), expected, attributes.getIndexKind());
+      return this;
+    }
+
+    /** Assert the salt bucket count reported on the per-scan {@code SALT BUCKETS <n>} line. */
+    public ExplainPlanAssert saltBuckets(Integer expected) {
+      assertEquals(at("saltBuckets"), expected, attributes.getSaltBuckets());
+      return this;
+    }
+
+    /** Assert the region count reported on the per-scan {@code REGIONS PLANNED <n>} line. */
+    public ExplainPlanAssert regionsPlanned(Integer expected) {
+      assertEquals(at("regionsPlanned"), expected, attributes.getRegionsPlanned());
+      return this;
+    }
+
     /**
      * Assert the scanned table or index name contains {@code expected}. Useful for "index used"
      * checks where the exact name carries a suffix.
@@ -183,6 +210,18 @@ public final class ExplainPlanTestUtil {
       return this;
     }
 
+    public ExplainPlanAssert serverFirstKeyOnlyProjection(boolean expected) {
+      assertEquals(at("serverFirstKeyOnlyProjection"), expected,
+        attributes.isServerFirstKeyOnlyProjection());
+      return this;
+    }
+
+    public ExplainPlanAssert serverEmptyColumnOnlyProjection(boolean expected) {
+      assertEquals(at("serverEmptyColumnOnlyProjection"), expected,
+        attributes.isServerEmptyColumnOnlyProjection());
+      return this;
+    }
+
     public ExplainPlanAssert serverAggregate(String expected) {
       assertEquals(at("serverAggregate"), expected, attributes.getServerAggregate());
       return this;