Preserve IntermingleTables flag in RecordLayerSchemaTemplate.toBuilder (#3482)

This preserves `IntermingleTables` when turning a
`RecordLayerSchemaTemplate` to its `Builder`.

It resolves #3483.

Author: hatyo

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

@@ -39,6 +39,7 @@
 import com.apple.foundationdb.relational.recordlayer.metadata.serde.RecordMetadataSerializer;
 import com.apple.foundationdb.relational.util.Assert;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Supplier;
 import com.google.common.base.Suppliers;
 import com.google.common.collect.ImmutableList;
@@ -95,18 +96,22 @@ public final class RecordLayerSchemaTemplate implements SchemaTemplate {
     @Nonnull
     private final Supplier<String> transactionBoundMetadataSupplier;
 
+    private final boolean intermingleTables;
+
     private RecordLayerSchemaTemplate(@Nonnull final String name,
                                       @Nonnull final Set<RecordLayerTable> tables,
                                       @Nonnull final Set<RecordLayerInvokedRoutine> invokedRoutines,
                                       int version,
                                       boolean enableLongRows,
-                                      boolean storeRowVersions) {
+                                      boolean storeRowVersions,
+                                      boolean intermingleTables) {
         this.name = name;
         this.tables = ImmutableSet.copyOf(tables);
         this.invokedRoutines = ImmutableSet.copyOf(invokedRoutines);
         this.version = version;
         this.enableLongRows = enableLongRows;
         this.storeRowVersions = storeRowVersions;
+        this.intermingleTables = intermingleTables;
         this.metaDataSupplier = Suppliers.memoize(this::buildRecordMetadata);
         this.tableIndexMappingSupplier = Suppliers.memoize(this::computeTableIndexMapping);
         this.indexesSupplier = Suppliers.memoize(this::computeIndexes);
@@ -120,13 +125,15 @@ private RecordLayerSchemaTemplate(@Nonnull final String name,
                                       int version,
                                       boolean enableLongRows,
                                       boolean storeRowVersions,
+                                      boolean intermingleTables,
                                       @Nonnull final RecordMetaData cachedMetadata) {
         this.name = name;
         this.version = version;
         this.tables = ImmutableSet.copyOf(tables);
         this.invokedRoutines = ImmutableSet.copyOf(invokedRoutines);
         this.enableLongRows = enableLongRows;
         this.storeRowVersions = storeRowVersions;
+        this.intermingleTables = intermingleTables;
         this.metaDataSupplier = Suppliers.memoize(() -> cachedMetadata);
         this.tableIndexMappingSupplier = Suppliers.memoize(this::computeTableIndexMapping);
         this.indexesSupplier = Suppliers.memoize(this::computeIndexes);
@@ -155,6 +162,11 @@ public boolean isStoreRowVersions() {
         return storeRowVersions;
     }
 
+    @VisibleForTesting
+    public boolean isIntermingleTables() {
+        return intermingleTables;
+    }
+
     @Nonnull
     @Override
     public Set<RecordLayerTable> getTables() {
@@ -560,10 +572,10 @@ public RecordLayerSchemaTemplate build() {
 
             if (cachedMetadata != null) {
                 return new RecordLayerSchemaTemplate(name, new LinkedHashSet<>(tables.values()),
-                        new LinkedHashSet<>(invokedRoutines.values()), version, enableLongRows, storeRowVersions, cachedMetadata);
+                        new LinkedHashSet<>(invokedRoutines.values()), version, enableLongRows, storeRowVersions, intermingleTables, cachedMetadata);
             } else {
                 return new RecordLayerSchemaTemplate(name, new LinkedHashSet<>(tables.values()),
-                        new LinkedHashSet<>(invokedRoutines.values()), version, enableLongRows, storeRowVersions);
+                        new LinkedHashSet<>(invokedRoutines.values()), version, enableLongRows, storeRowVersions, intermingleTables);
             }
         }
 
@@ -681,6 +693,7 @@ public Builder toBuilder() {
                 .setName(name)
                 .setVersion(version)
                 .setEnableLongRows(enableLongRows)
+                .setIntermingleTables(intermingleTables)
                 .addTables(getTables())
                 .addInvokedRoutines(getInvokedRoutines());
     }

fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/metadata/SchemaTemplateSerDeTests.java

@@ -433,6 +433,57 @@ public void onlyQueriedSqlFunctionsAreCompiled() throws RelationalException {
         Assertions.assertTrue(peekingDeserializer.hasOneCompilationRequestFor("SqlFunction3"));
     }
 
+    @ParameterizedTest(name = "schema template builder preserving intermingledTables flag set to {0}")
+    @ValueSource(booleans = {true, false})
+    public void schemaTemplateToBuilderPreservesIntermingledTablesFlag(boolean intermingleTables) {
+        var sampleRecordSchemaTemplate = RecordLayerSchemaTemplate.newBuilder()
+                .setName("TestSchemaTemplate")
+                .setVersion(42)
+                .addAuxiliaryType(DataType.StructType.from(
+                        "Subtype",
+                        List.of(DataType.StructType.Field.from("field1", DataType.Primitives.INTEGER.type(), 0)),
+                        true))
+                .setIntermingleTables(intermingleTables)
+                .addTable(
+                        RecordLayerTable.newBuilder(intermingleTables)
+                                .setName("T1")
+                                .addColumn(RecordLayerColumn.newBuilder()
+                                        .setName("COL1")
+                                        .setDataType(
+                                                DataType.StructType.from(
+                                                        "Subtype",
+                                                        List.of(DataType.StructType.Field.from("field1", DataType.Primitives.INTEGER.type(), 1)),
+                                                        true))
+                                        .build())
+                                .build())
+                .build();
+
+        // make sure the intermingleTables flag is preserved after creating the invoked routine in the builder
+        // as well as in the built schema template.
+        var builder = sampleRecordSchemaTemplate.toBuilder();
+        Assertions.assertEquals(intermingleTables, builder.isIntermingleTables());
+        sampleRecordSchemaTemplate = builder.build();
+        Assertions.assertEquals(intermingleTables, sampleRecordSchemaTemplate.isIntermingleTables());
+
+        // add temporary invoked routine.
+        builder.addInvokedRoutine(RecordLayerInvokedRoutine.newBuilder()
+                .setName("SqlFunction1")
+                .setDescription("CREATE FUNCTION SqlFunction1(IN Q BIGINT) AS SELECT * FROM T1 WHERE col1 < Q")
+                .setTemporary(true)
+                .withCompilableRoutine(CompiledFunctionStub::new)
+                .build());
+
+        // build the schema template
+        final var newSchemaTemplate = builder.build();
+
+        // make sure the intermingleTables flag is preserved after creating the invoked routine in the builder
+        // as well as the built schema template.
+        builder = newSchemaTemplate.toBuilder();
+        Assertions.assertEquals(intermingleTables, builder.isIntermingleTables());
+        sampleRecordSchemaTemplate = builder.build();
+        Assertions.assertEquals(intermingleTables, sampleRecordSchemaTemplate.isIntermingleTables());
+    }
+
     @Nonnull
     private static RecordMetadataDeserializerWithPeekingFunctionSupplier recMetadataSampleWithFunctions(@Nonnull final String... functions) {
         final var schemaTemplateBuilder = RecordLayerSchemaTemplate.newBuilder()