Enable force continuations mode on all YamlIntegrationTests

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

@@ -188,7 +188,7 @@ public PValue toValueProto(@Nonnull final PlanSerializationContext serialization
     public static PatternForLikeValue fromProto(@Nonnull final PlanSerializationContext serializationContext,
                                                 @Nonnull final PPatternForLikeValue patternForLikeValueProto) {
         return new PatternForLikeValue(Value.fromValueProto(serializationContext, Objects.requireNonNull(patternForLikeValueProto.getPatternChild())),
-                Value.fromValueProto(serializationContext, Objects.requireNonNull(patternForLikeValueProto.getPatternChild())));
+                Value.fromValueProto(serializationContext, Objects.requireNonNull(patternForLikeValueProto.getEscapeChild())));
     }
 
     @Nonnull

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

@@ -96,10 +96,19 @@ public <M extends Message> RecordCursor<QueryResult> executePlan(@Nonnull final
                                                                      @Nonnull final EvaluationContext context,
                                                                      @Nullable final byte[] continuation,
                                                                      @Nonnull final ExecuteProperties executeProperties) {
-        return new FutureCursor<>(store.getExecutor(),
-                getChild().executePlan(store, context, continuation, executeProperties).first()
-                        .thenApply(resultOptional ->
-                                resultOptional.orElseGet(() -> QueryResult.ofComputed(onEmptyResultValue.eval(store, context)))));
+        if (continuation == null) {
+            return new FutureCursor<>(store.getExecutor(),
+                    getChild().executePlan(store, context, null, executeProperties).first()
+                            .thenApply(resultOptional ->
+                                    resultOptional.orElseGet(() -> QueryResult.ofComputed(onEmptyResultValue.eval(store, context)))));
+        } else {
+            // The FutureCursor only ever returns a single continuation, indicating that the future
+            // has been completed. So, if we get a non-null continuation back, that means we've already
+            // completed the work done and returned something, so send an empty cursor back.
+            // Note that this doesn't handle out-of-band cursor no-next-reasons
+            // See: https://github.com/FoundationDB/fdb-record-layer/issues/3220
+            return RecordCursor.empty(store.getExecutor());
+        }
     }
 
     @Override

fdb-record-layer-core/src/test/java/com/apple/foundationdb/record/query/plan/cascades/LikeOperatorValueTest.java

@@ -22,7 +22,10 @@
 
 import com.apple.foundationdb.record.Bindings;
 import com.apple.foundationdb.record.EvaluationContext;
+import com.apple.foundationdb.record.PlanHashable;
+import com.apple.foundationdb.record.PlanSerializationContext;
 import com.apple.foundationdb.record.TestRecords7Proto;
+import com.apple.foundationdb.record.planprotos.PLikeOperatorValue;
 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.cascades.typing.Typed;
@@ -33,6 +36,7 @@
 import com.apple.foundationdb.record.query.plan.cascades.values.LikeOperatorValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
 import com.apple.foundationdb.record.query.plan.plans.QueryResult;
+import com.apple.foundationdb.record.query.plan.serialization.DefaultPlanSerializationRegistry;
 import com.google.common.collect.ImmutableList;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.extension.ExtensionContext;
@@ -41,6 +45,7 @@
 import org.junit.jupiter.params.provider.ArgumentsProvider;
 import org.junit.jupiter.params.provider.ArgumentsSource;
 
+import javax.annotation.Nonnull;
 import java.util.Arrays;
 import java.util.Optional;
 import java.util.stream.Stream;
@@ -188,18 +193,38 @@ void testSemanticException(Value lhs, Value rhs, Value escapeChar) {
     }
 
     @ParameterizedTest
