diff --git a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/typing/Type.java b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/typing/Type.java index 24cc4491b6..19f8ce98bc 100644 --- a/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/typing/Type.java +++ b/fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/typing/Type.java @@ -2588,7 +2588,6 @@ private static List normalizeFields(@Nullable final List fields) { // If any field info is missing, the type that is about to be constructed comes from a constructing // code path. We should be able to just set these field names and indexes as we wish. // - Set fieldNamesSeen = Sets.newHashSet(); final ImmutableList.Builder resultFieldsBuilder = ImmutableList.builder(); for (int i = 0; i < fields.size(); i++) { final var field = fields.get(i); @@ -2612,9 +2611,6 @@ private static List normalizeFields(@Nullable final List fields) { Optional.of(fieldStorageName)); } - if (!(fieldNamesSeen.add(fieldToBeAdded.getFieldName()))) { - throw new RecordCoreException("fields contain duplicate field names"); - } resultFieldsBuilder.add(fieldToBeAdded); } diff --git a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/metadata/DataTypeUtils.java b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/metadata/DataTypeUtils.java index 7799db0db3..e28579564b 100644 --- a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/metadata/DataTypeUtils.java +++ b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/metadata/DataTypeUtils.java @@ -81,7 +81,7 @@ final var record = (Type.Record) type; case ENUM: final var asEnum = (Type.Enum) type; final var enumValues = asEnum.getEnumValues().stream().map(v -> DataType.EnumType.EnumValue.of(v.getName(), v.getNumber())).collect(Collectors.toList()); - return DataType.EnumType.from(asEnum.getName() == null ? ProtoUtils.uniqueName("") : asEnum.getName(), enumValues, asEnum.isNullable()); + return DataType.EnumType.from(asEnum.getName() == null ? ProtoUtils.uniqueName("id") : asEnum.getName(), enumValues, asEnum.isNullable()); default: Assert.failUnchecked(String.format(Locale.ROOT, "unexpected type %s", type)); return null; // make compiler happy. diff --git a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/Expressions.java b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/Expressions.java index 93c0d4604c..46aefcdd9d 100644 --- a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/Expressions.java +++ b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/Expressions.java @@ -29,6 +29,7 @@ import com.apple.foundationdb.record.query.plan.cascades.typing.Type; import com.apple.foundationdb.record.query.plan.cascades.values.FieldValue; import com.apple.foundationdb.record.query.plan.cascades.values.Value; +import com.apple.foundationdb.relational.api.metadata.DataType; import com.apple.foundationdb.relational.util.Assert; import com.google.common.base.Verify; import com.google.common.collect.ImmutableList; @@ -207,6 +208,43 @@ public List underlyingTypes() { return Streams.stream(underlying()).map(Value::getResultType).collect(ImmutableList.toImmutableList()); } + /** + * Returns a StructType representing the semantic types of all expressions with their field names. + * + *

This wraps the individual expression data types into a single StructType that is + * structurally equivalent to the planner's Type.Record output. The StructType includes: + *

    + *
  • Field names from the expressions (handles aliases, star expansion, etc.)
    • + *
  • Type structure from semantic analysis (preserves struct type names)
    • + *
+ * + *

This StructType can be used directly for result set metadata after enriching nested + * struct names from RecordMetaData descriptors. + * + *

Note: The StructType name is a generated UUID since this is a general-purpose method. + * Contexts that need a specific name (e.g., "QUERY_RESULT" for top-level queries) should + * wrap or recreate the StructType with an appropriate name. + * + * @return A StructType with field names and semantic types from expressions + */ + @Nonnull + public DataType.StructType getStructType() { + final ImmutableList.Builder fieldsBuilder = ImmutableList.builder(); + int index = 0; + for (final Expression expression : underlying) { + // Use expression name if available, otherwise generate a name + final String fieldName = expression.getName() + .map(Identifier::toString) + .orElse("_" + index); + fieldsBuilder.add(DataType.StructType.Field.from(fieldName, expression.getDataType(), index)); + index++; + } + // Use UUID-based name since this is a general-purpose method + // Top-level contexts (like query results) will override with "QUERY_RESULT" + final String generatedName = "id" + java.util.UUID.randomUUID().toString().replace("-", "_"); + return DataType.StructType.from(generatedName, fieldsBuilder.build(), true); + } + @Nonnull public Stream stream() { return underlying.stream(); diff --git a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/PlanGenerator.java b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/PlanGenerator.java index 7db30bce17..a4de4cce8b 100644 --- a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/PlanGenerator.java +++ b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/PlanGenerator.java @@ -34,6 +34,7 @@ import com.apple.foundationdb.record.query.plan.cascades.SemanticException; import com.apple.foundationdb.record.query.plan.cascades.StableSelectorCostModel; import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository; +import com.apple.foundationdb.record.query.plan.cascades.typing.Type; import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan; import com.apple.foundationdb.record.query.plan.serialization.DefaultPlanSerializationRegistry; import com.apple.foundationdb.record.util.ProtoUtils; @@ -42,10 +43,12 @@ import com.apple.foundationdb.relational.api.exceptions.ErrorCode; import com.apple.foundationdb.relational.api.exceptions.RelationalException; import com.apple.foundationdb.relational.api.exceptions.UncheckedRelationalException; +import com.apple.foundationdb.relational.api.metadata.DataType; import com.apple.foundationdb.relational.api.metrics.RelationalMetric; import com.apple.foundationdb.relational.continuation.CompiledStatement; import com.apple.foundationdb.relational.continuation.TypedQueryArgument; import com.apple.foundationdb.relational.recordlayer.ContinuationImpl; +import com.apple.foundationdb.relational.recordlayer.metadata.DataTypeUtils; import com.apple.foundationdb.relational.recordlayer.metadata.RecordLayerSchemaTemplate; import com.apple.foundationdb.relational.recordlayer.query.cache.PhysicalPlanEquivalence; import com.apple.foundationdb.relational.recordlayer.query.cache.RelationalPlanCache; @@ -54,6 +57,7 @@ import com.apple.foundationdb.relational.util.Assert; import com.apple.foundationdb.relational.util.RelationalLoggingUtil; import com.google.common.base.VerifyException; +import com.google.common.collect.ImmutableList; import com.google.common.collect.Maps; import com.google.protobuf.InvalidProtocolBufferException; import org.apache.logging.log4j.LogManager; @@ -62,6 +66,7 @@ import javax.annotation.Nonnull; import java.sql.SQLException; import java.util.Arrays; +import java.util.List; import java.util.Objects; import java.util.Optional; import java.util.Set; @@ -326,12 +331,35 @@ private QueryPlan.PhysicalQueryPlan generatePhysicalPlanForExecuteContinuation(@ planGenerationContext.setContinuation(continuationProto); final var continuationPlanConstraint = QueryPlanConstraint.fromProto(serializationContext, compiledStatement.getPlanConstraint()); + + final DataType.StructType semanticStructType; + if (compiledStatement.hasQueryMetadata()) { + semanticStructType = Assert.castUnchecked(DataTypeUtils.toRelationalType(Type.fromTypeProto(serializationContext, compiledStatement.getQueryMetadata())), + DataType.StructType.class); + } else { + final Type resultType = recordQueryPlan.getResultType().getInnerType(); + if (resultType instanceof Type.Record) { + final Type.Record recordType = (Type.Record)resultType; + final List fields = recordType.getFields().stream() + .map(field -> DataType.StructType.Field.from( + field.getFieldName(), + DataTypeUtils.toRelationalType(field.getFieldType()), + field.getFieldIndex())) + .collect(java.util.stream.Collectors.toList()); + semanticStructType = DataType.StructType.from("QUERY_RESULT", fields, true); + } else { + // Fallback for non-record types (shouldn't happen for SELECT results) + semanticStructType = DataType.StructType.from("QUERY_RESULT", ImmutableList.of(), true); + } + } + return new QueryPlan.ContinuedPhysicalQueryPlan(recordQueryPlan, typeRepository, continuationPlanConstraint, planGenerationContext, "EXECUTE CONTINUATION " + ast.getQueryCacheKey().getCanonicalQueryString(), currentPlanHashMode, - serializedPlanHashMode); + serializedPlanHashMode, + semanticStructType); } private void resetTimer() { diff --git a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlan.java b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlan.java index dd81fb418c..cd6098ac84 100644 --- a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlan.java +++ b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlan.java @@ -128,6 +128,13 @@ public static class PhysicalQueryPlan extends QueryPlan { @Nonnull private final QueryExecutionContext queryExecutionContext; + /** + * Semantic type structure captured during semantic analysis. + * Complete StructType with field names and nested struct type names preserved. + */ + @Nonnull + private final DataType.StructType semanticStructType; + public PhysicalQueryPlan(@Nonnull final RecordQueryPlan recordQueryPlan, @Nullable final StatsMaps plannerStatsMaps, @Nonnull final TypeRepository typeRepository, @@ -135,7 +142,8 @@ public PhysicalQueryPlan(@Nonnull final RecordQueryPlan recordQueryPlan, @Nonnull final QueryPlanConstraint continuationConstraint, @Nonnull final QueryExecutionContext queryExecutionContext, @Nonnull final String query, - @Nonnull final PlanHashMode currentPlanHashMode) { + @Nonnull final PlanHashMode currentPlanHashMode, + @Nonnull final DataType.StructType semanticStructType) { super(query); this.recordQueryPlan = recordQueryPlan; this.plannerStatsMaps = plannerStatsMaps; @@ -145,6 +153,7 @@ public PhysicalQueryPlan(@Nonnull final RecordQueryPlan recordQueryPlan, this.queryExecutionContext = queryExecutionContext; this.currentPlanHashMode = currentPlanHashMode; this.planHashSupplier = Suppliers.memoize(() -> recordQueryPlan.planHash(currentPlanHashMode)); + this.semanticStructType = semanticStructType; } @Nonnull @@ -192,7 +201,8 @@ public PhysicalQueryPlan withExecutionContext(@Nonnull final QueryExecutionConte return this; } return new PhysicalQueryPlan(recordQueryPlan, plannerStatsMaps, typeRepository, constraint, - continuationConstraint, queryExecutionContext, query, queryExecutionContext.getPlanHashMode()); + continuationConstraint, queryExecutionContext, query, queryExecutionContext.getPlanHashMode(), + semanticStructType); } @Nonnull @@ -404,10 +414,10 @@ private RelationalResultSet executePhysicalPlan(@Nonnull final RecordLayerSchema parsedContinuation.getExecutionState(), executeProperties)); final var currentPlanHashMode = OptionsUtils.getCurrentPlanHashMode(options); - final var dataType = (DataType.StructType) DataTypeUtils.toRelationalType(type); + return executionContext.metricCollector.clock(RelationalMetric.RelationalEvent.CREATE_RESULT_SET_ITERATOR, () -> { final ResumableIterator iterator = RecordLayerIterator.create(cursor, messageFDBQueriedRecord -> new MessageTuple(messageFDBQueriedRecord.getMessage())); - return new RecordLayerResultSet(RelationalStructMetaData.of(dataType), iterator, connection, + return new RecordLayerResultSet(RelationalStructMetaData.of(semanticStructType), iterator, connection, (continuation, reason) -> enrichContinuation(continuation, currentPlanHashMode, reason)); }); @@ -450,8 +460,8 @@ private Continuation enrichContinuation(@Nonnull final Continuation continuation i++; } - compiledStatementBuilder.setPlanConstraint(getContinuationConstraint().toProto(serializationContext)); - + compiledStatementBuilder.setPlanConstraint(getContinuationConstraint().toProto(serializationContext)) + .setQueryMetadata(DataTypeUtils.toRecordLayerType(semanticStructType).toTypeProto(serializationContext)); continuationBuilder.withCompiledStatement(compiledStatementBuilder.build()); } return continuationBuilder.build(); @@ -476,9 +486,10 @@ public ContinuedPhysicalQueryPlan(@Nonnull final RecordQueryPlan recordQueryPlan @Nonnull final QueryExecutionContext queryExecutionParameters, @Nonnull final String query, @Nonnull final PlanHashMode currentPlanHashMode, - @Nonnull final PlanHashMode serializedPlanHashMode) { + @Nonnull final PlanHashMode serializedPlanHashMode, + @Nonnull final DataType.StructType semanticStructType) { super(recordQueryPlan, null, typeRepository, QueryPlanConstraint.noConstraint(), - continuationConstraint, queryExecutionParameters, query, currentPlanHashMode); + continuationConstraint, queryExecutionParameters, query, currentPlanHashMode, semanticStructType); this.serializedPlanHashMode = serializedPlanHashMode; this.serializedPlanHashSupplier = Suppliers.memoize(() -> recordQueryPlan.planHash(serializedPlanHashMode)); } @@ -488,15 +499,29 @@ public PlanHashMode getSerializedPlanHashMode() { return serializedPlanHashMode; } - @SuppressWarnings("PMD.CompareObjectsWithEquals") + /** + * Returns a plan with updated execution context. + * + *

Note: This method is never called in production because ContinuedPhysicalQueryPlan instances + * are not cached - each EXECUTE CONTINUATION deserializes the plan fresh from the continuation blob. + * However, we must override to satisfy the Plan interface contract. + * + *

TODO: Refactor the class hierarchy to eliminate this dead code. Potential approaches: + *

    + *
  • Collapse ContinuedPhysicalQueryPlan into PhysicalQueryPlan with a flag
    • + *
  • Use composition instead of inheritance
    • + *
  • Make Plan.withExecutionContext() optional with default implementation
    • + *
+ * + * @param queryExecutionContext The new execution context (ignored - never called) + * @return This instance (since continuation plans are never cached) + */ @Override @Nonnull public PhysicalQueryPlan withExecutionContext(@Nonnull final QueryExecutionContext queryExecutionContext) { - if (queryExecutionContext == this.getQueryExecutionContext()) { - return this; - } - return new ContinuedPhysicalQueryPlan(getRecordQueryPlan(), getTypeRepository(), getContinuationConstraint(), - queryExecutionContext, query, queryExecutionContext.getPlanHashMode(), getSerializedPlanHashMode()); + // This method is never called in production - continuation plans bypass the cache. + // Return this to avoid maintaining dead code. + return this; } @Override @@ -549,18 +574,27 @@ public static class LogicalQueryPlan extends QueryPlan { @Nonnull private final String query; + /** + * Semantic type structure captured during semantic analysis. + * Preserves struct type names - will be merged with planner field names after planning. + */ + @Nonnull + private final DataType.StructType semanticStructType; + @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Nonnull private Optional optimizedPlan; private LogicalQueryPlan(@Nonnull final RelationalExpression relationalExpression, @Nonnull final MutablePlanGenerationContext context, - @Nonnull final String query) { + @Nonnull final String query, + @Nonnull final DataType.StructType semanticStructType) { super(query); this.relationalExpression = relationalExpression; this.context = context; this.optimizedPlan = Optional.empty(); this.query = query; + this.semanticStructType = semanticStructType; } @Override @@ -609,7 +643,8 @@ public PhysicalQueryPlan optimize(@Nonnull CascadesPlanner planner, @Nonnull Pla optimizedPlan = Optional.of( new PhysicalQueryPlan(minimizedPlan, statsMaps, builder.build(), - constraint, continuationConstraint, context, query, currentPlanHashMode)); + constraint, continuationConstraint, context, query, currentPlanHashMode, + semanticStructType)); return optimizedPlan.get(); }); } @@ -657,8 +692,9 @@ public MutablePlanGenerationContext getGenerationContext() { @Nonnull public static LogicalQueryPlan of(@Nonnull final RelationalExpression relationalExpression, @Nonnull final MutablePlanGenerationContext context, - @Nonnull final String query) { - return new LogicalQueryPlan(relationalExpression, context, query); + @Nonnull final String query, + @Nonnull final DataType.StructType semanticStructType) { + return new LogicalQueryPlan(relationalExpression, context, query, semanticStructType); } @Nonnull diff --git a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/visitors/QueryVisitor.java b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/visitors/QueryVisitor.java index 2656aca97c..a505bb876f 100644 --- a/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/visitors/QueryVisitor.java +++ b/fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/visitors/QueryVisitor.java @@ -83,14 +83,20 @@ public static QueryVisitor of(@Nonnull BaseVisitor baseVisitor) { @Override public QueryPlan.LogicalQueryPlan visitSelectStatement(@Nonnull RelationalParser.SelectStatementContext ctx) { final var logicalOperator = parseChild(ctx); - return QueryPlan.LogicalQueryPlan.of(logicalOperator.getQuantifier().getRangesOver().get(), getDelegate().getPlanGenerationContext(), "TODO"); + // Capture semantic type structure as StructType with field names + final var semanticStructType = logicalOperator.getOutput().getStructType(); + return QueryPlan.LogicalQueryPlan.of(logicalOperator.getQuantifier().getRangesOver().get(), + getDelegate().getPlanGenerationContext(), getDelegate().getPlanGenerationContext().getQuery(), semanticStructType); } @Nonnull @Override public QueryPlan.LogicalQueryPlan visitDmlStatement(@Nonnull RelationalParser.DmlStatementContext ctx) { final var logicalOperator = parseChild(ctx); - return QueryPlan.LogicalQueryPlan.of(logicalOperator.getQuantifier().getRangesOver().get(), getDelegate().getPlanGenerationContext(), "TODO"); + // Capture semantic type structure as StructType with field names + final var semanticStructType = logicalOperator.getOutput().getStructType(); + return QueryPlan.LogicalQueryPlan.of(logicalOperator.getQuantifier().getRangesOver().get(), + getDelegate().getPlanGenerationContext(), getDelegate().getPlanGenerationContext().getQuery(), semanticStructType); } @Nonnull @@ -564,7 +570,10 @@ public Object visitExecuteContinuationStatement(@Nonnull RelationalParser.Execut public QueryPlan.LogicalQueryPlan visitFullDescribeStatement(@Nonnull RelationalParser.FullDescribeStatementContext ctx) { getDelegate().getPlanGenerationContext().setForExplain(ctx.EXPLAIN() != null); final var logicalOperator = Assert.castUnchecked(ctx.describeObjectClause().accept(this), LogicalOperator.class); - return QueryPlan.LogicalQueryPlan.of(logicalOperator.getQuantifier().getRangesOver().get(), getDelegate().getPlanGenerationContext(), "TODO"); + // Capture semantic type structure as StructType with field names + final var semanticStructType = logicalOperator.getOutput().getStructType(); + return QueryPlan.LogicalQueryPlan.of(logicalOperator.getQuantifier().getRangesOver().get(), + getDelegate().getPlanGenerationContext(), getDelegate().getPlanGenerationContext().getQuery(), semanticStructType); } @Nonnull diff --git a/fdb-relational-core/src/main/proto/continuation.proto b/fdb-relational-core/src/main/proto/continuation.proto index 4842d96288..a52b76776b 100644 --- a/fdb-relational-core/src/main/proto/continuation.proto +++ b/fdb-relational-core/src/main/proto/continuation.proto @@ -88,4 +88,6 @@ message CompiledStatement { repeated TypedQueryArgument arguments = 4; // query plan constraints optional com.apple.foundationdb.record.planprotos.PQueryPlanConstraint plan_constraint = 5; + // query metadata + optional com.apple.foundationdb.record.planprotos.PType queryMetadata = 6; } diff --git a/fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/StructDataMetadataTest.java b/fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/StructDataMetadataTest.java index 01f74d76ff..cd55ce6993 100644 --- a/fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/StructDataMetadataTest.java +++ b/fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/StructDataMetadataTest.java @@ -20,21 +20,27 @@ package com.apple.foundationdb.relational.recordlayer; +import com.apple.foundationdb.relational.api.Continuation; import com.apple.foundationdb.relational.api.EmbeddedRelationalArray; import com.apple.foundationdb.relational.api.EmbeddedRelationalStruct; import com.apple.foundationdb.relational.api.KeySet; import com.apple.foundationdb.relational.api.Options; +import com.apple.foundationdb.relational.api.RelationalArray; import com.apple.foundationdb.relational.api.RelationalResultSet; import com.apple.foundationdb.relational.api.RelationalStruct; import com.apple.foundationdb.relational.utils.SimpleDatabaseRule; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Order; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.function.ThrowingConsumer; import java.nio.charset.StandardCharsets; import java.sql.Array; +import java.sql.PreparedStatement; +import java.sql.ResultSet; import java.sql.SQLException; import java.util.Set; @@ -53,7 +59,13 @@ public class StructDataMetadataTest { " CREATE TYPE AS STRUCT struct_2 (c bigint, d struct_1) " + " CREATE TABLE nt (t_name string, st1 struct_2, PRIMARY KEY(t_name))" + " CREATE TYPE AS STRUCT struct_3 (c bytes, d boolean) " + - " CREATE TABLE at (a_name string, st2 struct_3 ARRAY, PRIMARY KEY(a_name))"; + " CREATE TABLE at (a_name string, st2 struct_3 ARRAY, PRIMARY KEY(a_name))" + + " CREATE TYPE AS STRUCT n1(a bigint, b string) " + + " CREATE TYPE AS STRUCT n2(a bigint, b string) " + + " CREATE TYPE AS STRUCT m(x n1, y n2) " + + " CREATE TABLE t3(id bigint, m m, PRIMARY KEY(id)) " + + " CREATE TABLE t4(id bigint, n1 n1, n2 n2, PRIMARY KEY(id)) "; + /* message at { @@ -82,6 +94,11 @@ void setUp() throws SQLException { .addStruct("ST1", EmbeddedRelationalStruct.newBuilder().addString("A", "Hello").build()) .build(); statement.executeInsert("T", m); + m = EmbeddedRelationalStruct.newBuilder() + .addString("NAME", "test_record_2") + .addStruct("ST1", EmbeddedRelationalStruct.newBuilder().addString("A", "World").build()) + .build(); + statement.executeInsert("T", m); m = EmbeddedRelationalStruct.newBuilder() .addString("T_NAME", "nt_record") @@ -94,7 +111,18 @@ void setUp() throws SQLException { .build(); statement.executeInsert("NT", m); - final var atBuilder = EmbeddedRelationalStruct.newBuilder(); + m = EmbeddedRelationalStruct.newBuilder() + .addString("T_NAME", "nt_record2") + .addStruct("ST1", EmbeddedRelationalStruct.newBuilder() + .addLong("C", 5678L) + .addStruct("D", EmbeddedRelationalStruct.newBuilder() + .addString("A", "Ciao") + .build()) + .build()) + .build(); + statement.executeInsert("NT", m); + + var atBuilder = EmbeddedRelationalStruct.newBuilder(); m = atBuilder.addString("A_NAME", "a_test_rec") .addArray("ST2", EmbeddedRelationalArray.newBuilder() .addStruct(EmbeddedRelationalStruct.newBuilder() @@ -108,6 +136,50 @@ void setUp() throws SQLException { .build()) .build(); statement.executeInsert("AT", m); + + atBuilder = EmbeddedRelationalStruct.newBuilder(); + m = atBuilder.addString("A_NAME", "another_test_rec") + .addArray("ST2", EmbeddedRelationalArray.newBuilder() + .addStruct(EmbeddedRelationalStruct.newBuilder() + .addBytes("C", "今日は".getBytes(StandardCharsets.UTF_8)) + .addBoolean("D", true) + .build()) + .addStruct(EmbeddedRelationalStruct.newBuilder() + .addBytes("C", "مرحبًا".getBytes(StandardCharsets.UTF_8)) + .addBoolean("D", false) + .build()) + .build()) + .build(); + statement.executeInsert("AT", m); + + RelationalStruct t3 = EmbeddedRelationalStruct.newBuilder() + .addLong("ID", 1L) + .addStruct("M", EmbeddedRelationalStruct.newBuilder() + .addStruct("X", EmbeddedRelationalStruct.newBuilder() + .addLong("A", 100L) + .addString("B", "blah") + .build()) + .addStruct("Y", EmbeddedRelationalStruct.newBuilder() + .addLong("A", 101L) + .addString("B", "blah blah") + .build()) + .build() + ) + .build(); + statement.executeInsert("T3", t3); + + RelationalStruct t4 = EmbeddedRelationalStruct.newBuilder() + .addLong("ID", 2L) + .addStruct("N1", EmbeddedRelationalStruct.newBuilder() + .addLong("A", 100L) + .addString("B", "blah") + .build()) + .addStruct("N2", EmbeddedRelationalStruct.newBuilder() + .addLong("A", 101L) + .addString("B", "blah blah") + .build()) + .build(); + statement.executeInsert("T4", t4); } @Test @@ -121,39 +193,181 @@ void canReadSingleStruct() throws Exception { Assertions.assertEquals("Hello", struct.getString("A"), "Incorrect value for nested struct!"); //check that the JDBC attributes methods work properly - Assertions.assertArrayEquals(struct.getAttributes(), new Object[]{"Hello"}, "Incorrect attributes!"); + Assertions.assertArrayEquals(new Object[]{"Hello"}, struct.getAttributes(), "Incorrect attributes!"); } } + /** + * Helper method to test struct type metadata preservation across query execution and continuations. + * + * @param query The SQL query to execute + * @param assertOnMetaData Consumer to assert on the result set metadata + * @param numBaseQueryRuns Number of times to run the base query (tests PhysicalQueryPlan.withExecutionContext when > 1) + * @param numContinuationRuns Number of times to run the continuation (tests ContinuedPhysicalQueryPlan.withExecutionContext when > 1) + */ + private void canReadStructTypeName(String query, + ThrowingConsumer assertOnMetaData, + int numBaseQueryRuns, + int numContinuationRuns) throws Throwable { + // Only set maxRows if we're testing continuations + if (numContinuationRuns > 0) { + statement.setMaxRows(1); + } + + Continuation continuation = null; + + // Run base query the specified number of times + for (int i = 0; i < numBaseQueryRuns; i++) { + try (final RelationalResultSet resultSet = statement.executeQuery(query)) { + Assertions.assertTrue(resultSet.next(), "Did not find a record on base query run " + (i + 1)); + assertOnMetaData.accept(resultSet); + if (i == 0 && numContinuationRuns > 0) { + continuation = resultSet.getContinuation(); + } + } + } + + // Run continuation the specified number of times + for (int i = 0; i < numContinuationRuns; i++) { + try (final PreparedStatement ps = connection.prepareStatement("EXECUTE CONTINUATION ?")) { + ps.setBytes(1, continuation.serialize()); + try (final ResultSet resultSet = ps.executeQuery()) { + Assertions.assertTrue(resultSet.next(), "Did not find a record on continuation run " + (i + 1)); + assertOnMetaData.accept(resultSet.unwrap(RelationalResultSet.class)); + } + } + } + } + + private void canReadStructTypeName(String query, ThrowingConsumer assertOnMetaData) throws Throwable { + canReadStructTypeName(query, assertOnMetaData, 1, 1); + } + @Test - void canReadProjectedStructTypeNameInNestedStar() throws Exception { - try (final RelationalResultSet resultSet = statement.executeQuery("SELECT (*) FROM T")) { - Assertions.assertTrue(resultSet.next(), "Did not find a record!"); + void canReadProjectedStructTypeNameInNestedStar() throws Throwable { + canReadStructTypeName("SELECT (*) FROM T", resultSet -> { RelationalStruct struct = resultSet.getStruct(1).getStruct("ST1"); Assertions.assertEquals("STRUCT_1", struct.getMetaData().getTypeName()); - } + }); } - // When projecting *, the underlying struct types are lost and replaced with a generic UUID type. - // This test should be replaced with the correct expected behavior once this is fixed. - // When projecting (*), everything works as expected, see `canReadProjectedStructTypeNameInNestedStar`. - // See https://github.com/FoundationDB/fdb-record-layer/issues/3743 @Test - void cannotReadProjectedStructTypeNameInUnnestedStar() throws Exception { - try (final RelationalResultSet resultSet = statement.executeQuery("SELECT * FROM T")) { - Assertions.assertTrue(resultSet.next(), "Did not find a record!"); + void canReadProjectedNestedStructTypeNameInNestedStar() throws Throwable { + canReadStructTypeName("SELECT (*) FROM NT", resultSet -> { + RelationalStruct struct = resultSet.getStruct(1).getStruct("ST1"); + Assertions.assertEquals("STRUCT_2", struct.getMetaData().getTypeName()); + RelationalStruct nestedStruct = struct.getStruct("D"); + Assertions.assertEquals("STRUCT_1", nestedStruct.getMetaData().getTypeName()); + }); + } + + @Test + void canReadProjectedStructInArrayTypeNameInNestedStar() throws Throwable { + canReadStructTypeName("SELECT (*) FROM AT", resultSet -> { + RelationalArray array = resultSet.getStruct(1).getArray("ST2"); + Assertions.assertEquals("STRUCT", array.getMetaData().getElementTypeName()); + Assertions.assertEquals("STRUCT_3", array.getMetaData().getElementStructMetaData().getTypeName()); + }); + } + + @Test + void canReadProjectedStructTypeNameInUnnestedStar() throws Throwable { + canReadStructTypeName("SELECT * FROM T", resultSet -> { RelationalStruct struct = resultSet.getStruct("ST1"); - Assertions.assertNotEquals("STRUCT_1", struct.getMetaData().getTypeName()); - } + Assertions.assertEquals("STRUCT_1", struct.getMetaData().getTypeName()); + }); } @Test - void canReadProjectedStructTypeNameDirectlyProjected() throws Exception { - try (final RelationalResultSet resultSet = statement.executeQuery("SELECT ST1 FROM T")) { - Assertions.assertTrue(resultSet.next(), "Did not find a record!"); + void canReadProjectedNestedStructTypeNameInUnnestedStar() throws Throwable { + canReadStructTypeName("SELECT * FROM NT", resultSet -> { + RelationalStruct struct = resultSet.getStruct("ST1"); + Assertions.assertEquals("STRUCT_2", struct.getMetaData().getTypeName()); + RelationalStruct nestedStruct = struct.getStruct("D"); + Assertions.assertEquals("STRUCT_1", nestedStruct.getMetaData().getTypeName()); + }); + } + + @Test + void canReadProjectedStructInArrayTypeNameInUnnestedStar() throws Throwable { + canReadStructTypeName("SELECT * FROM AT", resultSet -> { + RelationalArray array = resultSet.getArray("ST2"); + Assertions.assertEquals("STRUCT", array.getMetaData().getElementTypeName()); + Assertions.assertEquals("STRUCT_3", array.getMetaData().getElementStructMetaData().getTypeName()); + }); + } + + @Test + void canReadProjectedStructTypeNameDirectlyProjected() throws Throwable { + canReadStructTypeName("SELECT ST1 FROM T", resultSet -> { RelationalStruct struct = resultSet.getStruct("ST1"); Assertions.assertEquals("STRUCT_1", struct.getMetaData().getTypeName()); - } + }); + } + + @Test + void canReadProjectedNestedStructTypeNameDirectlyProjected() throws Throwable { + canReadStructTypeName("SELECT ST1 FROM NT", resultSet -> { + RelationalStruct struct = resultSet.getStruct("ST1").getStruct("D"); + Assertions.assertEquals("STRUCT_1", struct.getMetaData().getTypeName()); + }); + } + + @Test + void canReadProjectedStructInArrayTypeNameDirectlyProjected() throws Throwable { + canReadStructTypeName("SELECT * FROM AT", resultSet -> { + RelationalArray array = resultSet.getArray("ST2"); + Assertions.assertEquals("STRUCT", array.getMetaData().getElementTypeName()); + Assertions.assertEquals("STRUCT_3", array.getMetaData().getElementStructMetaData().getTypeName()); + }); + } + + @Test + void canReadProjectedDynamicStruct() throws Throwable { + canReadStructTypeName("SELECT STRUCT STRUCT_6(name, st1.a, st1) FROM T", resultSet -> { + RelationalStruct struct = resultSet.getStruct(1); + Assertions.assertEquals("STRUCT_6", struct.getMetaData().getTypeName()); + Assertions.assertEquals("STRUCT_1", struct.getStruct(3).getMetaData().getTypeName()); + }); + } + + @Test + void canReadProjectedStructWithDynamicStructInside() throws Throwable { + canReadStructTypeName("SELECT STRUCT STRUCT_6(name, STRUCT STRUCT_7(name, st1.a)) FROM T", resultSet -> { + RelationalStruct struct = resultSet.getStruct(1); + Assertions.assertEquals("STRUCT_6", struct.getMetaData().getTypeName()); + Assertions.assertEquals("STRUCT_7", struct.getStruct(2).getMetaData().getTypeName()); + }); + } + + @Test + void canReadAnonymousStructWithDynamicStructInside() throws Throwable { + canReadStructTypeName("SELECT (name, STRUCT STRUCT_7(name, st1.a)) FROM T", resultSet -> { + RelationalStruct struct = resultSet.getStruct(1); + Assertions.assertEquals("STRUCT_7", struct.getStruct(2).getMetaData().getTypeName()); + }); + } + + @Disabled // https://github.com/FoundationDB/fdb-record-layer/issues/3794 + void canDistinguishFieldsOfStructurallyEqualTypes() throws Throwable { + canReadStructTypeName("SELECT * FROM T4", resultSet -> { + RelationalStruct struct1 = resultSet.getStruct("N1"); + Assertions.assertEquals("N1", struct1.getMetaData().getTypeName()); + RelationalStruct struct2 = resultSet.getStruct("N2"); + Assertions.assertEquals("N2", struct2.getMetaData().getTypeName()); + }); + } + + @Disabled // https://github.com/FoundationDB/fdb-record-layer/issues/3794 + void canDistinguishNestedFieldsOfStructurallyEqualTypes() throws Throwable { + canReadStructTypeName("SELECT * FROM T3", resultSet -> { + RelationalStruct struct = resultSet.getStruct("M"); + Assertions.assertEquals("M", struct.getMetaData().getTypeName()); + RelationalStruct struct1 = struct.getStruct("X"); + Assertions.assertEquals("N1", struct1.getMetaData().getTypeName()); + RelationalStruct struct2 = struct.getStruct("Y"); + Assertions.assertEquals("N2", struct2.getMetaData().getTypeName()); + }); } @Test @@ -255,4 +469,52 @@ void canReadRepeatedStructWithArray() throws SQLException { } } } + + @Test + void structTypeMetadataPreservedAcrossPlanCache() throws Throwable { + canReadStructTypeName("SELECT * FROM T WHERE NAME = 'test_record_1'", resultSet -> { + RelationalStruct struct = resultSet.getStruct("ST1"); + Assertions.assertEquals("STRUCT_1", struct.getMetaData().getTypeName(), + "Struct type name should be preserved across plan cache"); + }, 2, 0); + } + + @Test + void nestedStructTypeMetadataPreservedAcrossPlanCache() throws Throwable { + canReadStructTypeName("SELECT * FROM NT WHERE T_NAME = 'nt_record'", resultSet -> { + RelationalStruct struct = resultSet.getStruct("ST1"); + RelationalStruct nestedStruct = struct.getStruct("D"); + Assertions.assertEquals("STRUCT_1", nestedStruct.getMetaData().getTypeName(), + "Nested struct type name should be preserved across plan cache"); + }, 2, 0); + } + + @Test + void arrayStructTypeMetadataPreservedAcrossPlanCache() throws Throwable { + canReadStructTypeName("SELECT * FROM AT WHERE A_NAME = 'a_test_rec'", resultSet -> { + RelationalArray array = resultSet.getArray("ST2"); + Assertions.assertEquals("STRUCT_3", array.getMetaData().getElementStructMetaData().getTypeName(), + "Array element struct type name should be preserved across plan cache"); + }, 2, 0); + } + + @Test + void structTypeMetadataPreservedInContinuationAcrossPlanCache() throws Throwable { + canReadStructTypeName("SELECT * FROM T", resultSet -> { + RelationalStruct struct = resultSet.getStruct("ST1"); + Assertions.assertEquals("STRUCT_1", struct.getMetaData().getTypeName(), + "Struct type name should be preserved in continuation across plan cache"); + }, 1, 2); + } + + @Test + void nestedStructTypeMetadataPreservedInContinuationAcrossPlanCache() throws Throwable { + canReadStructTypeName("SELECT * FROM NT", resultSet -> { + RelationalStruct struct = resultSet.getStruct("ST1"); + Assertions.assertEquals("STRUCT_2", struct.getMetaData().getTypeName()); + RelationalStruct nestedStruct = struct.getStruct("D"); + Assertions.assertEquals("STRUCT_1", nestedStruct.getMetaData().getTypeName(), + "Nested struct type name should be preserved in continuation across plan cache"); + }, 1, 2); + } } diff --git a/fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlanTest.java b/fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlanTest.java new file mode 100644 index 0000000000..10678081e4 --- /dev/null +++ b/fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/query/QueryPlanTest.java @@ -0,0 +1,109 @@ +/* + * QueryPlanTest.java + * + * This source file is part of the FoundationDB open source project + * + * Copyright 2021-2025 Apple Inc. and the FoundationDB project authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.apple.foundationdb.relational.recordlayer.query; + +import com.apple.foundationdb.record.PlanHashable.PlanHashMode; +import com.apple.foundationdb.record.query.plan.QueryPlanConstraint; +import com.apple.foundationdb.record.query.plan.cascades.typing.Type; +import com.apple.foundationdb.record.query.plan.cascades.typing.TypeRepository; +import com.apple.foundationdb.record.query.plan.plans.RecordQueryPlan; +import com.apple.foundationdb.relational.api.metadata.DataType; +import com.google.common.collect.ImmutableList; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * Unit tests for QueryPlan classes. + */ +class QueryPlanTest { + + /** + * Test that ContinuedPhysicalQueryPlan.withExecutionContext() returns the same instance. + * + *

This test exists primarily to satisfy code coverage requirements. In production, + * ContinuedPhysicalQueryPlan.withExecutionContext() is never called because continuation + * plans bypass the plan cache - each EXECUTE CONTINUATION statement deserializes the plan + * fresh from the continuation blob. + * + *

TODO: This test can be removed if/when the class hierarchy is refactored to eliminate + * the need for this dead code method (e.g., by collapsing ContinuedPhysicalQueryPlan into + * PhysicalQueryPlan with a flag, or making Plan.withExecutionContext() optional). + */ + @Test + void continuedPhysicalQueryPlanWithExecutionContextReturnsSameInstance() { + // Create minimal mocks to construct a ContinuedPhysicalQueryPlan + final RecordQueryPlan mockRecordQueryPlan = Mockito.mock(RecordQueryPlan.class); + final Type.Relation mockRelation = Mockito.mock(Type.Relation.class); + final Type.Record mockRecord = Type.Record.fromFields(ImmutableList.of( + Type.Record.Field.of(Type.primitiveType(Type.TypeCode.STRING), Optional.of("test_field")))); + + Mockito.when(mockRecordQueryPlan.getResultType()).thenReturn(mockRelation); + Mockito.when(mockRelation.getInnerType()).thenReturn(mockRecord); + + final TypeRepository typeRepository = TypeRepository.newBuilder().build(); + final QueryPlanConstraint constraint = QueryPlanConstraint.noConstraint(); + final QueryExecutionContext executionContext = new MutablePlanGenerationContext( + PreparedParams.empty(), + PlanHashMode.VC0, + "SELECT 1", + "SELECT 1", + 0); + + final ImmutableList semanticFieldTypes = ImmutableList.of( + DataType.Primitives.STRING.type()); + + // Wrap semantic types in a StructType + final DataType.StructType semanticStructType = DataType.StructType.from("QUERY_RESULT", + ImmutableList.of( + DataType.StructType.Field.from("field_0", DataType.Primitives.INTEGER.type(), 0), + DataType.StructType.Field.from("field_1", DataType.Primitives.STRING.type(), 1)), + true); + + // Create a ContinuedPhysicalQueryPlan instance + final QueryPlan.ContinuedPhysicalQueryPlan continuedPlan = new QueryPlan.ContinuedPhysicalQueryPlan( + mockRecordQueryPlan, + typeRepository, + constraint, + executionContext, + "EXECUTE CONTINUATION test", + PlanHashMode.VC0, + PlanHashMode.VL0, + semanticStructType); + + // Create a different execution context + final QueryExecutionContext differentContext = new MutablePlanGenerationContext( + PreparedParams.empty(), + PlanHashMode.VC0, + "SELECT 2", + "SELECT 2", + 1); + + // Call withExecutionContext and verify it returns the same instance + final QueryPlan.PhysicalQueryPlan result = continuedPlan.withExecutionContext(differentContext); + + assertSame(continuedPlan, result, + "ContinuedPhysicalQueryPlan.withExecutionContext() should return the same instance"); + } +} diff --git a/yaml-tests/src/test/resources/join-tests.yamsql b/yaml-tests/src/test/resources/join-tests.yamsql index 67477a437a..3ef8e2ca65 100644 --- a/yaml-tests/src/test/resources/join-tests.yamsql +++ b/yaml-tests/src/test/resources/join-tests.yamsql @@ -174,6 +174,22 @@ test_block: - unorderedResult: [{"Engineering", "OLAP"}, {"Sales", "Feedback"}, {"Marketing", "SEO"}] + - + # ambiguous sub select is fine if the top-level query does not specify column names + - query: select * from (select dept.name, project.name from emp, dept, project where emp.dept_id = dept.id and project.emp_id = emp.id) X; + - unorderedResult: [{"Engineering", "OLAP"}, + {"Sales", "Feedback"}, + {"Marketing", "SEO"}] + - + # ambiguous sub select is fine if the top-level query does not specify column names + - query: select (*) from (select dept.name, project.name from emp, dept, project where emp.dept_id = dept.id and project.emp_id = emp.id) X; + - unorderedResult: [{{"Engineering", "OLAP"}}, + {{"Sales", "Feedback"}}, + {{"Marketing", "SEO"}}] + - + # ambiguous sub select fails if top-level select refers to one of the columns + - query: select name from (select dept.name, project.name from emp, dept, project where emp.dept_id = dept.id and project.emp_id = emp.id) X; + - error: "42702" - # inner join version of previous - query: select dept.name, project.name from project inner join emp on emp.id = project.emp_id inner join dept on emp.dept_id = dept.id;