Added ability to hand in connection options through the yaml framework and temporary tests that disable all rewrite rules (#3438)

Author: normen662

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

@@ -29,6 +29,7 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Maps;
 
 import javax.annotation.Nonnull;
@@ -261,6 +262,11 @@ public enum IndexFetchMethod {
     private final Options parentOptions;
     private final Map<Name, Object> optionsMap;
 
+    @Nonnull
+    public static Options none() {
+        return NONE;
+    }
+
     @Nonnull
     public static Map<Name, Object> defaultOptions() {
         return OPTIONS_DEFAULT_VALUES;
@@ -316,6 +322,12 @@ private Builder() {
             optionsMap = Maps.newHashMap();
         }
 
+        @Nonnull
+        public Builder withOptionFromString(Name name, String valueAsString) throws SQLException {
+            final Object value = parseStringOption(name, valueAsString);
+            return withOption(name, value);
+        }
+
         @Nonnull
         public Builder withOption(Name name, Object value) throws SQLException {
             validateOption(name, value);
@@ -346,6 +358,16 @@ public Options build() {
         }
     }
 
+    @Nullable
+    private static Object parseStringOption(@Nonnull final Name name, String valueAsString) throws SQLException {
+        for (OptionContract contract : Objects.requireNonNull(OPTIONS).get(name)) {
+            if (contract instanceof TypeContract<?>) {
+                return ((TypeContract<?>)contract).fromString(valueAsString);
+            }
+        }
+        throw new SQLException("option must have at least one type contract", ErrorCode.INTERNAL_ERROR.getErrorCode());
+    }
+
     private static void validateOption(@Nonnull final Name name, Object value) throws SQLException {
         for (OptionContract contract : Objects.requireNonNull(OPTIONS).get(name)) {
             contract.validate(name, value);
@@ -362,13 +384,22 @@ private <T> T getOptionInternal(Name name) {
         }
     }
 
+    @Nonnull
+    public Iterable<? extends Map.Entry<Name, ?>> entries() {
+        if (parentOptions != null) {
+            return Iterables.concat(parentOptions.entries(), optionsMap.entrySet());
+        } else {
+            return optionsMap.entrySet();
+        }
+    }
+
     private static Map<Name, List<OptionContract>> makeContracts() {
         EnumMap<Name, List<OptionContract>> data = new EnumMap<>(Name.class);
-        data.put(Name.CONTINUATION, List.of(new TypeContract<>(Continuation.class)));
+        data.put(Name.CONTINUATION, List.of(TypeContract.of(Continuation.class, ignored -> { throw new UnsupportedOperationException(); })));
         data.put(Name.MAX_ROWS, List.of(TypeContract.intType(), RangeContract.of(0, Integer.MAX_VALUE)));
-        data.put(Name.INDEX_FETCH_METHOD, List.of(new TypeContract<>(IndexFetchMethod.class)));
+        data.put(Name.INDEX_FETCH_METHOD, List.of(TypeContract.of(IndexFetchMethod.class, IndexFetchMethod::valueOf)));
         data.put(Name.DISABLE_PLANNER_REWRITING, List.of(TypeContract.booleanType()));
-        data.put(Name.DISABLED_PLANNER_RULES, List.of(new CollectionContract(TypeContract.stringType())));
+        data.put(Name.DISABLED_PLANNER_RULES, List.of(new CollectionContract<>(TypeContract.stringType())));
         data.put(Name.INDEX_HINT, List.of(TypeContract.stringType()));
         data.put(Name.PLAN_CACHE_PRIMARY_MAX_ENTRIES, List.of(TypeContract.intType(), RangeContract.of(0, Integer.MAX_VALUE)));
         data.put(Name.PLAN_CACHE_PRIMARY_TIME_TO_LIVE_MILLIS, List.of(TypeContract.longType(), RangeContract.of(10L, Long.MAX_VALUE)));

fdb-relational-api/src/main/java/com/apple/foundationdb/relational/api/options/CollectionContract.java

@@ -24,21 +24,26 @@
 import com.apple.foundationdb.relational.api.exceptions.ErrorCode;
 
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Option contract that ensures that all elements of a collection match some contract.
  * The contract is only valid if the elements of the given option are (1) some kind
  * of collection type and (2) every element in the collection satisfies the "element
  * contract" over which the contract is defined. For example, the child contract
  * may be that each element is of a given type or within a particular range.
+ * @param <T> the type parameter of the collection
  */
-public class CollectionContract implements OptionContract {
+public class CollectionContract<T> implements OptionContract, OptionContractWithConversion<Collection<T>> {
     @Nonnull
-    private final OptionContract elementContract;
+    private final TypeContract<T> elementContract;
 
-    public CollectionContract(@Nonnull OptionContract elementContract) {
+    public CollectionContract(@Nonnull TypeContract<T> elementContract) {
         this.elementContract = elementContract;
     }
 
@@ -56,4 +61,15 @@ public void validate(final Options.Name name, final Object value) throws SQLExce
             throw new SQLException("Element of collection option " + name + " violated contract: " + err.getMessage(), err.getSQLState(), err);
         }
     }
+
+    @Nullable
+    @Override
+    public Collection<T> fromString(final String valueAsString) throws SQLException {
+        final List<T> results = new ArrayList<>(); // not null-phobic
+        for (final String split : valueAsString.split(",")) {
+            final String trimmedElementString = split.trim();
+            results.add(elementContract.fromString(trimmedElementString));
+        }
+        return Collections.unmodifiableCollection(results);
+    }
 }

fdb-relational-api/src/main/java/com/apple/foundationdb/relational/api/options/OptionContractWithConversion.java

@@ -0,0 +1,29 @@
+/*
+ * OptionContract.java
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2021-2024 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.api.options;
+
+import javax.annotation.Nullable;
+import java.sql.SQLException;
+
+public interface OptionContractWithConversion<T> extends OptionContract {
+    @Nullable
+    T fromString(String valueAsString) throws SQLException;
+}

fdb-relational-api/src/main/java/com/apple/foundationdb/relational/api/options/TypeContract.java

@@ -21,33 +21,38 @@
 package com.apple.foundationdb.relational.api.options;
 
 import com.apple.foundationdb.annotation.API;
-
 import com.apple.foundationdb.relational.api.Options;
 import com.apple.foundationdb.relational.api.exceptions.ErrorCode;
 
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import java.sql.SQLException;
+import java.util.function.Function;
 
 @API(API.Status.EXPERIMENTAL)
-public class TypeContract<T> implements OptionContract {
+public class TypeContract<T> implements OptionContract, OptionContractWithConversion<T> {
 
     @Nonnull
-    private static final TypeContract<Boolean> BOOLEAN_TYPE = new TypeContract<>(Boolean.class);
+    private static final TypeContract<Boolean> BOOLEAN_TYPE = new TypeContract<>(Boolean.class, Boolean::parseBoolean);
 
     @Nonnull
-    private static final TypeContract<Integer> INTEGER_TYPE = new TypeContract<>(Integer.class);
+    private static final TypeContract<Integer> INTEGER_TYPE = new TypeContract<>(Integer.class, Integer::parseInt);
 
     @Nonnull
-    private static final TypeContract<Long> LONG_TYPE = new TypeContract<>(Long.class);
+    private static final TypeContract<Long> LONG_TYPE = new TypeContract<>(Long.class, Long::parseLong);
 
     @Nonnull
-    private static final TypeContract<String> STRING_TYPE = new TypeContract<>(String.class);
+    private static final TypeContract<String> STRING_TYPE = new TypeContract<>(String.class, Function.identity());
 
+    @Nonnull
     private final Class<T> clazz;
 
-    public TypeContract(Class<T> clazz) {
-        this.clazz = clazz;
+    @Nonnull
+    private final Function<String, T> fromStringFunction;
 
+    private TypeContract(@Nonnull Class<T> clazz, @Nonnull Function<String, T> fromStringFunction) {
+        this.clazz = clazz;
+        this.fromStringFunction = fromStringFunction;
     }
 
     @Override
@@ -57,9 +62,15 @@ public void validate(Options.Name name, Object value) throws SQLException {
         }
     }
 
+    @Nullable
+    @Override
+    public T fromString(String valueAsString) throws SQLException {
+        return fromStringFunction.apply(valueAsString);
+    }
+
     @Nonnull
-    public static <T> TypeContract<T> of(@Nonnull final Class<T> clazz) {
-        return new TypeContract<>(clazz);
+    public static <T> TypeContract<T> of(@Nonnull final Class<T> clazz, @Nonnull Function<String, T> fromStringFunction) {
+        return new TypeContract<>(clazz, fromStringFunction);
     }
 
     @Nonnull

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

@@ -0,0 +1,52 @@
+/*
+ * EmbeddedSimpleYamlConnection.java
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2015-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.yamltests;
+
+import com.apple.foundationdb.relational.api.Options;
+import com.apple.foundationdb.relational.api.RelationalConnection;
+import com.apple.foundationdb.relational.yamltests.server.SemanticVersion;
+
+import javax.annotation.Nonnull;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Map;
+
+/**
+ * A simple version of {@link YamlConnection} for interacting with a single {@link RelationalConnection}.
+ */
+public class EmbeddedSimpleYamlConnection extends SimpleYamlConnection {
+    public EmbeddedSimpleYamlConnection(@Nonnull Connection connection, @Nonnull SemanticVersion version) throws SQLException {
+        super(connection, version, version.toString());
+    }
+
+    public EmbeddedSimpleYamlConnection(@Nonnull Connection connection, @Nonnull SemanticVersion version, @Nonnull String connectionLabel) throws SQLException {
+        super(connection, version, connectionLabel);
+    }
+
+    @Override
+    @SuppressWarnings("PMD.CloseResource")
+    public void setConnectionOptions(@Nonnull final Options connectionOptions) throws SQLException {
+        final RelationalConnection underlying = getUnderlying();
+        for (Map.Entry<Options.Name, ?> entry : connectionOptions.entries()) {
+            underlying.setOption(entry.getKey(), entry.getValue());
+        }
+    }
+}

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

@@ -1,5 +1,5 @@
 /*
- * YamlConnection.java
+ * SimpleYamlConnection.java
  *
  * This source file is part of the FoundationDB open source project
  *
@@ -20,12 +20,15 @@
 
 package com.apple.foundationdb.relational.yamltests;
 
+import com.apple.foundationdb.relational.api.Options;
 import com.apple.foundationdb.relational.api.RelationalConnection;
 import com.apple.foundationdb.relational.api.RelationalPreparedStatement;
 import com.apple.foundationdb.relational.api.RelationalStatement;
 import com.apple.foundationdb.relational.api.metrics.MetricCollector;
 import com.apple.foundationdb.relational.recordlayer.EmbeddedRelationalConnection;
 import com.apple.foundationdb.relational.yamltests.server.SemanticVersion;
+import com.google.common.collect.Iterables;
+import org.junit.jupiter.api.Assumptions;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -54,11 +57,23 @@ public SimpleYamlConnection(@Nonnull Connection connection, @Nonnull SemanticVer
         this.connectionLabel = connectionLabel;
     }
 
+    @Nonnull
+    protected RelationalConnection getUnderlying() {
+        return underlying;
+    }
+
     @Override
     public void close() throws SQLException {
         underlying.close();
     }
 
+    @Override
+    public void setConnectionOptions(@Nonnull final Options connectionOptions) throws SQLException {
+        if (!Iterables.isEmpty(connectionOptions.entries())) {
+            Assumptions.abort("only embedded connections support the setting of connection options");
+        }
+    }
+
     @Override
     public boolean supportsMetricCollector() {
         return underlying instanceof EmbeddedRelationalConnection;

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

@@ -20,6 +20,7 @@
 
 package com.apple.foundationdb.relational.yamltests;
 
+import com.apple.foundationdb.relational.api.Options;
 import com.apple.foundationdb.relational.api.RelationalConnection;
 import com.apple.foundationdb.relational.api.RelationalPreparedStatement;
 import com.apple.foundationdb.relational.api.RelationalStatement;
@@ -43,6 +44,8 @@ public interface YamlConnection extends AutoCloseable {
     @Override
     void close() throws SQLException;
 
+    void setConnectionOptions(@Nonnull Options connectionOptions) throws SQLException;
+
     /**
      * Creates a statement (see {@link RelationalConnection#createStatement()}).
      * @return a new statement

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

@@ -31,6 +31,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.junit.jupiter.api.Assertions;
+import org.opentest4j.TestAbortedException;
 import org.yaml.snakeyaml.DumperOptions;
 import org.yaml.snakeyaml.Yaml;
 
@@ -265,32 +266,35 @@ public List<Block> getFinalizeBlocks() {
      * test_run: lineNumber of query, query run as a simple statement or as prepared statement, parameters (if any)
      * test_block: lineNumber of test_block, seed used for randomization, execution properties
      *
-     * @param e the throwable that needs to be wrapped
+     * @param throwable the throwable that needs to be wrapped
      * @param msg additional context
      * @param identifier The name of the element type to which the context is associated to.
      * @param lineNumber the line number in the YAMSQL file to which the context is associated to.
      *
      * @return wrapped {@link YamlExecutionError}
      */
     @Nonnull
-    public YamlExecutionError wrapContext(@Nullable Throwable e, @Nonnull Supplier<String> msg, @Nonnull String identifier, int lineNumber) {
+    public RuntimeException wrapContext(@Nonnull Throwable throwable, @Nonnull Supplier<String> msg, @Nonnull String identifier, int lineNumber) {
         String fileName;
         if (resourcePath.contains("/")) {
             final String[] split = resourcePath.split("/");
             fileName = split[split.length - 1];
         } else {
             fileName = resourcePath;
         }
-        if (e instanceof YamlExecutionError) {
-            final var oldStackTrace = e.getStackTrace();
+
+        if (throwable instanceof TestAbortedException) {
+            return (TestAbortedException)throwable;
+        } else if (throwable instanceof YamlExecutionError) {
+            final var oldStackTrace = throwable.getStackTrace();
             final var newStackTrace = new StackTraceElement[oldStackTrace.length + 1];
             System.arraycopy(oldStackTrace, 0, newStackTrace, 0, oldStackTrace.length);
             newStackTrace[oldStackTrace.length] = new StackTraceElement("YAML_FILE", identifier, fileName, lineNumber);
-            e.setStackTrace(newStackTrace);
-            return (YamlExecutionError) e;
+            throwable.setStackTrace(newStackTrace);
+            return (YamlExecutionError)throwable;
         } else {
             // wrap
-            final var wrapper = new YamlExecutionError(msg.get(), e);
+            final var wrapper = new YamlExecutionError(msg.get(), throwable);
             wrapper.setStackTrace(new StackTraceElement[]{new StackTraceElement("YAML_FILE", identifier, fileName, lineNumber)});
             return wrapper;
         }