Store queries in schema template and warmup plan cache on startup

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/RecordMetaData.java

@@ -86,7 +86,9 @@
     private final Map<String, UserDefinedFunction> userDefinedFunctionMap;
     @Nonnull
     private final Map<String, View> viewMap;
     @Nonnull
+    private final Map<String, String> storedQueries;
+    @Nonnull
     private final Map<String, Index> indexes;
     @Nonnull
     private final Map<String, Index> universalIndexes;
@@ -118,6 +120,7 @@
                 Collections.unmodifiableList(orig.formerIndexes),
                 Collections.unmodifiableMap(orig.userDefinedFunctionMap),
                 Collections.unmodifiableMap(orig.viewMap),
+                Collections.unmodifiableMap(orig.storedQueries),
                 orig.splitLongRecords,
                 orig.storeRecordVersions,
                 orig.version,
@@ -139,6 +142,7 @@
                              @Nonnull List<FormerIndex> formerIndexes,
                              @Nonnull Map<String, UserDefinedFunction> userDefinedFunctionMap,
                              @Nonnull Map<String, View> viewMap,
+                             @Nonnull Map<String, String> storedQueries,
                              boolean splitLongRecords,
                              boolean storeRecordVersions,
                              int version,
@@ -157,6 +161,7 @@
         this.formerIndexes = formerIndexes;
         this.userDefinedFunctionMap = userDefinedFunctionMap;
         this.viewMap = viewMap;
+        this.storedQueries = storedQueries;
         this.splitLongRecords = splitLongRecords;
         this.storeRecordVersions = storeRecordVersions;
         this.version = version;
@@ -704,6 +709,7 @@
 
         builder.addAllUserDefinedFunctions(userDefinedFunctionMap.values().stream().map(UserDefinedFunction::toProto).collect(Collectors.toList()));
         builder.addAllViews(viewMap.values().stream().map(View::toProto).collect(Collectors.toList()));
+        builder.putAllStoredQueries(storedQueries);
         builder.setSplitLongRecords(splitLongRecords);
         builder.setStoreRecordVersions(storeRecordVersions);
         builder.setVersion(version);
@@ -728,6 +734,11 @@
         return viewMap;
     }
 
+    @Nonnull
+    public Map<String, String> getStoredQueries() {
+        return storedQueries;
+    }
+
     @Nonnull
     public Type.Record getPlannerType(@Nonnull String recordTypeName) {
         final RecordType recordType = getRecordType(recordTypeName);

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/RecordMetaDataBuilder.java

@@ -115,7 +115,9 @@
     private final Map<String, UserDefinedFunction> userDefinedFunctionMap;
     @Nonnull
     private final Map<String, View> viewMap;
     @Nonnull
+    private final Map<String, String> storedQueries;
+    @Nonnull
     private final Map<String, Index> indexes;
     @Nonnull
     private final Map<String, Index> universalIndexes;
@@ -152,6 +154,7 @@
         syntheticRecordTypes = new HashMap<>();
         userDefinedFunctionMap = new HashMap<>();
         viewMap = new HashMap<>();
+        storedQueries = new HashMap<>();
     }
 
     private void processSchemaOptions(boolean processExtensionOptions) {
@@ -238,6 +241,7 @@
             final View view = View.fromProto(viewProto);
             viewMap.put(view.getName(), view);
         }
+        storedQueries.putAll(metaDataProto.getStoredQueriesMap());
         if (metaDataProto.hasSplitLongRecords()) {
             splitLongRecords = metaDataProto.getSplitLongRecords();
         }
@@ -1215,6 +1219,15 @@
         viewMap.put(view.getName(), view);
     }
 
+    @Nonnull
+    public Map<String, String> getStoredQueries() {
+        return storedQueries;
+    }
+
+    public void addStoredQuery(@Nonnull String name, @Nonnull String storedQuery) {
+        storedQueries.put(name, storedQuery);
+    }
+
     public boolean isSplitLongRecords() {
         return splitLongRecords;
     }