-    @SuppressWarnings({"rawtypes", "unchecked", "ConstantConditions"})
+    @SuppressWarnings({"ConstantConditions"})
     @ArgumentsSource(ValidInputArgumentsProvider.class)
     void testLike(String lhs, String rhs, final String escapeChar, Boolean result) {
+        final LikeOperatorValue value = createLikeOperatorValue(lhs, rhs, escapeChar);
+        Assertions.assertEquals(result, value.eval(null, evaluationContext));
+    }
+
+    @ParameterizedTest
+    @SuppressWarnings({"ConstantConditions"})
+    @ArgumentsSource(ValidInputArgumentsProvider.class)
+    void testLikeSerialization(String lhs, String rhs, final String escapeChar, Boolean result) {
+        final LikeOperatorValue value = createLikeOperatorValue(lhs, rhs, escapeChar);
+        final PLikeOperatorValue proto = value.toProto(
+                new PlanSerializationContext(new DefaultPlanSerializationRegistry(),
+                        PlanHashable.CURRENT_FOR_CONTINUATION));
+        final LikeOperatorValue deserialized = LikeOperatorValue.fromProto(new PlanSerializationContext(new DefaultPlanSerializationRegistry(),
+                PlanHashable.CURRENT_FOR_CONTINUATION), proto);
+        Assertions.assertEquals(result, deserialized.eval(null, evaluationContext));
+    }
+
+
+    @SuppressWarnings({"rawtypes", "unchecked", "ConstantConditions"})
+    @Nonnull
+    private static LikeOperatorValue createLikeOperatorValue(final String lhs, final String rhs, final String escapeChar) {
         BuiltInFunction like = new LikeOperatorValue.LikeFn();
         BuiltInFunction pattern = new PatternForLikeValue.PatternForLikeFn();
         Typed value = like.encapsulate(Arrays.asList(
-                    new LiteralValue<>(Type.primitiveType(Type.TypeCode.STRING), lhs),
-                    pattern.encapsulate(Arrays.asList(
-                            new LiteralValue<>(Type.primitiveType(Type.TypeCode.STRING), rhs),
-                            new LiteralValue<>(Type.primitiveType(Type.TypeCode.STRING), escapeChar)))));
-        Assertions.assertTrue(value instanceof LikeOperatorValue);
-        Object actualValue = ((LikeOperatorValue)value).eval(null, evaluationContext);
-        Assertions.assertEquals(result, actualValue);
+                new LiteralValue<>(Type.primitiveType(Type.TypeCode.STRING), lhs),
+                pattern.encapsulate(Arrays.asList(
+                        new LiteralValue<>(Type.primitiveType(Type.TypeCode.STRING), rhs),
+                        new LiteralValue<>(Type.primitiveType(Type.TypeCode.STRING), escapeChar)))));
+        Assertions.assertInstanceOf(LikeOperatorValue.class, value);
+        return (LikeOperatorValue) value;
     }
 }

yaml-tests/src/main/java/com/apple/foundationdb/relational/yamltests/CustomYamlConstructor.java

@@ -132,6 +132,11 @@ public static LinedObject cast(@Nonnull Object obj, @Nonnull Supplier<String> ms
             Assert.thatUnchecked(obj instanceof LinedObject, ErrorCode.INTERNAL_ERROR, msg);
             return (LinedObject) obj;
         }
