Include planner configuration in the QueryCacheKey (#3463)

This includes part of the planner configurations and the index fetch
method in the plan cache primary key.

It resolves #3479.

Author: hatyo

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

@@ -281,6 +281,15 @@ public boolean isRuleEnabled(@Nonnull PlannerRule<?, ?> rule) {
         return !disabledTransformationRules.contains(rule.getClass().getSimpleName());
     }
 
+    /**
+     * Returns the set of disabled transformation rules.
+     * @return set of disabled transformation rules.
+     */
+    @Nonnull
+    public Set<String> getDisabledTransformationRules() {
+        return disabledTransformationRules;
+    }
+
     /**
      * Return whether the query planner should defer cross products during join enumeration.
      * <br>

fdb-relational-api/src/main/java/com/apple/foundationdb/relational/api/Options.java

@@ -133,7 +133,9 @@ public enum Name {
          * By default, no rules are disabled, and the user should be able to leave this
          * unset. This is intended as an escape hatch in case the introduction of a new
          * planner rule causes trouble for an existing query.
-         *
+         * <p>
+         * This option is experimental, and is meant to be used for debugging purposes only.
+         * </p>
          * Scope: Connection, Query
          */
         DISABLED_PLANNER_RULES,
@@ -145,7 +147,9 @@ public enum Name {
          * the planning phase may now need to match a more complicated query, but it can
          * be used as a way to disable the rewrite phase if certain queries either
          * encounter an error or take too much time exploring different rewrites.
-         *
+         * <p>
+         * This option is experimental, and is meant to be used for debugging purposes only.
+         * </p>
          * Scope: Connection, Query
          */
         DISABLE_PLANNER_REWRITING,

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/AbstractEmbeddedStatement.java

@@ -64,7 +64,8 @@ public AbstractEmbeddedStatement(@Nonnull final EmbeddedRelationalConnection con
     }
 
     @Nonnull
-    abstract PlanContext buildPlanContext(@Nonnull FDBRecordStoreBase<?> store) throws RelationalException;
+    abstract PlanContext createPlanContext(@Nonnull FDBRecordStoreBase<?> store,
+                                           @Nonnull Options options) throws RelationalException;
 
     @SuppressWarnings("PMD.PreserveStackTrace")
     public boolean executeInternal(String sql) throws SQLException, RelationalException {
@@ -81,8 +82,8 @@ public boolean executeInternal(String sql) throws SQLException, RelationalExcept
                 try (var schema = conn.getRecordLayerDatabase().loadSchema(conn.getSchema())) {
                     final var planCacheMaybe = Optional.ofNullable(conn.getRecordLayerDatabase().getPlanCache());
                     final var store = schema.loadStore().unwrap(FDBRecordStoreBase.class);
-                    final var planGenerator = PlanGenerator.of(planCacheMaybe,
-                            buildPlanContext(store),
+                    final var planGenerator = PlanGenerator.create(planCacheMaybe,
+                            createPlanContext(store, options),
                             store.getRecordMetaData(),
                             store.getRecordStoreState(), this.options);
                     final Plan<?> plan = planGenerator.getPlan(sql);

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/EmbeddedRelationalPreparedStatement.java

@@ -23,6 +23,7 @@
 import com.apple.foundationdb.annotation.API;
 
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
+import com.apple.foundationdb.relational.api.Options;
 import com.apple.foundationdb.relational.api.RelationalPreparedStatement;
 import com.apple.foundationdb.relational.api.RelationalResultSet;
 import com.apple.foundationdb.relational.api.exceptions.ErrorCode;
@@ -216,9 +217,9 @@ public void setNull(String parameterName, int sqlType) throws SQLException {
 
     @Override
     @Nonnull
-    PlanContext buildPlanContext(final @Nonnull FDBRecordStoreBase<?> store) throws RelationalException {
+    PlanContext createPlanContext(@Nonnull final FDBRecordStoreBase<?> store, @Nonnull final Options options) throws RelationalException {
         return PlanContext.builder()
-                .fromRecordStore(store)
+                .fromRecordStore(store, options)
                 .fromDatabase(conn.getRecordLayerDatabase())
                 .withMetricsCollector(Assert.notNullUnchecked(conn.getMetricCollector()))
                 .withPreparedParameters(PreparedParams.of(parameters, namedParameters))

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/EmbeddedRelationalStatement.java

@@ -58,9 +58,9 @@ public EmbeddedRelationalStatement(@Nonnull EmbeddedRelationalConnection conn) t
 
     @Override
     @Nonnull
-    PlanContext buildPlanContext(final @Nonnull FDBRecordStoreBase<?> store) throws RelationalException {
+    PlanContext createPlanContext(@Nonnull final FDBRecordStoreBase<?> store, @Nonnull final Options options) throws RelationalException {
         return PlanContext.builder()
-                .fromRecordStore(store)
+                .fromRecordStore(store, options)
                 .fromDatabase(conn.getRecordLayerDatabase())
                 .withMetricsCollector(Assert.notNullUnchecked(conn.getMetricCollector()))
                 .withSchemaTemplate(conn.getTransaction().getBoundSchemaTemplateMaybe().orElse(conn.getSchemaTemplate()))

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/AstNormalizer.java

@@ -59,7 +59,6 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Struct;
-import java.util.BitSet;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
@@ -78,7 +77,7 @@
  *     <li>understand parameters necessary for execution: limit, offset, continuation, and explain flag. These parameters are
  *     necessary for Relational to prepare the plan for execution.</li>
  *     <li>process in-predicate and generate array literal of the in-list contains simple constants.</li>
- *     <li>identify query caching flags that might influence its interaction with plan cache (see {@link Result.QueryCachingFlags}).</li>
+ *     <li>identify query caching flags that might influence its interaction with plan cache (see {@link NormalizationResult.QueryCachingFlags}).</li>
  * </ul>
  * <p>
  * The visitor is designed to be very fast;
@@ -135,7 +134,7 @@ public final class AstNormalizer extends RelationalParserBaseVisitor<Object> {
     private final PreparedParams preparedStatementParameters;
 
     @Nonnull
-    private final Set<Result.QueryCachingFlags> queryCachingFlags;
+    private final Set<NormalizationResult.QueryCachingFlags> queryCachingFlags;
 
     @Nonnull
     private final Options.Builder queryOptions;
@@ -165,7 +164,7 @@ private AstNormalizer(@Nonnull final PreparedParams preparedStatementParameters,
         this.preparedStatementParameters = preparedStatementParameters;
         allowTokenAddition = true;
         allowLiteralAddition = true;
-        queryCachingFlags = EnumSet.noneOf(Result.QueryCachingFlags.class);
+        queryCachingFlags = EnumSet.noneOf(NormalizationResult.QueryCachingFlags.class);
         queryOptions = Options.builder();
         this.caseSensitive = caseSensitive;
     }
@@ -224,7 +223,7 @@ public String getCanonicalSqlString() {
     }
 
     @Nonnull
-    public Set<Result.QueryCachingFlags> getQueryCachingFlags() {
+    public Set<NormalizationResult.QueryCachingFlags> getQueryCachingFlags() {
         return queryCachingFlags;
     }
 
@@ -267,7 +266,7 @@ public Void visitLimitClauseAtom(RelationalParser.LimitClauseAtomContext ctx) {
     @Override
     public Object visitQuery(@Nonnull RelationalParser.QueryContext ctx) {
         if (queryCachingFlags.isEmpty()) {
-            queryCachingFlags.add(Result.QueryCachingFlags.IS_DQL_STATEMENT);
+            queryCachingFlags.add(NormalizationResult.QueryCachingFlags.IS_DQL_STATEMENT);
         }
         if (ctx.ctes() != null) {
             visit(ctx.ctes());
@@ -296,7 +295,7 @@ public RelationalExpression visitQueryOptions(@Nonnull RelationalParser.QueryOpt
     public Object visitQueryOption(@Nonnull RelationalParser.QueryOptionContext ctx) {
         try {
             if (ctx.NOCACHE() != null) {
-                queryCachingFlags.add(Result.QueryCachingFlags.WITH_NO_CACHE_OPTION);
+                queryCachingFlags.add(NormalizationResult.QueryCachingFlags.WITH_NO_CACHE_OPTION);
             }
             if (ctx.LOG() != null) {
                 queryOptions.withOption(Options.Name.LOG_QUERY, true);
@@ -315,37 +314,37 @@ public Object visitQueryOption(@Nonnull RelationalParser.QueryOptionContext ctx)
 
     @Override
     public Object visitDdlStatement(@Nonnull RelationalParser.DdlStatementContext ctx) {
-        queryCachingFlags.add(Result.QueryCachingFlags.IS_DDL_STATEMENT);
+        queryCachingFlags.add(NormalizationResult.QueryCachingFlags.IS_DDL_STATEMENT);
         return visitChildren(ctx);
     }
 
     @Override
     public Object visitInsertStatement(final RelationalParser.InsertStatementContext ctx) {
-        queryCachingFlags.add(Result.QueryCachingFlags.IS_INSERT_STATEMENT);
+        queryCachingFlags.add(NormalizationResult.QueryCachingFlags.IS_INSERT_STATEMENT);
         return super.visitInsertStatement(ctx);
     }
 
     @Override
     public Object visitUpdateStatement(final RelationalParser.UpdateStatementContext ctx) {
-        queryCachingFlags.add(Result.QueryCachingFlags.IS_UPDATE_STATEMENT);
+        queryCachingFlags.add(NormalizationResult.QueryCachingFlags.IS_UPDATE_STATEMENT);
         return super.visitUpdateStatement(ctx);
     }
 
     @Override
     public Object visitDeleteStatement(final RelationalParser.DeleteStatementContext ctx) {
-        queryCachingFlags.add(Result.QueryCachingFlags.IS_DELETE_STATEMENT);
+        queryCachingFlags.add(NormalizationResult.QueryCachingFlags.IS_DELETE_STATEMENT);
         return super.visitDeleteStatement(ctx);
     }
 
     @Override
     public Object visitAdministrationStatement(@Nonnull RelationalParser.AdministrationStatementContext ctx) {
-        queryCachingFlags.add(Result.QueryCachingFlags.IS_ADMIN_STATEMENT);
+        queryCachingFlags.add(NormalizationResult.QueryCachingFlags.IS_ADMIN_STATEMENT);
         return visitChildren(ctx);
     }
 
     @Override
     public Object visitUtilityStatement(@Nonnull RelationalParser.UtilityStatementContext ctx) {
-        queryCachingFlags.add(Result.QueryCachingFlags.IS_UTILITY_STATEMENT);
+        queryCachingFlags.add(NormalizationResult.QueryCachingFlags.IS_UTILITY_STATEMENT);
         return visitChildren(ctx);
     }
 
@@ -486,8 +485,8 @@ public Object visitInPredicate(@Nonnull RelationalParser.InPredicateContext ctx)
 
     @Override
     public Object visitExecuteContinuationStatement(@Nonnull RelationalParser.ExecuteContinuationStatementContext ctx) {
-        queryCachingFlags.add(Result.QueryCachingFlags.IS_EXECUTE_CONTINUATION_STATEMENT);
-        queryCachingFlags.add(Result.QueryCachingFlags.WITH_NO_CACHE_OPTION);
+        queryCachingFlags.add(NormalizationResult.QueryCachingFlags.IS_EXECUTE_CONTINUATION_STATEMENT);
+        queryCachingFlags.add(NormalizationResult.QueryCachingFlags.WITH_NO_CACHE_OPTION);
         if (ctx.queryOptions() != null) {
             ctx.queryOptions().accept(this);
         }
@@ -575,10 +574,10 @@ private void processLiteral(@Nonnull final Object literal, final int tokenIndex,
      * @return The query parse tree along with contextual information required for planning and executing it.
      */
     @Nonnull
-    public static Result normalizeQuery(@Nonnull final PlanContext context,
-                                        @Nonnull final String query,
-                                        boolean isCaseSensitive,
-                                        @Nonnull final PlanHashable.PlanHashMode currentPlanHashMode) throws RelationalException {
+    public static NormalizationResult normalizeQuery(@Nonnull final PlanContext context,
+                                                     @Nonnull final String query,
+                                                     boolean isCaseSensitive,
+                                                     @Nonnull final PlanHashable.PlanHashMode currentPlanHashMode) throws RelationalException {
         // lexing, parsing, and normalization are profiled through the metric collector.
         final var metricCollector = context.getMetricsCollector();
         final var rootContext = metricCollector.clock(RelationalMetric.RelationalEvent.LEX_PARSE,
@@ -588,7 +587,7 @@ public static Result normalizeQuery(@Nonnull final PlanContext context,
                         context.getSchemaTemplate(), rootContext,
                         PreparedParams.copyOf(context.getPreparedStatementParameters()),
                         context.getUserVersion(),
-                        context.getSchemaTemplate().getIndexEntriesAsBitset(context.getPlannerConfiguration().getReadableIndexes()),
+                        context.getPlannerConfiguration(),
                         isCaseSensitive,
                         currentPlanHashMode,
                         query
@@ -597,14 +596,14 @@ public static Result normalizeQuery(@Nonnull final PlanContext context,
 
     @Nonnull
     @VisibleForTesting
-    public static Result normalizeAst(@Nonnull final SchemaTemplate schemaTemplate,
-                                      @Nonnull final RelationalParser.RootContext context,
-                                      @Nonnull final PreparedParams preparedStatementParameters,
-                                      int userVersion,
-                                      @Nonnull final BitSet readableIndexes,
-                                      boolean caseSensitive,
-                                      @Nonnull final PlanHashable.PlanHashMode currentPlanHashMode,
-                                      @Nonnull final String query) {
+    public static NormalizationResult normalizeAst(@Nonnull final SchemaTemplate schemaTemplate,
+                                                   @Nonnull final RelationalParser.RootContext context,
+                                                   @Nonnull final PreparedParams preparedStatementParameters,
+                                                   int userVersion,
+                                                   @Nonnull final PlannerConfiguration plannerConfiguration,
+                                                   boolean caseSensitive,
+                                                   @Nonnull final PlanHashable.PlanHashMode currentPlanHashMode,
+                                                   @Nonnull final String query) {
         final var astNormalizer = new AstNormalizer(preparedStatementParameters, caseSensitive, currentPlanHashMode);
         astNormalizer.visit(context);
         final var recordLayerSchemaTemplate = Assert.castUnchecked(schemaTemplate, RecordLayerSchemaTemplate.class);
@@ -632,19 +631,19 @@ public static Result normalizeAst(@Nonnull final SchemaTemplate schemaTemplate,
             final var compiledFunction = recordLayerRoutine.getCompilableSqlFunctionSupplier().get();
             astNormalizer.queryHasherContextBuilder.getLiteralsBuilder().importLiterals(compiledFunction.getAuxiliaryLiterals());
         }
-        return new Result(
+        return new NormalizationResult(
                 recordLayerSchemaTemplate.getName(),
-                QueryCacheKey.of(astNormalizer.getCanonicalSqlString(), astNormalizer.getHash(),
-                        recordLayerSchemaTemplate.getVersion(), readableIndexes, userVersion,
-                        recordLayerSchemaTemplate.getTransactionBoundMetadataAsString()),
+                QueryCacheKey.of(astNormalizer.getCanonicalSqlString(), plannerConfiguration,
+                        recordLayerSchemaTemplate.getTransactionBoundMetadataAsString(), astNormalizer.getHash(),
+                        recordLayerSchemaTemplate.getVersion(), userVersion),
                 astNormalizer.getQueryExecutionParameters(),
                 context,
                 astNormalizer.getQueryCachingFlags(),
                 astNormalizer.getQueryOptions(),
                 query);
     }
 
-    public static final class Result {
+    public static final class NormalizationResult {
 
         /**
          * A set of flags that determine how the query should interact with the plan cache.
@@ -687,13 +686,13 @@ public enum QueryCachingFlags {
         @Nonnull
         private final String query;
 
-        public Result(@Nonnull final String schemaTemplateName,
-                      @Nonnull final QueryCacheKey queryCacheKey,
-                      @Nonnull final QueryExecutionContext queryExecutionContext,
-                      @Nonnull final ParseTree parseTree,
-                      @Nonnull final Set<QueryCachingFlags> queryCachingFlags,
-                      @Nonnull final Options queryOptions,
-                      @Nonnull final String query) {
+        public NormalizationResult(@Nonnull final String schemaTemplateName,
+                                   @Nonnull final QueryCacheKey queryCacheKey,
+                                   @Nonnull final QueryExecutionContext queryExecutionContext,
+                                   @Nonnull final ParseTree parseTree,
+                                   @Nonnull final Set<QueryCachingFlags> queryCachingFlags,
+                                   @Nonnull final Options queryOptions,
+                                   @Nonnull final String query) {
             this.schemaTemplateName = schemaTemplateName;
             this.queryCacheKey = queryCacheKey;
             this.queryExecutionContext = queryExecutionContext;
@@ -703,6 +702,7 @@ public Result(@Nonnull final String schemaTemplateName,
             this.query = query;
         }
 
+        @Nonnull
         public String getSchemaTemplateName() {
             return schemaTemplateName;
         }