@@ -1456,7 +1469,7 @@
         Map<Object, SyntheticRecordType<?>> recordTypeKeyToSyntheticRecordTypeMap = Maps.newHashMapWithExpectedSize(syntheticRecordTypes.size());
         RecordMetaData metaData = new RecordMetaData(recordsDescriptor, getUnionDescriptor(), unionFields,
                 builtRecordTypes, builtSyntheticRecordTypes, recordTypeKeyToSyntheticRecordTypeMap,
-                indexes, universalIndexes, formerIndexes, userDefinedFunctionMap, viewMap,
+                indexes, universalIndexes, formerIndexes, userDefinedFunctionMap, viewMap, storedQueries,
                 splitLongRecords, storeRecordVersions, version, subspaceKeyCounter, usesSubspaceKeyCounter, recordCountKey, localFileDescriptor != null);
         for (RecordTypeBuilder recordTypeBuilder : recordTypes.values()) {
             KeyExpression primaryKey = recordTypeBuilder.getPrimaryKey();

fdb-record-layer-core/src/main/proto/record_metadata.proto

@@ -210,6 +210,7 @@ message MetaData {
   repeated UnnestedRecordType unnested_record_types = 13;
   repeated PUserDefinedFunction user_defined_functions = 14;
   repeated PView views = 15;
+  map<string, string> stored_queries = 16;
   extensions 1000 to 2000;
 }
 

fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/provider/foundationdb/MetaDataProtoEditorUnitTest.java

@@ -587,6 +587,7 @@ void validateMetaDataCoverage() {
         assertEquals(Set.of(
                         "split_long_records", "version", "former_indexes", "record_count_key",
                         "store_record_versions", "dependencies", "subspace_key_counter", "uses_subspace_key_counter",
+                        "stored_queries",
                         // the below reference record types
                         "records", "indexes", "record_types", "joined_record_types", "unnested_record_types",
                         "user_defined_functions", "views"),

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

@@ -26,7 +26,8 @@
 
 import javax.annotation.Nonnull;
 import java.util.BitSet;
 import java.util.Collection;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 
@@ -130,6 +131,14 @@
     @Nonnull
     Collection<? extends InvokedRoutine> getTemporaryInvokedRoutines() throws RelationalException;
 
+    /**
+     * Returns the stored queries defined in this schema template.
+     *
+     * @return A map of stored query names to their SQL strings.
+     */
+    @Nonnull
+    Map<String, String> getStoredQueries();
+
     @Nonnull
     String getTransactionBoundMetadataAsString() throws RelationalException;
 

fdb-relational-core/src/main/antlr/RelationalParser.g4

@@ -91,7 +91,7 @@ utilityStatement
 
 templateClause
     :
-        CREATE ( structDefinition | tableDefinition | enumDefinition | indexDefinition | sqlInvokedFunction | viewDefinition )
+        CREATE ( structDefinition | tableDefinition | enumDefinition | indexDefinition | sqlInvokedFunction | viewDefinition | queryDefinition )
     ;
 
 createStatement
@@ -246,6 +246,10 @@ viewDefinition
     : VIEW viewName=fullId AS viewQuery=query
     ;
 
+queryDefinition
+    : QUERY queryName=uid AS storedQuery=query
+    ;
+
 tempSqlInvokedFunction
     : functionSpecification ON COMMIT DROP FUNCTION routineBody
     ;

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

@@ -28,7 +28,8 @@
 import com.apple.foundationdb.relational.api.StorageCluster;
 import com.apple.foundationdb.relational.api.catalog.StoreCatalog;
 import com.apple.foundationdb.relational.api.metrics.NoOpMetricRegistry;
 import com.apple.foundationdb.relational.recordlayer.ddl.RecordLayerMetadataOperationsFactory;
+import com.apple.foundationdb.relational.recordlayer.query.OfflineStoredQueriesProcessor;
 import com.apple.foundationdb.relational.recordlayer.query.cache.RelationalPlanCache;
 
 import com.codahale.metrics.MetricRegistry;
@@ -52,8 +53,17 @@
 
         MetricRegistry mEngine = convertToRecordLayerEngine(metricsEngine);
 
-        List<StorageCluster> clusters = databases.stream().map(db ->
-                new RecordLayerStorageCluster(new DirectFdbConnection(db, mEngine), baseKeySpace, cfg, schemaCatalog, planCache, ddlFactory)).collect(Collectors.toList());
+        List<FdbConnection> connections = databases.stream()
+                .map(db -> new DirectFdbConnection(db, mEngine))
+                .collect(Collectors.toList());
+
+        List<StorageCluster> clusters = connections.stream()
+                .map(conn -> new RecordLayerStorageCluster(conn, baseKeySpace, cfg, schemaCatalog, planCache, ddlFactory))
+                .collect(Collectors.toList());
+
+        if (planCache != null && !connections.isEmpty()) {
+            new OfflineStoredQueriesProcessor(planCache, schemaCatalog, connections.get(0), mEngine).run();
+        }
 
         return new EmbeddedRelationalEngine(clusters, mEngine);
     }

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

@@ -34,7 +34,9 @@
 
 import javax.annotation.Nonnull;
 import java.util.BitSet;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 
@@ -139,6 +141,12 @@
         throw new RelationalException("NoOpSchemaTemplate doesn't have temporary invoked routines!", ErrorCode.INVALID_PARAMETER);
     }
 
+    @Nonnull
+    @Override
+    public Map<String, String> getStoredQueries() {
+        return Collections.emptyMap();
+    }
+
     @Nonnull
     @Override
     public String getTransactionBoundMetadataAsString() throws RelationalException {

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

@@ -79,7 +79,10 @@
 
     @Nonnull
     private final Set<RecordLayerView> views;
 
+    @Nonnull
+    private final Map<String, String> storedQueries;
+
     private final int version;
 
     private final boolean enableLongRows;
@@ -107,6 +110,7 @@
                                       @Nonnull final Set<RecordLayerTable> tables,
                                       @Nonnull final Set<RecordLayerInvokedRoutine> invokedRoutines,
                                       @Nonnull final Set<RecordLayerView> views,
+                                      @Nonnull final Map<String, String> storedQueries,
                                       int version,
                                       boolean enableLongRows,
                                       boolean storeRowVersions,
@@ -115,6 +119,7 @@
         this.tables = ImmutableSet.copyOf(tables);
         this.invokedRoutines = ImmutableSet.copyOf(invokedRoutines);
         this.views = ImmutableSet.copyOf(views);
+        this.storedQueries = ImmutableMap.copyOf(storedQueries);
         this.version = version;
         this.enableLongRows = enableLongRows;
         this.storeRowVersions = storeRowVersions;
@@ -130,6 +135,7 @@
                                       @Nonnull final Set<RecordLayerTable> tables,
                                       @Nonnull final Set<RecordLayerInvokedRoutine> invokedRoutines,
                                       @Nonnull final Set<RecordLayerView> views,
+                                      @Nonnull final Map<String, String> storedQueries,
                                       int version,
                                       boolean enableLongRows,
                                       boolean storeRowVersions,
@@ -140,6 +146,7 @@
         this.tables = ImmutableSet.copyOf(tables);
         this.invokedRoutines = ImmutableSet.copyOf(invokedRoutines);
         this.views = ImmutableSet.copyOf(views);
+        this.storedQueries = ImmutableMap.copyOf(storedQueries);
         this.enableLongRows = enableLongRows;
         this.storeRowVersions = storeRowVersions;
         this.intermingleTables = intermingleTables;
@@ -338,6 +345,12 @@
         return views;
     }
 
+    @Nonnull
+    @Override
+    public Map<String, String> getStoredQueries() {
+        return storedQueries;
+    }
+
     @Nonnull
     @Override
     public Optional<? extends View> findViewByName(@Nonnull final String viewName) {
@@ -414,6 +427,9 @@
         @Nonnull
         private final Map<String, RecordLayerView> views;
 
+        @Nonnull
+        private final Map<String, String> storedQueries;
+
 
         private RecordMetaData cachedMetadata;
 
@@ -422,6 +438,7 @@
             auxiliaryTypes = new LinkedHashMap<>();
             invokedRoutines = new LinkedHashMap<>();
             views = new LinkedHashMap<>();
+            storedQueries = new LinkedHashMap<>();
             // enable long rows is TRUE by default
             enableLongRows = true;
         }
@@ -540,6 +557,18 @@
             return this;
         }
 
