Fix struct type metadata preservation in query results and continuations

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/typing/Type.java

@@ -2588,7 +2588,6 @@ private static List<Field> normalizeFields(@Nullable final List<Field> 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<String> fieldNamesSeen = Sets.newHashSet();
             final ImmutableList.Builder<Field> resultFieldsBuilder = ImmutableList.builder();
             for (int i = 0; i < fields.size(); i++) {
                 final var field = fields.get(i);
@@ -2612,9 +2611,6 @@ private static List<Field> normalizeFields(@Nullable final List<Field> fields) {
                                     Optional.of(fieldStorageName));
                 }
 
-                if (!(fieldNamesSeen.add(fieldToBeAdded.getFieldName()))) {
-                    throw new RecordCoreException("fields contain duplicate field names");
-                }
                 resultFieldsBuilder.add(fieldToBeAdded);
             }
 

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.

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<Type> 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.
+     *
+     * <p>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:
+     * <ul>
+     *   <li>Field names from the expressions (handles aliases, star expansion, etc.)</li>
+     *   <li>Type structure from semantic analysis (preserves struct type names)</li>
+     * </ul>
+     *
+     * <p>This StructType can be used directly for result set metadata after enriching nested
+     * struct names from RecordMetaData descriptors.
+     *
+     * <p>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<DataType.StructType.Field> 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<Expression> stream() {
         return underlying.stream();

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 @@
         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<DataType.StructType.Field> 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() {

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

@@ -128,14 +128,22 @@
         @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,
                                  @Nonnull final QueryPlanConstraint constraint,
                                  @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 @@
             this.queryExecutionContext = queryExecutionContext;
             this.currentPlanHashMode = currentPlanHashMode;
             this.planHashSupplier = Suppliers.memoize(() -> recordQueryPlan.planHash(currentPlanHashMode));
+            this.semanticStructType = semanticStructType;
         }
 
         @Nonnull
@@ -192,7 +201,8 @@
                 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 @@
                             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<Row> 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 @@
                     i++;
                 }
 
-                compiledStatementBuilder.setPlanConstraint(getContinuationConstraint().toProto(serializationContext));
-
+                compiledStatementBuilder.setPlanConstraint(getContinuationConstraint().toProto(serializationContext))
+                        .setQueryMetadata(DataTypeUtils.toRecordLayerType(semanticStructType).toTypeProto(serializationContext));
                 continuationBuilder.withCompiledStatement(compiledStatementBuilder.build());
             }
             return continuationBuilder.build();
@@ -470,15 +480,16 @@
         @Nonnull
         private final Supplier<Integer> serializedPlanHashSupplier;
 
         public ContinuedPhysicalQueryPlan(@Nonnull final RecordQueryPlan recordQueryPlan,
                                           @Nonnull final TypeRepository typeRepository,
                                           @Nonnull final QueryPlanConstraint continuationConstraint,
                                           @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 @@
             return serializedPlanHashMode;
         }
 
-        @SuppressWarnings("PMD.CompareObjectsWithEquals")
+        /**
+         * Returns a plan with updated execution context.
+         *
+         * <p>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.
+         *
+         * <p>TODO: Refactor the class hierarchy to eliminate this dead code. Potential approaches:
+         * <ul>
+         *   <li>Collapse ContinuedPhysicalQueryPlan into PhysicalQueryPlan with a flag</li>
+         *   <li>Use composition instead of inheritance</li>
+         *   <li>Make Plan.withExecutionContext() optional with default implementation</li>
+         * </ul>
+         *
+         * @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 @@
         @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<PhysicalQueryPlan> 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 @@
 
                 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 @@
         @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