+
+        @Override
+        public String toString() {
+            return object + "@line:" + lineNumber;
+        }
     }
 
     private static class ConstructIgnore extends AbstractConstruct {

yaml-tests/src/main/java/com/apple/foundationdb/relational/yamltests/block/Block.java

@@ -53,7 +53,8 @@ public interface Block {
      */
     static Block parse(@Nonnull Object document, int blockNumber, @Nonnull YamlExecutionContext executionContext) {
         final var blockObject = Matchers.map(document, "block");
-        Assert.thatUnchecked(blockObject.size() == 1, "Illegal Format: A block is expected to be a map of size 1");
+        Assert.thatUnchecked(blockObject.size() == 1,
+                "Illegal Format: A block is expected to be a map of size 1 (block: " + blockNumber + ") keys: " + blockObject.keySet());
         final var entry = Matchers.firstEntry(blockObject, "block key-value");
         final var linedObject = CustomYamlConstructor.LinedObject.cast(entry.getKey(), () -> "Invalid block key-value pair: " + entry);
         final var lineNumber = linedObject.getLineNumber();

yaml-tests/src/main/java/com/apple/foundationdb/relational/yamltests/command/QueryExecutor.java

@@ -26,9 +26,11 @@
 import com.apple.foundationdb.relational.api.RelationalResultSetMetaData;
 import com.apple.foundationdb.relational.api.exceptions.RelationalException;
 import com.apple.foundationdb.relational.api.metrics.RelationalMetric;
+import com.apple.foundationdb.relational.recordlayer.ContinuationImpl;
 import com.apple.foundationdb.relational.yamltests.AggregateResultSet;
 import com.apple.foundationdb.relational.yamltests.YamlConnection;
 import com.apple.foundationdb.relational.yamltests.command.parameterinjection.Parameter;
+import com.apple.foundationdb.relational.yamltests.server.SemanticVersion;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.junit.jupiter.api.Assertions;
@@ -53,6 +55,8 @@ public class QueryExecutor {
     private static final Logger logger = LogManager.getLogger(QueryExecutor.class);
     private static final int FORCED_MAX_ROWS = 1; // The maxRows number to use when we are forcing it on the test
     private static final int MAX_CONTINUATIONS_ALLOWED = 100;
+    @SuppressWarnings("PMD.AvoidUsingHardCodedIP") // This is not an IP address
+    private static final SemanticVersion STRICT_ASSERTIONS_CUTOFF = SemanticVersion.parse("4.1.9.0");
 
     @Nonnull
     private final String query;
@@ -107,8 +111,10 @@ public Continuation execute(@Nonnull YamlConnection connection, @Nullable Contin
             return executeQuery(connection, config, currentQuery, checkCache, maxRows);
         } else if (continuation.atBeginning()) {
             // Continuation cannot be at beginning if it was returned from a query
-            reportTestFailure("Received continuation shouldn't be at beginning");
-            return null;
+            if (STRICT_ASSERTIONS_CUTOFF.lesserVersions(connection.getVersions()).isEmpty()) {
+                reportTestFailure("Received continuation shouldn't be at beginning");
+            }
+            return ContinuationImpl.END;
         } else {
             // Have a continuation - continue
             return executeContinuation(connection, continuation, config, currentQuery, maxRows);
@@ -143,7 +149,7 @@ private Object executeStatementAndCheckCacheIfNeeded(@Nonnull Statement s, final
         final var toReturn = executeStatementAndCheckForceContinuations(s, statementHasQuery, queryString, connection, maxRows);
         final var postMetricCollector = connection.getMetricCollector();
         final var postValue = postMetricCollector.hasCounter(RelationalMetric.RelationalCount.PLAN_CACHE_TERTIARY_HIT) ?
-                postMetricCollector.getCountsForCounter(RelationalMetric.RelationalCount.PLAN_CACHE_TERTIARY_HIT) : 0;
+                              postMetricCollector.getCountsForCounter(RelationalMetric.RelationalCount.PLAN_CACHE_TERTIARY_HIT) : 0;
         final var planFound = preMetricCollector != postMetricCollector ? postValue == 1 : postValue == preValue + 1;
         if (!planFound) {
             reportTestFailure("‼️ Expected to retrieve the plan from the cache at line " + lineNumber);
@@ -263,7 +269,11 @@ private Object executeStatementWithForcedContinuations(final @Nonnull Statement
             int count = 0;
             while (!continuation.atEnd()) {
                 if (continuation.atBeginning()) {
-                    reportTestFailure("Received continuation shouldn't be at beginning");
+                    if (STRICT_ASSERTIONS_CUTOFF.lesserVersions(connection.getVersions()).isEmpty()) {
+                        reportTestFailure("Received continuation shouldn't be at beginning");
+                    }
+                    continuation = ContinuationImpl.END;
+                    break;
                 }
                 try (var s2 = prepareContinuationStatement(connection, continuation, FORCED_MAX_ROWS)) {
                     resultSet = (RelationalResultSet)executeStatement(s2, true, queryString);
@@ -273,7 +283,9 @@ private Object executeStatementWithForcedContinuations(final @Nonnull Statement
                         results.add(resultSet);
                     } else {
                         // We assume that the last result is empty because of the maxRows:1
-                        Assertions.assertFalse(hasNext, "Result has more rows than maxRows allowed");
+                        if (STRICT_ASSERTIONS_CUTOFF.lesserVersions(connection.getVersions()).isEmpty()) {
+                            Assertions.assertFalse(hasNext, "End result should not have any associated value when maxRows is 1");
+                        }
                     }
                 }
                 count += 1; // PMD failure for ++

yaml-tests/src/test/java/YamlIntegrationTests.java

@@ -18,7 +18,6 @@
  * limitations under the License.
  */
 
-import com.apple.foundationdb.relational.yamltests.ExcludeYamlTestConfig;
 import com.apple.foundationdb.relational.yamltests.MaintainYamlTestConfig;
 import com.apple.foundationdb.relational.yamltests.YamlTest;
 import com.apple.foundationdb.relational.yamltests.YamlTestConfigFilters;
@@ -39,43 +38,31 @@ public void showcasingTests(YamlTest.Runner runner) throws Exception {
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Infinite continuation loop (https://github.com/FoundationDB/fdb-record-layer/issues/3095)")
     public void groupByTests(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("groupby-tests.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "continuation verification (https://github.com/FoundationDB/fdb-record-layer/issues/3096)")
     public void standardTests(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("standard-tests.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "continuation verification (https://github.com/FoundationDB/fdb-record-layer/issues/3096)")
     public void standardTestsWithProto(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("standard-tests-proto.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Continuation verification (https://github.com/FoundationDB/fdb-record-layer/issues/3096)")
     public void fieldIndexTestsProto(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("field-index-tests-proto.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Continuation verification (https://github.com/FoundationDB/fdb-record-layer/issues/3096)")
     public void standardTestsWithMetaData(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("standard-tests-metadata.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "continuation verification (https://github.com/FoundationDB/fdb-record-layer/issues/3096)")
     public void nullOperator(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("null-operator-tests.yamsql");
     }
@@ -97,22 +84,16 @@ public void scenarioTests(YamlTest.Runner runner) throws Exception {
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Infinite continuation loop (https://github.com/FoundationDB/fdb-record-layer/issues/3095)")
     public void joinTests(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("join-tests.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Infinite continuation loop (https://github.com/FoundationDB/fdb-record-layer/issues/3095)")
     public void subqueryTests(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("subquery-tests.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Infinite continuation loop (https://github.com/FoundationDB/fdb-record-layer/issues/3095)")
     public void selectAStar(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("select-a-star.yamsql");
     }
@@ -134,8 +115,6 @@ public void aggregateIndexTests(YamlTest.Runner runner) throws Exception {
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Infinite continuation loop (https://github.com/FoundationDB/fdb-record-layer/issues/3095)")
     public void aggregateEmptyTable(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("aggregate-empty-table.yamsql");
     }
@@ -196,8 +175,6 @@ void bytes(YamlTest.Runner runner) throws Exception {
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Continuation verification (https://github.com/FoundationDB/fdb-record-layer/issues/3096)")
     void catalog(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("catalog.yamsql");
     }
@@ -208,15 +185,11 @@ public void caseWhen(YamlTest.Runner runner) throws Exception {
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "maxRows ignored on update (https://github.com/FoundationDB/fdb-record-layer/issues/3100)")
     public void updateDeleteReturning(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("update-delete-returning.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Like continuation failure (https://github.com/FoundationDB/fdb-record-layer/issues/3099)")
     void like(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("like.yamsql");
     }
@@ -227,8 +200,6 @@ void functions(YamlTest.Runner runner) throws Exception {
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Continuation verification (https://github.com/FoundationDB/fdb-record-layer/issues/3096)")
     void createDrop(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("create-drop.yamsql");
     }
@@ -254,15 +225,11 @@ public void indexedFunctions(YamlTest.Runner runner) throws Exception {
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Infinite continuation loop (https://github.com/FoundationDB/fdb-record-layer/issues/3095)")
     public void union(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("union.yamsql");
     }
 
     @TestTemplate
-    @ExcludeYamlTestConfig(value = YamlTestConfigFilters.DO_NOT_FORCE_CONTINUATIONS,
-            reason = "Infinite continuation loop (https://github.com/FoundationDB/fdb-record-layer/issues/3095)")
     public void unionEmptyTables(YamlTest.Runner runner) throws Exception {
         runner.runYamsql("union-empty-tables.yamsql");
     }