+        @Nonnull
+        public Builder addStoredQuery(@Nonnull final String name, @Nonnull final String storedQuery) {
+            storedQueries.put(name, storedQuery);
+            return this;
+        }
+
+        @Nonnull
+        public Builder addStoredQueries(@Nonnull final Map<String, String> storedQueries) {
+            this.storedQueries.putAll(storedQueries);
+            return this;
+        }
+
         /**
          * Adds an auxiliary type, an auxiliary type is a type that is merely created, so it can be referenced later on
          * in a table definition. Any {@link DataType.Named} data type can be added as an auxiliary type such as {@code enum}s
@@ -632,10 +661,10 @@
 
             if (cachedMetadata != null) {
                 return new RecordLayerSchemaTemplate(name, new LinkedHashSet<>(tables.values()),
-                        new LinkedHashSet<>(invokedRoutines.values()), new LinkedHashSet<>(views.values()), version, enableLongRows, storeRowVersions, intermingleTables, cachedMetadata);
+                        new LinkedHashSet<>(invokedRoutines.values()), new LinkedHashSet<>(views.values()), storedQueries, version, enableLongRows, storeRowVersions, intermingleTables, cachedMetadata);
             } else {
                 return new RecordLayerSchemaTemplate(name, new LinkedHashSet<>(tables.values()),
-                        new LinkedHashSet<>(invokedRoutines.values()), new LinkedHashSet<>(views.values()), version, enableLongRows, storeRowVersions, intermingleTables);
+                        new LinkedHashSet<>(invokedRoutines.values()), new LinkedHashSet<>(views.values()), storedQueries, version, enableLongRows, storeRowVersions, intermingleTables);
             }
         }
 
@@ -763,6 +792,7 @@
                 .setIntermingleTables(intermingleTables)
                 .addTables(getTables())
                 .addInvokedRoutines(getInvokedRoutines())
-                .addViews(getViews());
+                .addViews(getViews())
+                .addStoredQueries(getStoredQueries());
     }
 }

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/metadata/serde/RecordMetadataDeserializer.java

@@ -124,7 +124,8 @@
             for (final var view : recordMetaData.getViewMap().entrySet()) {
                 schemaTemplateBuilder.addView(generateViewBuilder(metadataProvider, view.getKey(), view.getValue().getDefinition()).build());
             }
         }
+        schemaTemplateBuilder.addStoredQueries(recordMetaData.getStoredQueries());
         schemaTemplateBuilder.setCachedMetadata(recordMetaData);
         return schemaTemplateBuilder;
     }

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/metadata/serde/RecordMetadataSerializer.java

@@ -106,10 +106,14 @@
 
     @Override
     public void visit(@Nonnull SchemaTemplate schemaTemplate) {
         Assert.thatUnchecked(schemaTemplate instanceof RecordLayerSchemaTemplate);
+        final var recLayerSchemaTemplate = (RecordLayerSchemaTemplate) schemaTemplate;
         getBuilder().setSplitLongRecords(schemaTemplate.isEnableLongRows());
         getBuilder().setStoreRecordVersions(schemaTemplate.isStoreRowVersions());
         getBuilder().setVersion(schemaTemplate.getVersion());
+        for (final var entry : recLayerSchemaTemplate.getStoredQueries().entrySet()) {
+            getBuilder().addStoredQuery(entry.getKey(), entry.getValue());
+        }
     }
 
     @Nonnull