From 8e73232102d6275b4f13de9d089d3a9b224c9727 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <abe@aber.io>
Date: Thu, 18 Jan 2024 14:20:44 -0500
Subject: [PATCH 001/126] CASSANDRA-19180: Support reloading keystore in
 cassandra-java-driver

---
 .../api/core/config/DefaultDriverOption.java  |   6 +
 .../api/core/config/TypedDriverOption.java    |   6 +
 .../core/ssl/DefaultSslEngineFactory.java     |  35 ++-
 .../core/ssl/ReloadingKeyManagerFactory.java  | 257 +++++++++++++++++
 core/src/main/resources/reference.conf        |   7 +
 .../ssl/ReloadingKeyManagerFactoryTest.java   | 272 ++++++++++++++++++
 .../ReloadingKeyManagerFactoryTest/README.md  |  39 +++
 .../certs/client-alternate.keystore           | Bin 0 -> 2467 bytes
 .../certs/client-original.keystore            | Bin 0 -> 2457 bytes
 .../certs/client.truststore                   | Bin 0 -> 1002 bytes
 .../certs/server.keystore                     | Bin 0 -> 2407 bytes
 .../certs/server.truststore                   | Bin 0 -> 1890 bytes
 manual/core/ssl/README.md                     |  10 +-
 upgrade_guide/README.md                       |  11 +
 14 files changed, 627 insertions(+), 16 deletions(-)
 create mode 100644 core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactoryTest.java
 create mode 100644 core/src/test/resources/ReloadingKeyManagerFactoryTest/README.md
 create mode 100644 core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client-alternate.keystore
 create mode 100644 core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client-original.keystore
 create mode 100644 core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client.truststore
 create mode 100644 core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/server.keystore
 create mode 100644 core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/server.truststore

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
index 4c0668570b2..c10a8237c43 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
@@ -255,6 +255,12 @@ public enum DefaultDriverOption implements DriverOption {
    * <p>Value-type: {@link String}
    */
   SSL_KEYSTORE_PASSWORD("advanced.ssl-engine-factory.keystore-password"),
+  /**
+   * The duration between attempts to reload the keystore.
+   *
+   * <p>Value-type: {@link java.time.Duration}
+   */
+  SSL_KEYSTORE_RELOAD_INTERVAL("advanced.ssl-engine-factory.keystore-reload-interval"),
   /**
    * The location of the truststore file.
    *
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
index ec36079730f..88c012fa351 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
@@ -235,6 +235,12 @@ public String toString() {
   /** The keystore password. */
   public static final TypedDriverOption<String> SSL_KEYSTORE_PASSWORD =
       new TypedDriverOption<>(DefaultDriverOption.SSL_KEYSTORE_PASSWORD, GenericType.STRING);
+
+  /** The duration between attempts to reload the keystore. */
+  public static final TypedDriverOption<Duration> SSL_KEYSTORE_RELOAD_INTERVAL =
+      new TypedDriverOption<>(
+          DefaultDriverOption.SSL_KEYSTORE_RELOAD_INTERVAL, GenericType.DURATION);
+
   /** The location of the truststore file. */
   public static final TypedDriverOption<String> SSL_TRUSTSTORE_PATH =
       new TypedDriverOption<>(DefaultDriverOption.SSL_TRUSTSTORE_PATH, GenericType.STRING);
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
index 085b36dc539..55a6e9c7da8 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
@@ -27,11 +27,12 @@
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.security.KeyStore;
 import java.security.SecureRandom;
+import java.time.Duration;
 import java.util.List;
-import javax.net.ssl.KeyManagerFactory;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLEngine;
 import javax.net.ssl.SSLParameters;
@@ -54,6 +55,7 @@
  *     truststore-password = password123
  *     keystore-path = /path/to/client.keystore
  *     keystore-password = password123
+ *     keystore-reload-interval = 30 minutes
  *   }
  * }
  * </pre>
@@ -66,6 +68,7 @@ public class DefaultSslEngineFactory implements SslEngineFactory {
   private final SSLContext sslContext;
   private final String[] cipherSuites;
   private final boolean requireHostnameValidation;
+  private ReloadingKeyManagerFactory kmf;
 
   /** Builds a new instance from the driver configuration. */
   public DefaultSslEngineFactory(DriverContext driverContext) {
@@ -132,20 +135,8 @@ protected SSLContext buildContext(DriverExecutionProfile config) throws Exceptio
       }
 
       // initialize keystore if configured.
-      KeyManagerFactory kmf = null;
       if (config.isDefined(DefaultDriverOption.SSL_KEYSTORE_PATH)) {
-        try (InputStream ksf =
-            Files.newInputStream(
-                Paths.get(config.getString(DefaultDriverOption.SSL_KEYSTORE_PATH)))) {
-          KeyStore ks = KeyStore.getInstance("JKS");
-          char[] password =
-              config.isDefined(DefaultDriverOption.SSL_KEYSTORE_PASSWORD)
-                  ? config.getString(DefaultDriverOption.SSL_KEYSTORE_PASSWORD).toCharArray()
-                  : null;
-          ks.load(ksf, password);
-          kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
-          kmf.init(ks, password);
-        }
+        kmf = buildReloadingKeyManagerFactory(config);
       }
 
       context.init(
@@ -159,8 +150,22 @@ protected SSLContext buildContext(DriverExecutionProfile config) throws Exceptio
     }
   }
 
+  private ReloadingKeyManagerFactory buildReloadingKeyManagerFactory(
+      DriverExecutionProfile config) {
+    Path keystorePath = Paths.get(config.getString(DefaultDriverOption.SSL_KEYSTORE_PATH));
+    String password =
+        config.isDefined(DefaultDriverOption.SSL_KEYSTORE_PASSWORD)
+            ? config.getString(DefaultDriverOption.SSL_KEYSTORE_PASSWORD)
+            : null;
+    Duration reloadInterval =
+        config.isDefined(DefaultDriverOption.SSL_KEYSTORE_RELOAD_INTERVAL)
+            ? config.getDuration(DefaultDriverOption.SSL_KEYSTORE_RELOAD_INTERVAL)
+            : Duration.ZERO;
+    return ReloadingKeyManagerFactory.create(keystorePath, password, reloadInterval);
+  }
+
   @Override
   public void close() throws Exception {
-    // nothing to do
+    kmf.close();
   }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
new file mode 100644
index 00000000000..9aaee701114
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
@@ -0,0 +1,257 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.ssl;
+
+import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.Socket;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.Principal;
+import java.security.PrivateKey;
+import java.security.Provider;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.KeyManagerFactorySpi;
+import javax.net.ssl.ManagerFactoryParameters;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.X509ExtendedKeyManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ReloadingKeyManagerFactory extends KeyManagerFactory implements AutoCloseable {
+  private static final Logger logger = LoggerFactory.getLogger(ReloadingKeyManagerFactory.class);
+  private static final String KEYSTORE_TYPE = "JKS";
+  private Path keystorePath;
+  private String keystorePassword;
+  private ScheduledExecutorService executor;
+  private final Spi spi;
+
+  // We're using a single thread executor so this shouldn't need to be volatile, since all updates
+  // to lastDigest should come from the same thread
+  private volatile byte[] lastDigest;
+
+  /**
+   * Create a new {@link ReloadingKeyManagerFactory} with the given keystore file and password,
+   * reloading from the file's content at the given interval. This function will do an initial
+   * reload before returning, to confirm that the file exists and is readable.
+   *
+   * @param keystorePath the keystore file to reload
+   * @param keystorePassword the keystore password
+   * @param reloadInterval the duration between reload attempts. Set to {@link
+   *     java.time.Duration#ZERO} to disable scheduled reloading.
+   * @return
+   */
+  public static ReloadingKeyManagerFactory create(
+      Path keystorePath, String keystorePassword, Duration reloadInterval) {
+    KeyManagerFactory kmf;
+    try {
+      kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+    } catch (NoSuchAlgorithmException e) {
+      throw new RuntimeException(e);
+    }
+
+    KeyStore ks;
+    try (InputStream ksf = Files.newInputStream(keystorePath)) {
+      ks = KeyStore.getInstance(KEYSTORE_TYPE);
+      ks.load(ksf, keystorePassword.toCharArray());
+    } catch (IOException | CertificateException | KeyStoreException | NoSuchAlgorithmException e) {
+      throw new RuntimeException(e);
+    }
+    try {
+      kmf.init(ks, keystorePassword.toCharArray());
+    } catch (KeyStoreException | NoSuchAlgorithmException | UnrecoverableKeyException e) {
+      throw new RuntimeException(e);
+    }
+
+    ReloadingKeyManagerFactory reloadingKeyManagerFactory = new ReloadingKeyManagerFactory(kmf);
+    reloadingKeyManagerFactory.start(keystorePath, keystorePassword, reloadInterval);
+    return reloadingKeyManagerFactory;
+  }
+
+  @VisibleForTesting
+  protected ReloadingKeyManagerFactory(KeyManagerFactory initial) {
+    this(
+        new Spi((X509ExtendedKeyManager) initial.getKeyManagers()[0]),
+        initial.getProvider(),
+        initial.getAlgorithm());
+  }
+
+  private ReloadingKeyManagerFactory(Spi spi, Provider provider, String algorithm) {
+    super(spi, provider, algorithm);
+    this.spi = spi;
+  }
+
+  private void start(Path keystorePath, String keystorePassword, Duration reloadInterval) {
+    this.keystorePath = keystorePath;
+    this.keystorePassword = keystorePassword;
+    this.executor =
+        Executors.newScheduledThreadPool(
+            1,
+            runnable -> {
+              Thread t = Executors.defaultThreadFactory().newThread(runnable);
+              t.setDaemon(true);
+              return t;
+            });
+
+    // Ensure that reload is called once synchronously, to make sure the file exists etc.
+    reload();
+
+    if (!reloadInterval.isZero())
+      this.executor.scheduleWithFixedDelay(
+          this::reload,
+          reloadInterval.toMillis(),
+          reloadInterval.toMillis(),
+          TimeUnit.MILLISECONDS);
+  }
+
+  @VisibleForTesting
+  void reload() {
+    try {
+      reload0();
+    } catch (Exception e) {
+      logger.warn("Failed to reload", e);
+    }
+  }
+
+  private synchronized void reload0()
+      throws NoSuchAlgorithmException, IOException, KeyStoreException, CertificateException,
+          UnrecoverableKeyException {
+    logger.debug("Checking KeyStore file {} for updates", keystorePath);
+
+    final byte[] keyStoreBytes = Files.readAllBytes(keystorePath);
+    final byte[] newDigest = digest(keyStoreBytes);
+    if (lastDigest != null && Arrays.equals(lastDigest, digest(keyStoreBytes))) {
+      logger.debug("KeyStore file content has not changed; skipping update");
+      return;
+    }
+
+    final KeyStore keyStore = KeyStore.getInstance(KEYSTORE_TYPE);
+    try (InputStream inputStream = new ByteArrayInputStream(keyStoreBytes)) {
+      keyStore.load(inputStream, keystorePassword.toCharArray());
+    }
+    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+    kmf.init(keyStore, keystorePassword.toCharArray());
+    logger.info("Detected updates to KeyStore file {}", keystorePath);
+
+    this.spi.keyManager.set((X509ExtendedKeyManager) kmf.getKeyManagers()[0]);
+    this.lastDigest = newDigest;
+  }
+
+  @Override
+  public void close() throws Exception {
+    if (executor != null) {
+      executor.shutdown();
+    }
+  }
+
+  private static byte[] digest(byte[] payload) throws NoSuchAlgorithmException {
+    final MessageDigest digest = MessageDigest.getInstance("SHA-256");
+    return digest.digest(payload);
+  }
+
+  private static class Spi extends KeyManagerFactorySpi {
+    DelegatingKeyManager keyManager;
+
+    Spi(X509ExtendedKeyManager initial) {
+      this.keyManager = new DelegatingKeyManager(initial);
+    }
+
+    @Override
+    protected void engineInit(KeyStore ks, char[] password) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    protected void engineInit(ManagerFactoryParameters spec) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    protected KeyManager[] engineGetKeyManagers() {
+      return new KeyManager[] {keyManager};
+    }
+  }
+
+  private static class DelegatingKeyManager extends X509ExtendedKeyManager {
+    AtomicReference<X509ExtendedKeyManager> delegate;
+
+    DelegatingKeyManager(X509ExtendedKeyManager initial) {
+      delegate = new AtomicReference<>(initial);
+    }
+
+    void set(X509ExtendedKeyManager keyManager) {
+      delegate.set(keyManager);
+    }
+
+    @Override
+    public String chooseEngineClientAlias(String[] keyType, Principal[] issuers, SSLEngine engine) {
+      return delegate.get().chooseEngineClientAlias(keyType, issuers, engine);
+    }
+
+    @Override
+    public String chooseEngineServerAlias(String keyType, Principal[] issuers, SSLEngine engine) {
+      return delegate.get().chooseEngineServerAlias(keyType, issuers, engine);
+    }
+
+    @Override
+    public String[] getClientAliases(String keyType, Principal[] issuers) {
+      return delegate.get().getClientAliases(keyType, issuers);
+    }
+
+    @Override
+    public String chooseClientAlias(String[] keyType, Principal[] issuers, Socket socket) {
+      return delegate.get().chooseClientAlias(keyType, issuers, socket);
+    }
+
+    @Override
+    public String[] getServerAliases(String keyType, Principal[] issuers) {
+      return delegate.get().getServerAliases(keyType, issuers);
+    }
+
+    @Override
+    public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
+      return delegate.get().chooseServerAlias(keyType, issuers, socket);
+    }
+
+    @Override
+    public X509Certificate[] getCertificateChain(String alias) {
+      return delegate.get().getCertificateChain(alias);
+    }
+
+    @Override
+    public PrivateKey getPrivateKey(String alias) {
+      return delegate.get().getPrivateKey(alias);
+    }
+  }
+}
diff --git a/core/src/main/resources/reference.conf b/core/src/main/resources/reference.conf
index 75bed97e498..d1ac22e553b 100644
--- a/core/src/main/resources/reference.conf
+++ b/core/src/main/resources/reference.conf
@@ -790,6 +790,13 @@ datastax-java-driver {
     // truststore-password = password123
     // keystore-path = /path/to/client.keystore
     // keystore-password = password123
+
+    # The duration between attempts to reload the keystore from the contents of the file specified
+    # by `keystore-path`. This is mainly relevant in environments where certificates have short
+    # lifetimes and applications are restarted infrequently, since an expired client certificate
+    # will prevent new connections from being established until the application is restarted. If
+    # not set, defaults to not reload the keystore.
+    // keystore-reload-interval = 30 minutes
   }
 
   # The generator that assigns a microsecond timestamp to each request.
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactoryTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactoryTest.java
new file mode 100644
index 00000000000..d291924b800
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactoryTest.java
@@ -0,0 +1,272 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.ssl;
+
+import static java.nio.file.StandardCopyOption.COPY_ATTRIBUTES;
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.math.BigInteger;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.SocketException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.X509Certificate;
+import java.time.Duration;
+import java.util.Optional;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.TrustManagerFactory;
+import org.junit.Assert;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ReloadingKeyManagerFactoryTest {
+  private static final Logger logger =
+      LoggerFactory.getLogger(ReloadingKeyManagerFactoryTest.class);
+
+  static final Path CERT_BASE =
+      Paths.get(
+          ReloadingKeyManagerFactoryTest.class
+              .getResource(
+                  String.format("/%s/certs/", ReloadingKeyManagerFactoryTest.class.getSimpleName()))
+              .getPath());
+  static final Path SERVER_KEYSTORE_PATH = CERT_BASE.resolve("server.keystore");
+  static final Path SERVER_TRUSTSTORE_PATH = CERT_BASE.resolve("server.truststore");
+
+  static final Path ORIGINAL_CLIENT_KEYSTORE_PATH = CERT_BASE.resolve("client-original.keystore");
+  static final Path ALTERNATE_CLIENT_KEYSTORE_PATH = CERT_BASE.resolve("client-alternate.keystore");
+  static final BigInteger ORIGINAL_CLIENT_KEYSTORE_CERT_SERIAL =
+      convertSerial("7372a966"); // 1936894310
+  static final BigInteger ALTERNATE_CLIENT_KEYSTORE_CERT_SERIAL =
+      convertSerial("e50bf31"); // 240172849
+
+  // File at this path will change content
+  static final Path TMP_CLIENT_KEYSTORE_PATH;
+
+  static {
+    try {
+      TMP_CLIENT_KEYSTORE_PATH =
+          Files.createTempFile(ReloadingKeyManagerFactoryTest.class.getSimpleName(), null);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  static final Path CLIENT_TRUSTSTORE_PATH = CERT_BASE.resolve("client.truststore");
+  static final String CERTSTORE_PASSWORD = "changeit";
+  static final Duration NO_SCHEDULED_RELOAD = Duration.ofMillis(0);
+
+  private static TrustManagerFactory buildTrustManagerFactory() {
+    TrustManagerFactory tmf;
+    try (InputStream tsf = Files.newInputStream(CLIENT_TRUSTSTORE_PATH)) {
+      KeyStore ts = KeyStore.getInstance("JKS");
+      char[] password = CERTSTORE_PASSWORD.toCharArray();
+      ts.load(tsf, password);
+      tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+      tmf.init(ts);
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+    return tmf;
+  }
+
+  private static SSLContext buildServerSslContext() {
+    try {
+      SSLContext context = SSLContext.getInstance("SSL");
+
+      TrustManagerFactory tmf;
+      try (InputStream tsf = Files.newInputStream(SERVER_TRUSTSTORE_PATH)) {
+        KeyStore ts = KeyStore.getInstance("JKS");
+        char[] password = CERTSTORE_PASSWORD.toCharArray();
+        ts.load(tsf, password);
+        tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+        tmf.init(ts);
+      }
+
+      KeyManagerFactory kmf;
+      try (InputStream ksf = Files.newInputStream(SERVER_KEYSTORE_PATH)) {
+        KeyStore ks = KeyStore.getInstance("JKS");
+        char[] password = CERTSTORE_PASSWORD.toCharArray();
+        ks.load(ksf, password);
+        kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+        kmf.init(ks, password);
+      }
+
+      context.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());
+      return context;
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Test
+  public void client_certificates_should_reload() throws Exception {
+    Files.copy(
+        ORIGINAL_CLIENT_KEYSTORE_PATH, TMP_CLIENT_KEYSTORE_PATH, REPLACE_EXISTING, COPY_ATTRIBUTES);
+
+    final BlockingQueue<Optional<X509Certificate[]>> peerCertificates =
+        new LinkedBlockingQueue<>(1);
+
+    // Create a listening socket. Make sure there's no backlog so each accept is in order.
+    SSLContext serverSslContext = buildServerSslContext();
+    final SSLServerSocket server =
+        (SSLServerSocket) serverSslContext.getServerSocketFactory().createServerSocket();
+    server.bind(new InetSocketAddress(0), 1);
+    server.setUseClientMode(false);
+    server.setNeedClientAuth(true);
+    Thread serverThread =
+        new Thread(
+            () -> {
+              while (true) {
+                try {
+                  logger.info("Server accepting client");
+                  final SSLSocket conn = (SSLSocket) server.accept();
+                  logger.info("Server accepted client {}", conn);
+                  conn.addHandshakeCompletedListener(
+                      event -> {
+                        boolean offer;
+                        try {
+                          // Transfer certificates to client thread once handshake is complete, so
+                          // it can safely close
+                          // the socket
+                          offer =
+                              peerCertificates.offer(
+                                  Optional.of((X509Certificate[]) event.getPeerCertificates()));
+                        } catch (SSLPeerUnverifiedException e) {
+                          offer = peerCertificates.offer(Optional.empty());
+                        }
+                        Assert.assertTrue(offer);
+                      });
+                  logger.info("Server starting handshake");
+                  // Without this, client handshake blocks
+                  conn.startHandshake();
+                } catch (IOException e) {
+                  // Not sure why I sometimes see ~thousands of these locally
+                  if (e instanceof SocketException && e.getMessage().contains("Socket closed"))
+                    return;
+                  logger.info("Server accept error", e);
+                }
+              }
+            });
+    serverThread.setName(String.format("%s-serverThread", this.getClass().getSimpleName()));
+    serverThread.setDaemon(true);
+    serverThread.start();
+
+    final ReloadingKeyManagerFactory kmf =
+        ReloadingKeyManagerFactory.create(
+            TMP_CLIENT_KEYSTORE_PATH, CERTSTORE_PASSWORD, NO_SCHEDULED_RELOAD);
+    // Need a tmf that tells the server to send its certs
+    final TrustManagerFactory tmf = buildTrustManagerFactory();
+
+    // Check original client certificate
+    testClientCertificates(
+        kmf,
+        tmf,
+        server.getLocalSocketAddress(),
+        () -> {
+          try {
+            return peerCertificates.poll(10, TimeUnit.SECONDS);
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+        },
+        certs -> {
+          Assert.assertEquals(1, certs.length);
+          X509Certificate cert = certs[0];
+          Assert.assertEquals(ORIGINAL_CLIENT_KEYSTORE_CERT_SERIAL, cert.getSerialNumber());
+        });
+
+    // Update keystore content
+    logger.info("Updating keystore file with new content");
+    Files.copy(
+        ALTERNATE_CLIENT_KEYSTORE_PATH,
+        TMP_CLIENT_KEYSTORE_PATH,
+        REPLACE_EXISTING,
+        COPY_ATTRIBUTES);
+    kmf.reload();
+
+    // Check that alternate client certificate was applied
+    testClientCertificates(
+        kmf,
+        tmf,
+        server.getLocalSocketAddress(),
+        () -> {
+          try {
+            return peerCertificates.poll(30, TimeUnit.SECONDS);
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+        },
+        certs -> {
+          Assert.assertEquals(1, certs.length);
+          X509Certificate cert = certs[0];
+          Assert.assertEquals(ALTERNATE_CLIENT_KEYSTORE_CERT_SERIAL, cert.getSerialNumber());
+        });
+
+    kmf.close();
+    server.close();
+  }
+
+  private static void testClientCertificates(
+      KeyManagerFactory kmf,
+      TrustManagerFactory tmf,
+      SocketAddress serverAddress,
+      Supplier<Optional<X509Certificate[]>> certsSupplier,
+      Consumer<X509Certificate[]> certsConsumer)
+      throws NoSuchAlgorithmException, KeyManagementException, IOException {
+    SSLContext clientSslContext = SSLContext.getInstance("TLS");
+    clientSslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
+    final SSLSocket client = (SSLSocket) clientSslContext.getSocketFactory().createSocket();
+    logger.info("Client connecting");
+    client.connect(serverAddress);
+    logger.info("Client doing handshake");
+    client.startHandshake();
+
+    final Optional<X509Certificate[]> lastCertificate = certsSupplier.get();
+    logger.info("Client got its certificate back from the server; closing socket");
+    client.close();
+    Assert.assertNotNull(lastCertificate);
+    Assert.assertTrue(lastCertificate.isPresent());
+    logger.info("Client got its certificate back from server: {}", lastCertificate);
+
+    certsConsumer.accept(lastCertificate.get());
+  }
+
+  private static BigInteger convertSerial(String hex) {
+    final BigInteger serial = new BigInteger(Integer.valueOf(hex, 16).toString());
+    logger.info("Serial hex {} is {}", hex, serial);
+    return serial;
+  }
+}
diff --git a/core/src/test/resources/ReloadingKeyManagerFactoryTest/README.md b/core/src/test/resources/ReloadingKeyManagerFactoryTest/README.md
new file mode 100644
index 00000000000..9ff9b622e5b
--- /dev/null
+++ b/core/src/test/resources/ReloadingKeyManagerFactoryTest/README.md
@@ -0,0 +1,39 @@
+# How to create cert stores for ReloadingKeyManagerFactoryTest
+
+Need the following cert stores:
+- `server.keystore`
+- `client-original.keystore`
+- `client-alternate.keystore`
+- `server.truststore`: trusts `client-original.keystore` and `client-alternate.keystore`
+- `client.truststore`: trusts `server.keystore`
+
+We shouldn't need any signing requests or chains of trust, since truststores are just including certs directly.
+
+First create the three keystores:
+```
+$ keytool -genkeypair -keyalg RSA -alias server -keystore server.keystore -dname "CN=server" -storepass changeit -keypass changeit
+$ keytool -genkeypair -keyalg RSA -alias client-original -keystore client-original.keystore -dname "CN=client-original" -storepass changeit -keypass changeit
+$ keytool -genkeypair -keyalg RSA -alias client-alternate -keystore client-alternate.keystore -dname "CN=client-alternate" -storepass changeit -keypass changeit
+```
+
+Note that we need to use `-keyalg RSA` because keytool's default keyalg is DSA, which TLS 1.3 doesn't support. If DSA is
+used, the handshake will fail due to the server not being able to find any authentication schemes compatible with its
+x509 certificate ("Unavailable authentication scheme").
+
+Then export all the certs:
+```
+$ keytool -exportcert -keystore server.keystore -alias server -file server.cert -storepass changeit
+$ keytool -exportcert -keystore client-original.keystore -alias client-original -file client-original.cert -storepass changeit
+$ keytool -exportcert -keystore client-alternate.keystore -alias client-alternate -file client-alternate.cert -storepass changeit
+```
+
+Then create the server.truststore that trusts the two client certs:
+```
+$ keytool -import -file client-original.cert -alias client-original -keystore server.truststore -storepass changeit
+$ keytool -import -file client-alternate.cert -alias client-alternate -keystore server.truststore -storepass changeit
+```
+
+Then create the client.truststore that trusts the server cert:
+```
+$ keytool -import -file server.cert -alias server -keystore client.truststore -storepass changeit
+```
diff --git a/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client-alternate.keystore b/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client-alternate.keystore
new file mode 100644
index 0000000000000000000000000000000000000000..91cee636a0baab4d6e8b706c76da6bffd8398f37
GIT binary patch
literal 2467
zcmY+Ec|6pK8^>qN3{8_AWE>&JwIR$TN$z_vtXZ)}Nu%63a;C=hbw!RwWSlc{Ws$S6
z?)zw#9248H$k9kO3L)WVf3M$f_qBgKujl!^pXc-Z`N05i8W$LX0pJeYaK(6B{5CI`
z2TTXx=1>4`a)b>q04)4pE0`}7fO#EZx1)05M*Pop;y9R#4nX%X0CXFpz<vDx_~^M9
zRIo))>(_!+E1^f*j_q18d2Sn?o!MLvP>&51fDW$t2UV<xo~Svtw&@IEI1PE(3A^3h
z>lHvQ9<GM>@L9oBPQ8A4sTlWF&YRT3u*E0+WN?r!T&q}?d|KEf^LS?aLVfMGdgs>)
zdDeG(T&lkR>AznZ7kDPQmt{{~r8qf%C@nBTBdgEv+0{x833;>;&$$=wbH;@m?OAE~
z_lZ{Z2Gf{`(y{enkkglPGu5l%9!q(aI-Bm3uj28?q6UKfMha;49c4w0Q<qwUk`nG`
zYM;C;U1}jkSr#*reK3=c$P-YLpTOqE670%p>9~5^aYS^Z!Pz8jD(=dY?@B=e?!tkO
zX2_`>5>KSdKikfskn;0b5OYgJUj4TYn}wNQ#;uD;R6mPpp?iKW+Ub(057Tv|Zgk-I
z3J9ldZ?`==HU=N>@AbZ#^n=n3a8FvRCT(*GlP?42t_}3+@*!0?kW3{#RT|n_O4!S^
z>L<~h3Y7Fb<Q^HM`7ZUmjpXPa+8*xM=k{((;pB?dJFz#Nc{_L6&a2Nmg(0UWL!|1q
zDqkO_5f>>tEyt+&iADmEjvkz!U0ZQYkA?E95)8TgA1L4+x=}7FCAm&06FWsm-dTCS
z3C!o|GYVee4{W~qg1MWrZA4@K>EXH<E4^%^k7#JRmVCt|`I<rs+x|{ztbMU?^qrU8
zFJCw55-+KBOw4#94iIlmdw7~-?+0QfxSV7r5G>qtA>WEB&<ZJomeYvKGbBzF#y937
z<J1Kl`h3FfgtIP&`^Zin^I$fDU4}Bb2_!o*7d-Mw6#b3^7S=oyLF&~Ccq)DY2+K8&
zxtu14moM7O`*lvC<jVCS=AlxIl+;_%$2**7%Ra7E<XGw|e(%QQlHPu;diBpT*}t-x
z?4f2q@WRxoig4hQ!Ve8b=}~sv?Y+%bgj<=fEcFmKHIvAW0mullMz-}0hSRyF(gcLo
zD45}qP5-usZ)LHbzOOJ2@zv<kws)@`ijSOapjrpAYgc~{m_&&U??|N2P<sblLZLIp
zh{EMt%%U|`87rfCQ)!Mxv`LgfMU`o^v;@J_G|>cE6$6N_u=tjD<6>OQ0w6_g-$4|Y
z!ffsmsSo5p{?4Bt47zm`Np^Q^xXa;H92~ULr@mGSmU;sF<(u%R9i%=AR$Lb<$ub?o
zY&h%rr(I+DGdUrkvk-@$2Iq|(?LO2LY)yZW(np&~hmNNA0`*d6p+Rj-^Hz<jCAS>R
zg_Jdhk9x`;7Qv<)$2-&)J0zb%ONU2OGD+It<BsGdtNq(vo`F7~2KJ&Bt*r)jCGWSJ
z=9ERY^)<zDmhGzc1mEF;@~iF|`+_}UZvx7RSKm(1m{I-wQgWirCrLa54JTbAGqqa`
zvNp>Zk7D5v|BXSKlLfcMLD%73N7v`Oun`6UCnKV=c9LPO|A}*qF%!Jp_mF;W|MxHS
zipQrcwGekW>i}(@byZP83q`4x&#6z{ZdiUkr>|~P7r|2`1L_+j%C>Jn_=tSx-<UsK
zGu@YzrjCkKt!5|X#^rj2$TAGS87>>)hdrBZ@0BQ!QhdOOkZ7lt$_E-5icT!0N_Ckw
z^~ByKk!lHAk(x2OxWA7bSZG<M3=56OBHU{W%MMmggr@IHn^>$O-(T1~l;lxNy5fty
zj8XkND&c}y>C;l68=zYtPmn9f7Ze0i29b_b(2)u_(xks84Ei4f3M&W|xa{fUDuva+
zV9#l2T+mRzh|$0Rkk-GCc(~~Rr0NKjbAdre?a4nI@V`=*`>)hR6>_mdop6;eEn6^^
zHXr-C`hTPUH+7=`h=(%PNAIePZRStSje^<Y`}$fY2br6X?4YJ(NsS3lKLl`lS6nl*
zSD>Mw^LgS<=-A-IEiC<XbIknKoM=D-?^Dexe8$C34p97=Q*$Dk6=?$|E;zxrhYKwU
z)(PBQEp=h0d5;oNn;GOfqlP!*)5-;eaRTCrx2CF+o7Jsc)vS7{GM)Pd&k`ym;EF(I
zs$@@!RZ)2;eYV$><@s4vMYmfFK<b|e7Up@u&rMH2@#d#Y{w^YSeVgN3j?4#p6W7@j
z@eihT#^$spvGl0qKl)7PL(qv8BiV^xeA_}cNA%R2E>3*oS6~ISaf^7ZcrrhN`2JM-
zev+3IAaAI6c=`RA;%E2G{6~!i{KkLL9WAmE32ILpGGFdOMWa?IL8(AMXEi@rM-6hx
zD>`)k+ulL#iu~f4frGb=j6%MrS8?{uqK+}D313GOIW@C%5&n5mUY^1!jX_9lwft0M
znYN{V>sdej3C$!yX9YRg5b@WA_c97_^9{27I8tc(AC!|=QDhraIb_oNg!XOADd$gZ
z^nn<mez`$a=caW-1M+Kq2!cHKp1n?4-P^Y8R<(;P$gd)?39DEc-bu}Z4FhYOXePxr
zK($hU&@oat^6mSpX*arPaX%o(0H2Qe*?u=ENFNp<zBQ+*1_l+OlC#d^Z$TGulJW)=
z!0-c+Q+-b8iVVSw&~oF%Sb4;DRA+Jsfr+K49l)zFv6OV>mUV}mNQ;F|9i@!ObA$Zj
z{6!%d5LPC&Mx}atTNGMW*$rKB4jyOe(cFNn4dx0PoU6kx7vOj&?jA?YPp711-D!Q7
zh|~NSX)+%%^MVQPFWGbUn}GcBNlBr-(*y5QGr-BJ*b3b#iqq78CMJw?>$G~`w53;Q
z!gvucIyYy&mP99{bL{FW7KKv<y~CoE-vtftrVTmjiJ5f|lBsch<C{;zu#ac6Uqw{A
z0KOR-=J{2ARl^3?5|R06)<wrg<NWX#3t{omu!@(HIkMFf4hBOWPs47fd-U<;Sd@Z=
zX|BYfAEEP}s66dhs<WbFFD*BPIQv<mAeD|bV~6>K2p+m@3<!O6Zy5e++NHdM1RH!d
zEw6sDD^9Wzzy2eDpO?`^3^myvn?1Xhg&cNo9A1np-weN?CSMtBu9dT$Wn9Cfh0(>J
zF>r2}(hm@>Q!o%zPy~f#DSpsZ)k-d0n@SIhTL{zjhYFs5wZbXUDbZeHHiXN*8`~c?
M&hzAgfaB@^0fMoC8UO$Q

literal 0
HcmV?d00001

diff --git a/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client-original.keystore b/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client-original.keystore
new file mode 100644
index 0000000000000000000000000000000000000000..74e31f7bc6f1ab222cf2c8ac5feb2324d1f01fdf
GIT binary patch
literal 2457
zcmY+EX*d)L7sqGJjAbkr5r&Z^ySZkDJF;uYmUXTrhLFaRZ3x+l24fo)vQr~lVT>)y
zWQ&`mOEHm%L`4}(l##9LeV_Ne_qiX=bI$qw&pBVt^Zbz{o;(g92ub3x<>XN%TaelO
zKrSGa#A5^|@#r04Z6pa2_b&+&1SUcJkMPB#@Z#kC-xePf$U!B6_mCto8>zwx{XafB
zE(sQiJyu#?hE}x;Zt9+oJV^9#!tTg%fB*ybU=nyJt|{279;mNR@WY$Nh1VBYwZB4q
z)vNJTDLf5-5?yZU2}#LPa#)km>Pc1rx4Fm9NHzb_yre-&<^B}C;D5^Yl5Oq<JEQQ6
zORtg_XFP_w(`OfMQ()+%mJg%x!GgJghMxCiDec)6=&9BeC5`jg;~93$&h<Stnp@Mn
ziSh(%S!V93op~xdtM8oW0JYP2Bkdz%u!IGL`_7*XwfqFUnK%c=%m5=Oz4ooo(Svm+
zSR+s<-P$P`;Sen)uz^b`5`kSpMW7zssF3VjPhU6b*+HjOKg(poOp`7wPoAE$FDW*Z
z1{+C=l5?qFCIr2rAMFkc*1PX)by}=E8c|@u=7_^d7i!ETZ`ez=E`Q|e3`e<t{!H|>
zPg~(r7!&;^XWpmjpgiWfW(V$CjpbUUlk-$cL#X&Hxvx?j@i8DSHii38c~1BD5H+fY
z$#CO10`N#1T1?6CRz53eU-97eLR-2UKnVZcpEHlkd^y@pvbq8mc3|VwKU&5cW^=nf
zBF?RleCf9ynn00_^XA+$`l__nr4mS%qDPF^t_wQQfKx1>VpqUJF0(&}>B|+nr(@}P
zkGWqs8Cn%x)JGq_66|=c(z$fOT%fBaIKM@Nk`00)-;N~dFdTLB!i9L>MAnJ>uY}Z1
z433YD(CH=HcJKJ~Pwm)f8%xvgiiZC=FoluLch{+!{P?2Lv?fElEfLkIa7C+pv$mb%
z@z!w-28P1q*KySfEztD!%4%YfR}yN1V)x%WLSN<r#SH7H5SL?&xnYM0J$6Gj{mEBy
zRLnSB&){D77qm!Es<pCt(Ax4F9?jtsK~#qjXE>`UqhMw}Q|?BXOKmNyVK1vx=6?KO
zgOj@1oZiK^(o`!_2j3#w&+&=k>o?r0hfu+^%fdPhQI&jz=q=p^Wr0eyU7OOPqyJ$-
zM#4_uy5v_cE3Z!x4Qj!DU3V2!i(Xz68S$z{M+!>dp)G6)rwqy070Zo11Uq6*tr7EW
zWR|y&Q%Zli7`OhJ<2@x&qfTEaA(E^2HYX}pfb(qi&1!~k@57b1D~-2yIe$_g%M*?(
zrB>}r+?399xdSFxtXg^R{z3>oLGrHu{d)C|Bes)&hubYkTQLzeSgCgZOz6l}d7F+Z
z!LtNs`p@K-H`*%lv10>=FmEG;zzI{w`;RCm?W)F}PitE2ZZ{dE*~o&jgVJY0YKED+
z@xW5|C<B<Y%jX!t#)|FY1KQJpR;Vyh>n?PDBh%U{`Kc;*F8%>qyG93+&b66)P$c_`
z0RJHz`=Q_A-Z>@tl$)y(x6wpXiWeliYbibQ{0)y^qlmN<`1Pc|_fjekY$o6mE}-p^
zAZxiSv4FnKU`^O<vsGOw!StR4Y-!b%o&0{;isC-A^cUUweTVmpXZ-<V5pO-^oh8~O
z_W0HQn4D?ak9THF@3{)mzMHnLetoGN8Clx#XuU=l7%y(#P}f4?v;dNc)5n~JZ5Qh9
zQ;^js;Wg7Hh1Tag*1y8g%QX(PrW`GF(8G@=bPvH*?;!4B*b@vQCvRBazIk)hwd0`p
zT@)i$plZ+N`eGrPt6;#8KP74G+b^bUHycQM`prz{9}beq@B`Urd*Ae0MP|Wg2Vxi2
zfkJ8I1Pv4piTK+pc|=e$($WAQKoB4RKmddQA^-?LC?Nc(^E-+VfHxorDf`d3C`tq@
z>=+PCkU?o9QD|*#3`Se?s3d_}{~qGvq>?~YN2r_w2slc`|0uwJc`oOFJl8HAW>o$`
zgK;g8Bdyr;+9x4${m_3sH<1MLN-hjgO5KX57hO|!v3B~XmRZ(trMsy?$KPclb+$C(
z(AAMn%Oa|6iTs8t=zol}O#7yI{?Ecq9+f7y4cz^{>&y@-f(lDYFUAL&<>aQ^;NQGy
zl3q=%I*sa5R|dKzSjs}GDc$^P?+$JaFlQ7;jlG9L^tg`QI_T(4SsDSC<?q-kEU!(&
zF`$l;TTHp^u-L`H@k%${LLMm^UCi3eqM2W(oTCCa`rSisJ9VEeF8Nkv<z}&AJ;LTs
z^%vh9`=2j8wRma4k~`#)dZR)A`Rf$~I|3c%Um;)D(yL?=KG0kVU5Wt>7>u!@Jz=Ms
zKXFEqzLw;V3xB3m<AlnaSd1Ul9kW+`v97lm7*Qhr8K@v}A#L$=gyL5(m5r#T0Kc07
z=510NmNR&z>kSj3WIL$)?6P{oewGD%`ubkdnG70>%0awbH>x8w;tMlC7*y4tK2Q)9
z4a^XDn8=OtR*ZPo=5YA)VJ)tQmNr?d0$&oPu}Z`QbzP>&0ljdDsH`z|CV<#xum8o*
zXL@=pJ_e&gSJmNP2Z1-)f~#XrBF-t#`n2p9$2X>|sx$B-beQ!yLt09BZp+E8)bOx1
z+~xL*hR>UY<aPq_W~q0uhFd;F<G9DkLtcXoozjcHfiTfCoxacc56dR5B2!R=AG2}E
zjTbT|WoA(mz1jP2zv8TNwX@_(?bh~I(-ipatlI3W$~FbfIVwxuRR+fouavP$)tjza
z+VaiS!v}2X25>-&hFWU1$r!e#BN{)wXY|8sTWfDmDlw-3>o@5sNmMc7dcsx8sJJW6
z*@3gxIQagW(SP~%VxT<4U>93(d&m4qFEc(PKs)XPaeVX5h2A@?{`W(J1mjqQK=z7U
z;bi(@U5(jQ3hx@e{e5WpB2k8skUaHJ45@Ei83^sfao*da`6w{eqm^D*b~7<{1CzJZ
z^LRhp(I=mIVPtOPx7}m;MU|s=nOEwprlp4+Upo&N54AX7+`3+u?>MElT@{^o*-g3X
z;;#44#N#pvqFJOJbWc~bI-uX*{kc^<&EmnSLv}^p6@f%OhYyVo=#`wzcdnS!M%P({
zX8)aSUfcQF#i0Z$R)%ZS;`PgN`_@Mnx%lhC5$9gjpUmhV=L_g#VCt1Jz`7;puYN-s
zB4v?0oDeku5C;qb0E>kFtX=4tCoCI=<L62U*`6(lMde5IcD}YaWWOl<xY+<UJaf_c
MoxKkS2uP;>1qcLsrT_o{

literal 0
HcmV?d00001

diff --git a/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client.truststore b/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/client.truststore
new file mode 100644
index 0000000000000000000000000000000000000000..3ce9a720dbc7557774ebbfbae2975235cfc52e46
GIT binary patch
literal 1002
zcmV<G0~P!*f&=CP0Ru3C1D^&7Duzgg_YDCD0ic2dkOYDQj4*-&h%kZ!ga!#JhDe6@
z4FLxRpn?N+FoFYd0s#Opf&*#>2`Yw2hW8Bt2LUiC1_~;MNQU<f0So~KFdGCEj>V75
z8*8{D>rwp3j1%KTjZuVQ0s{cUP=JC1FrCLfv|Un~ufMqg!U2hEV#UbjV}nkvFlQfT
zws%zX^-+$Sav!Xsm&~zLgw(N++mklJptmni0Rd*-42bRCxb#@tBkj1vJL2}Aa=vBC
zPMQtbU(SfTvZUg5FrGs^!)BInqQn-V3mMPE>}8wYgV%;IL=Doa$bq*zeba|fhmr)?
z{WT@X3G>&d^g3rY(d5aI5(f{}<3lUb2H{J3blG0qi^|N$X^v_Z2pUJvE)*qjm_z<C
z68P!n7^z7V>?h$x`Hv=I<Um-&9h{n1^)a-{nRI6ijq^8H!8pEE626w{JjM<iqy_a2
z2Vn~-$J6kiXLgiy{B|0j`BAdz2FdcXcyC9hlZHg!W$<bOY%3jxgrpUw5}4K%JQ2qG
z<D@W&c5OHYpA^>ZIyBR9UJF?_KKH53{`;22J8C$gMyNS`7;2EE>X%=a@JIp|6v;!T
zY;ymI?&;~1Z#4z=p%*1c$Bdb*6=c!+<BxsNn~3LTQPYM3MH&t;2HZTif!m-SMXZ44
zjQ=NdAfWtWTXgHog**BmB-TVJC}yq52I6Rtzd^2gJ5Bx(k0=eCZfmsNHwrycF{RmA
zN&~z=omL{44%;fZ&Y6@0w=I${3cE7|`*L9RaoLO&pHdLUSGUkVq=>anhyT~Bbzz0m
z_T}hw@W2;-Z>~!h?<)CRno)GNEK^>E<1jMm(BoHpZX}YC63Rf<SeUkkz0}AY^dmdc
zQmA{|_2%~YdRQQR!8`9fFeN9<zdFmF9F;Gr`BgltdjD_!UwXCK{t=_m=D;PFE_+gz
zm2|4x-L3K^e)7U1YZ9bcm!NL?=cXBYy)8aFq-3f%=o$&kJR+FjvOfTvV0r^{jVY!j
zl^<9F8}uCiOIgCvUD33<vB2Nu_O!F=IqwQs!CY^@UOQGq(^dFq#g<-Yje9-@hK7WK
z8r;Nd=0LOt0%Kz7lD$QN`#ifVd;}QKqO4OBVsBokxS!X`hIuv5mvmA4`vIy`N2(p}
zEk@r^hrA^3Gg&cks)=9pO8Uz;IB=AQ+c9U8QO^GHs~fB<Zyy0@5xa}sY=YIT2t!c1
zA)eGyMi~HL{xCi;AutIB1uG5%0vZJX1Qgdf8T8}fpVh9<j0=ZUJ=_j+a25m<w_Q5V
Y+ZY?kAM<!?o!a&xn(^u10s{etpkX)KnE(I)

literal 0
HcmV?d00001

diff --git a/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/server.keystore b/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/server.keystore
new file mode 100644
index 0000000000000000000000000000000000000000..7d279638a34410041be7a25e5ba91cfbe77b0050
GIT binary patch
literal 2407
zcmY+EX*d)L7sqGD%xElS8C_#6Bb2d@J-dkPyRnWKvSgc(<TA#{5+Ro%W3m-4U8JH?
z_UwBj8YISUiY^i&Z})xP_ul7zIOjai?|;tu_`{H4J|G|)h71#i!eo+7lfQ8T*?}cw
z7&n*<gZ;!13>gymuL$A>CPT14vHj1ohI0Pzii-mXDj|cvW60od7&MgQ|M=%~BpCiE
z;EkLZ4;%5>y+O<O6Pohi1eqWZ8=%t`Oa}J`Q)+_Q$5lA3e>unWCmmk(MayYhI)mv6
zPQ4<WK}(v2i!Cj1M$Q{s`DLuzXOFG8=;rovOPYv=O-c0N152S_Ns<?bYBWChymaC1
zu-W8d(C~aZ*Rf@&^th$8n&Y`&O8KAn^5LA;yq7mQ&Vl3onbcJOB0BxTP_FVp+B-$j
z99WVnv6-`eIY0*gp7%w?bbSA1ocoIlbL=VdGF)@zx_qSb<#J0P_Gxo)WTl0Ue+MUU
z77<g=--n42T}mle*me3`L_NXVxwYu1lzE2Ri{Ck~{ny>~K1*bj`RgbTL_>hv<SoQK
z;e8#I3-w~zZW$G~O;BL(-)W^FmJm8ty2mh{qOrcZ0J&8GPfi}UMcX{CEWCbt2bk8D
zWp9juXqw57Nq8dd>$Sh%;2Rb_%*VqR(zqe-TP<A!r#1D&s*h>|YJMAoGHB-b!c%=c
ze(Od0212~nI#ej7BRB&JhQIk!s?ELnvSH5q`bC|Dhp*Cm`d0=z<}I|ZnD}XV86|bd
z%QRlh1eb=$jG?I!bqfwlJ42C|%s%ps9{?+s!-%>%>wnm8G#-WS(ZXJ<@($?OUYlMu
zpX(32Z!5lbESMj%;x@yv8K62i*e6ZzK`NCJuIBhvX`u^Jh1`Zd?f5)bQ7jb-_?oo7
zc5+Am4oT|aVMa5CE646n>jC4+;pXm)FZ@{!o>wi@SMAIht`*2+>wBH*7`Z2kTpzav
zk3~EII`>{M`=uy#dP~2Gt(kSP+;pE>jRp5K^a)7@_x6S?RY<xwpW1lp%#xKnUr4OI
zw0sGB_SRgLE;Rn^K`JW$hj>O^LA1-!BWKkQ!ouu}Q{MHNp&Z2RG>1!*oDXq%oDhG;
z8v@FxP5iW#rtKZQnbKXqaW&mtRHio;U%A<yhFGZ@X}$x954){%e8$p+$x^qlgcRJU
zGRfQ)*CFM$h?J095(7>$d`O?6UxjpfINFA~_8d2h<f<p*nd@xka%ExoVr*l-wg_)L
zk5KehQN-vM?8N!gM^z;Gf|uP4Z>6t)0P{^Er^2cx;GxP3321=tPI!2$=<O?$o9cdb
z4IihXaF1PC4oKq4NYjWw?ExzhFNpiW<RBYy>sg>+BX(XnLKY2*_au_IXLI$-tmXla
zcln~;$JZlNaFPcO>2-SdUEV!#jgIIXkg#Csw(=jIib}A@W0%;@iCi~}Mz|`t^s2QK
zf<5Y$VqJquw0tBy1zvovIp5noKYlRR=hD%oY9I5!BmVqTEQ<Xiw;bw3rJCpN?HJJ>
z=dt$zj$UeKO|VwWUfQb?F?@egF365BQ$1=4nBv|&JIqaCG1(M;N+Oxh%JW2Hs`&S7
zfmxw!{5(15tTvPI9Z#EsM823-f79Pg#ATkXe0#v!Qg`Hmj}_)q?2RLNGTWbjRd;xe
zP9bk8YsP67rk!i;x*MSvM{YNXQ)o|Y-YZ(E_>j@#WP70p+U(e!_@t7aet3;2e^$Hc
zjsUQEe6lGIB|NAp;gM1J%UyTFRgR?~68d_!NR*?!+TGgxggUx<Qxu=RSnJ^D*&j_l
z&|$5>CnuyF(3v_fId=C!=Zk%KYs>EXqnj-=W!|NWYY04~vh>aX&6=+HH-s#pS_yBB
z6%rntQ8K_F|5haou5?nA3lIUg0tg30{natz|AYcca4?@^V8|7ek_JXeSwllz?XSX+
z*>eA0VuzNH*^+*u1P~DLbHx0U0RLrJ=wF7Nbm?oAULYOKWN&Dzcr<+%3%mXDzlJ4|
z*$hOl3XRj95W|~)EE8!YGfM$kduN4Qn=YIiPXatQY}pC>&DH?HYtdAD@S~UsnFsWO
zr)P^$%i)fqZAV{|p9LUkbR<o#S60?>q#&EHO7C0my01{y02H`rI6k2im2Dor)Biy!
zmugcQDoJ^*AYp8*IuuengO9zbD>F0c34CCFxI6!dHY34vq$e0_=5HyfGEuioKUM52
zQ~M~^{UArogqrE@#OX`;_^lIa2{kZ!=mifHOmZ(5l{0qTD@?Ju<%NfL(_ojAHE-;W
zWLxzo7Y5Q<jXi`<KaLo?B?g#T*@uP2THw9LFICnpUuOoYdhJn!h;H|EsZV3udEU3`
z<6I<hpQSGcG@*v&!*WQ~^uEBY{g$PIY#Fr;i~?gxM$09=qpU$dIX^3_Ze-oKGbhV;
zDx51B|JY$H1M$HlH6}_Waco5yU7Qk4Hu>1nYn={y)m1I6brk8f5)&5nxQt>@vnAMV
zS0>C=qorZ?Ocn8*yg}3+qgl-!idDD=KNqFRwnSfTFs0W>Su+RSPvyTGJ*eP>U0}E2
zUd(Ug7hygN2wgn3-?%z;bK5X2-QWgpcg2h#D8coD{n<8>tu2zNkMava`T7YSjDTU$
z(}LEM$O%nTg6aOV?UO)V&ISQ3;`FGHBf6<#lQsIBd(`o+Q5>4x<PyH~=Hi|~rLZi*
zAc(Rb@>>6`tz>)7S^<i@U&35%dehTLQO1;F7X%s~&-Hyrto2W0S~HSILE*<{hWBP^
zEJdl5+?9T^wpnrc6)DZa#4|6-2`N03(_+`fViTHe>BAmJh9y5p&h<*DSy5s~;t8=<
zR#V8GzPzlLE;Wi}gBI#}#aop(EEe+nu4MH4E&?OnilWT3#A~Jr8x+@|<9Dw*6@pQ7
zaf+R(xNR+;HpNOugkAo~P}fA-==>K|CN;=tYA>;%J`^YEI`b_jkDuKgb$tK$Sm9&B
z0HDI^vbs8SH(lbKpTPpaW8*#uF(R=TPsMY29`1EBY(|DZflTAqW}w3xAC#kvsW!ps
zm%$llg@{IU<Mq1W)H5`@eJN@+^-br@6d286VXFF@Ed!$lnU=oPN`xSh>;uBp7(I+Q
z1_p)5o@4_FK>%Pl&pd$|>s7ZHh%-Hzg^h8Zm58wi!y`cUL7^SRjK#Odlc~S&q_HPu
LD}&g8$tC{*$&6Q$

literal 0
HcmV?d00001

diff --git a/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/server.truststore b/core/src/test/resources/ReloadingKeyManagerFactoryTest/certs/server.truststore
new file mode 100644
index 0000000000000000000000000000000000000000..c9b06b5fbe1c2a81cfdcb7319bb82acbb0f6b4a0
GIT binary patch
literal 1890
zcmV-o2c7sZf(Kp#0Ru3C2NwnjDuzgg_YDCD0ic2h2n2!$1TcaJ05F0E{00dshDe6@
z4FLxRpn?YNFoFi@0s#Opf(GIS2`Yw2hW8Bt2LUiC1_~;MNQU<f0So~KFdGCE`hky|
zn$xSBD^9o^1@?vXthE0)0s{cUP=JC4sA_nF9{mg*_wkOF1AL86ZWVW5^09_?^HT{i
z9~5g8gGDqz3m^~hm%osjvT2N4BKF_d04KjZvLSH!n^gST%e_P#dI~y`IA7fN7ZmVP
zN8ZX^l)4TEF`D5=e`y0RbLQ(o8W3lcHq`{fFs6~9z|mpnT8q$YZrn-`L9qVr?i$@7
z11oF0B|;3*eRdC|Sc!j%eCi<DMAg)0kcwv=nbiwVY0zLvS>ntF0&nl&gP8eutUG)C
z)w>s(%-}4h_Gb1JtX(Gt7Lf@UC}iJX!76zfiIVH0c~njU_FTR+|0xpktwPDK`^Y9v
zC5e446hb8OZ#U75j;Ms?U|uJJ;Ee>{0HK4!Z~CZ{>MP)R$nHJ8b^`v&p*PR534D#`
zUX=-?!((kjc;`_o$6t3Q8Vm!@C1CabTumt4?w~^ir$fdubO0%R$@dTK@Hp~`1LsH$
ztnm<6t_iJ)*rx{1Z8$SlU#C_zKD!z+Hg5}=&!4Ad|CLESP~?q%$ZGwZiD0Z+d)JfG
z{h#&*pKYW3`CuXL0oSVz-W`PbfNk0ccywE}7`4vJiNBuK!M=um?6L>23_8fv$3Xkf
zla7@l0l`1gRepm3i51mk9d2a16lX)NWpbN4Nb~*UlTqHm@>p#j()|tMaG{!EK?txB
zz9TXuosh|w=K7qc#CVE=bZkix_tumaFKcxM$PC9NV%fbGEf+KbT*^uz5=105W|(Gz
zh1WSXjvo@eD3v^to!L5ki(e-mkiE`5xl~T2WPugTRw%T2ev{!*lYLn)`A_@qfY%1B
zTfV1dpKPoyX>GX*-L)BMKNCgSIqdP;;pr1k>qN<6L6Y>N4k$Q11k5RSivFQSO~BVJ
zc@jUS2tpjyl+t?636-1+=#xyVuQGI&C3jziYebkuEB%={ht9Zx7*(fy6Jlk-E!|Vk
zx8C6hY3&W{elehl-nRQnklm4qmxyWM@)BS7_N*p43FLryqfhgYi6tz@qvNXwF4!^7
zqo8wN&kRPfY$$<`^%L{QuaL1Rq?#)xz-HOAiWg_(q090rB_K=e+sz)6(z+ghLOGO{
zMCk?=+l_7=Z>;vt${=nyv>CdN=1b*ZO8N@4w>g8DINf3{H{$aE4n>Z6x??J#u{T&o
z%54l3cU!1JGMS5EC9e3a1Z8Y&Wp@t>lrOHcs37ug7T>pDgWM<oTLjzF-k=oMI8vAM
ze*DOAqejLomppk2DEKFDEbux>czgBy_<T9h62*b7QL3v~M!iawkhcoCg|ejti@~Uu
z&Du{rzK}38^gR3hLTkIXv!MYLAD*#yAS_r6ez%BO+f;~A5VT;0;ua`gY|#dzHguSP
zK=72j6w~pPrX9Wx9!cNz?OrmV4lEWY;Y3itqO<b{=OVaI*sELRQ-Sngr*e<m{<%t0
zr}0OKkLjiW12^6Tva2DGXhHQ?GOoFhz#D@u=*H33?FKc2fyjg)y!GUs7%_z^SV~gz
zF*RB*3O$-@TW?HRYyR(g*$}924t=AixPA9n8FpfivVRmcW`vCgZ{Tw_Q!6yc?lDLW
zwr86z+ic@c)~N*KcU}Y!iWSi<ML(7ljma%ZMh>~}LR>q0Y1Pl{9%j7O)q`KwU6Ksh
zRdxKfk~-^lky#Z70A6rIeXi5CEBvr9@(ymtO%n0pEDfBK$I-g_eCFut@fHJT&~?tW
ztaY3)I_gBKpC})fn3FTMdRZ=7eIz-<gux;GRnb82rR}i^T?Gj0n?w9U88Zy)W+f_@
zVR)kO-B8lFou-~QyXUig&|__En7KFHbO0c_p}T(7cQx;ZV%>MkNNr+V(M^b0c~Lwp
zCupPHv*t-fLt_mv3as*+x+yvQH0sqjX~Z);uyx$a7ZvCkHpnuqmo{W*bFF7tFDZeW
z_i~-$^{(ho^1Io^|J7>^gaBQtB{o37w+wztlzW{qg7m(d*}JjQ!hq*;4?S|medoRl
zEqSS3CV58g+Aerc>21P}Efcs`T{qP?C+bV>W+L~~S$k#BSdXGOjCix%{+>yiZYhs}
zYlCX#u_bUbj0Rq<YAm>ExB>PJ$*|0HFA<8Y-)Cwrpmt6vysGvweeUqv`qwWNXi)Sj
z!1SW!%WDc|3}%u8`*V~tAzXv2RP)L#Y}Gg3ciTdabi9l{SV$)t<4KkPPi&FDR-{OP
zTsp#f;>qOE1u6|Ner4vS0|B^Jvf`P*5z0kJ?KHd<RAJ;OyngSkr8Y>PVKoLha>0|*
zhWhKFT6?9;Xs5l|qcA=&AutIB1uG5%0vZJX1Qg`kli9U7#PfFfuLGPqc&FXlm~;db
ctoVTJaCWa4Yfw+L!h=^Pt>>Pu0s{etpskvUfB*mh

literal 0
HcmV?d00001

diff --git a/manual/core/ssl/README.md b/manual/core/ssl/README.md
index b8aa9b89192..913c7bc6c9a 100644
--- a/manual/core/ssl/README.md
+++ b/manual/core/ssl/README.md
@@ -94,11 +94,13 @@ If you're using a CA, sign the client certificate with it (see the blog post lin
 this page). Then the nodes' truststores only need to contain the CA's certificate (which should
 already be the case if you've followed the steps for inter-node encryption).
 
+`DefaultSslEngineFactory` supports client keystore reloading; see property
+`advanced.ssl-engine-factory.keystore-reload-interval`.
 
 ### Driver configuration
 
 By default, the driver's SSL support is based on the JDK's built-in implementation: JSSE (Java
-Secure Socket Extension),.
+Secure Socket Extension).
 
 To enable it, you need to define an engine factory in the [configuration](../configuration/).
 
@@ -126,6 +128,12 @@ datastax-java-driver {
     // truststore-password = password123
     // keystore-path = /path/to/client.keystore
     // keystore-password = password123
+
+    # The duration between attempts to reload the keystore from the contents of the file specified
+    # by `keystore-path`. This is mainly relevant in environments where certificates have short
+    # lifetimes and applications are restarted infrequently, since an expired client certificate
+    # will prevent new connections from being established until the application is restarted.
+    // keystore-reload-interval = 30 minutes
   }
 }
 ```
diff --git a/upgrade_guide/README.md b/upgrade_guide/README.md
index e79e8f8cc6d..c6df74ffc2a 100644
--- a/upgrade_guide/README.md
+++ b/upgrade_guide/README.md
@@ -19,6 +19,17 @@ under the License.
 
 ## Upgrade guide
 
+### NEW VERSION PLACEHOLDER
+
+#### Keystore reloading in DefaultSslEngineFactory
+
+`DefaultSslEngineFactory` now includes an optional keystore reloading interval, for detecting changes in the local
+client keystore file. This is relevant in environments with mTLS enabled and short-lived client certificates, especially
+when an application restart might not always happen between a new keystore becoming available and the previous
+keystore certificate expiring.
+
+This feature is disabled by default for compatibility. To enable, see `keystore-reload-interval` in `reference.conf`.
+
 ### 4.17.0
 
 #### Beta support for Java17

From c7719aed14705b735571ecbfbda23d3b8506eb11 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <abe@aber.io>
Date: Tue, 23 Jan 2024 16:09:35 -0500
Subject: [PATCH 002/126] PR feedback: avoid extra exception wrapping, provide
 thread naming, improve error messages, etc.

---
 .../api/core/config/DefaultDriverOption.java  | 12 ++---
 .../core/ssl/DefaultSslEngineFactory.java     |  4 +-
 .../core/ssl/ReloadingKeyManagerFactory.java  | 44 +++++++++----------
 3 files changed, 28 insertions(+), 32 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
index c10a8237c43..afe16e96886 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
@@ -255,12 +255,6 @@ public enum DefaultDriverOption implements DriverOption {
    * <p>Value-type: {@link String}
    */
   SSL_KEYSTORE_PASSWORD("advanced.ssl-engine-factory.keystore-password"),
-  /**
-   * The duration between attempts to reload the keystore.
-   *
-   * <p>Value-type: {@link java.time.Duration}
-   */
-  SSL_KEYSTORE_RELOAD_INTERVAL("advanced.ssl-engine-factory.keystore-reload-interval"),
   /**
    * The location of the truststore file.
    *
@@ -982,6 +976,12 @@ public enum DefaultDriverOption implements DriverOption {
    * <p>Value-type: boolean
    */
   METRICS_GENERATE_AGGREGABLE_HISTOGRAMS("advanced.metrics.histograms.generate-aggregable"),
+  /**
+   * The duration between attempts to reload the keystore.
+   *
+   * <p>Value-type: {@link java.time.Duration}
+   */
+  SSL_KEYSTORE_RELOAD_INTERVAL("advanced.ssl-engine-factory.keystore-reload-interval"),
   ;
 
   private final String path;
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
index 55a6e9c7da8..adf23f8e89a 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
@@ -150,8 +150,8 @@ protected SSLContext buildContext(DriverExecutionProfile config) throws Exceptio
     }
   }
 
-  private ReloadingKeyManagerFactory buildReloadingKeyManagerFactory(
-      DriverExecutionProfile config) {
+  private ReloadingKeyManagerFactory buildReloadingKeyManagerFactory(DriverExecutionProfile config)
+      throws Exception {
     Path keystorePath = Paths.get(config.getString(DefaultDriverOption.SSL_KEYSTORE_PATH));
     String password =
         config.isDefined(DefaultDriverOption.SSL_KEYSTORE_PASSWORD)
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
index 9aaee701114..540ddfd79fa 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
@@ -73,26 +73,17 @@ public class ReloadingKeyManagerFactory extends KeyManagerFactory implements Aut
    * @return
    */
   public static ReloadingKeyManagerFactory create(
-      Path keystorePath, String keystorePassword, Duration reloadInterval) {
-    KeyManagerFactory kmf;
-    try {
-      kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
-    } catch (NoSuchAlgorithmException e) {
-      throw new RuntimeException(e);
-    }
+      Path keystorePath, String keystorePassword, Duration reloadInterval)
+      throws UnrecoverableKeyException, KeyStoreException, NoSuchAlgorithmException,
+          CertificateException, IOException {
+    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
 
     KeyStore ks;
     try (InputStream ksf = Files.newInputStream(keystorePath)) {
       ks = KeyStore.getInstance(KEYSTORE_TYPE);
       ks.load(ksf, keystorePassword.toCharArray());
-    } catch (IOException | CertificateException | KeyStoreException | NoSuchAlgorithmException e) {
-      throw new RuntimeException(e);
-    }
-    try {
-      kmf.init(ks, keystorePassword.toCharArray());
-    } catch (KeyStoreException | NoSuchAlgorithmException | UnrecoverableKeyException e) {
-      throw new RuntimeException(e);
     }
+    kmf.init(ks, keystorePassword.toCharArray());
 
     ReloadingKeyManagerFactory reloadingKeyManagerFactory = new ReloadingKeyManagerFactory(kmf);
     reloadingKeyManagerFactory.start(keystorePath, keystorePassword, reloadInterval);
@@ -115,24 +106,26 @@ private ReloadingKeyManagerFactory(Spi spi, Provider provider, String algorithm)
   private void start(Path keystorePath, String keystorePassword, Duration reloadInterval) {
     this.keystorePath = keystorePath;
     this.keystorePassword = keystorePassword;
-    this.executor =
-        Executors.newScheduledThreadPool(
-            1,
-            runnable -> {
-              Thread t = Executors.defaultThreadFactory().newThread(runnable);
-              t.setDaemon(true);
-              return t;
-            });
 
     // Ensure that reload is called once synchronously, to make sure the file exists etc.
     reload();
 
-    if (!reloadInterval.isZero())
+    if (!reloadInterval.isZero()) {
+      this.executor =
+          Executors.newScheduledThreadPool(
+              1,
+              runnable -> {
+                Thread t = Executors.defaultThreadFactory().newThread(runnable);
+                t.setName(String.format("%s-%%d", this.getClass().getSimpleName()));
+                t.setDaemon(true);
+                return t;
+              });
       this.executor.scheduleWithFixedDelay(
           this::reload,
           reloadInterval.toMillis(),
           reloadInterval.toMillis(),
           TimeUnit.MILLISECONDS);
+    }
   }
 
   @VisibleForTesting
@@ -140,7 +133,10 @@ void reload() {
     try {
       reload0();
     } catch (Exception e) {
-      logger.warn("Failed to reload", e);
+      String msg =
+          "Failed to reload KeyStore. If this continues to happen, your client may use stale identity"
+              + "certificates and fail to re-establish connections to Cassandra hosts.";
+      logger.warn(msg, e);
     }
   }
 

From ea2e475185b5863ef6eed347f57286d6a3bfd8a9 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aratnofsky@apple.com>
Date: Fri, 2 Feb 2024 14:56:22 -0500
Subject: [PATCH 003/126] Address PR feedback: reload-interval to use Optional
 internally and null in config, rather than using sentinel Duration.ZERO

---
 .../core/ssl/DefaultSslEngineFactory.java     | 14 ++++-----
 .../core/ssl/ReloadingKeyManagerFactory.java  | 29 +++++++++++++------
 .../ssl/ReloadingKeyManagerFactoryTest.java   |  4 +--
 3 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
index adf23f8e89a..bb95dc738c7 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
@@ -33,6 +33,7 @@
 import java.security.SecureRandom;
 import java.time.Duration;
 import java.util.List;
+import java.util.Optional;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLEngine;
 import javax.net.ssl.SSLParameters;
@@ -153,14 +154,11 @@ protected SSLContext buildContext(DriverExecutionProfile config) throws Exceptio
   private ReloadingKeyManagerFactory buildReloadingKeyManagerFactory(DriverExecutionProfile config)
       throws Exception {
     Path keystorePath = Paths.get(config.getString(DefaultDriverOption.SSL_KEYSTORE_PATH));
-    String password =
-        config.isDefined(DefaultDriverOption.SSL_KEYSTORE_PASSWORD)
-            ? config.getString(DefaultDriverOption.SSL_KEYSTORE_PASSWORD)
-            : null;
-    Duration reloadInterval =
-        config.isDefined(DefaultDriverOption.SSL_KEYSTORE_RELOAD_INTERVAL)
-            ? config.getDuration(DefaultDriverOption.SSL_KEYSTORE_RELOAD_INTERVAL)
-            : Duration.ZERO;
+    String password = config.getString(DefaultDriverOption.SSL_KEYSTORE_PASSWORD, null);
+    Optional<Duration> reloadInterval =
+        Optional.ofNullable(
+            config.getDuration(DefaultDriverOption.SSL_KEYSTORE_RELOAD_INTERVAL, null));
+
     return ReloadingKeyManagerFactory.create(keystorePath, password, reloadInterval);
   }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
index 540ddfd79fa..8a9e11bb2e9 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactory.java
@@ -36,6 +36,7 @@
 import java.security.cert.X509Certificate;
 import java.time.Duration;
 import java.util.Arrays;
+import java.util.Optional;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
@@ -68,12 +69,12 @@ public class ReloadingKeyManagerFactory extends KeyManagerFactory implements Aut
    *
    * @param keystorePath the keystore file to reload
    * @param keystorePassword the keystore password
-   * @param reloadInterval the duration between reload attempts. Set to {@link
-   *     java.time.Duration#ZERO} to disable scheduled reloading.
+   * @param reloadInterval the duration between reload attempts. Set to {@link Optional#empty()} to
+   *     disable scheduled reloading.
    * @return
    */
-  public static ReloadingKeyManagerFactory create(
-      Path keystorePath, String keystorePassword, Duration reloadInterval)
+  static ReloadingKeyManagerFactory create(
+      Path keystorePath, String keystorePassword, Optional<Duration> reloadInterval)
       throws UnrecoverableKeyException, KeyStoreException, NoSuchAlgorithmException,
           CertificateException, IOException {
     KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
@@ -103,14 +104,24 @@ private ReloadingKeyManagerFactory(Spi spi, Provider provider, String algorithm)
     this.spi = spi;
   }
 
-  private void start(Path keystorePath, String keystorePassword, Duration reloadInterval) {
+  private void start(
+      Path keystorePath, String keystorePassword, Optional<Duration> reloadInterval) {
     this.keystorePath = keystorePath;
     this.keystorePassword = keystorePassword;
 
     // Ensure that reload is called once synchronously, to make sure the file exists etc.
     reload();
 
-    if (!reloadInterval.isZero()) {
+    if (!reloadInterval.isPresent() || reloadInterval.get().isZero()) {
+      final String msg =
+          "KeyStore reloading is disabled. If your Cassandra cluster requires client certificates, "
+              + "client application restarts are infrequent, and client certificates have short lifetimes, then your client "
+              + "may fail to re-establish connections to Cassandra hosts. To enable KeyStore reloading, see "
+              + "`advanced.ssl-engine-factory.keystore-reload-interval` in reference.conf.";
+      logger.info(msg);
+    } else {
+      logger.info("KeyStore reloading is enabled with interval {}", reloadInterval.get());
+
       this.executor =
           Executors.newScheduledThreadPool(
               1,
@@ -122,8 +133,8 @@ private void start(Path keystorePath, String keystorePassword, Duration reloadIn
               });
       this.executor.scheduleWithFixedDelay(
           this::reload,
-          reloadInterval.toMillis(),
-          reloadInterval.toMillis(),
+          reloadInterval.get().toMillis(),
+          reloadInterval.get().toMillis(),
           TimeUnit.MILLISECONDS);
     }
   }
@@ -135,7 +146,7 @@ void reload() {
     } catch (Exception e) {
       String msg =
           "Failed to reload KeyStore. If this continues to happen, your client may use stale identity"
-              + "certificates and fail to re-establish connections to Cassandra hosts.";
+              + " certificates and fail to re-establish connections to Cassandra hosts.";
       logger.warn(msg, e);
     }
   }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactoryTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactoryTest.java
index d291924b800..d07b45c21df 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactoryTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/ssl/ReloadingKeyManagerFactoryTest.java
@@ -34,7 +34,6 @@
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.security.cert.X509Certificate;
-import java.time.Duration;
 import java.util.Optional;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
@@ -86,7 +85,6 @@ public class ReloadingKeyManagerFactoryTest {
 
   static final Path CLIENT_TRUSTSTORE_PATH = CERT_BASE.resolve("client.truststore");
   static final String CERTSTORE_PASSWORD = "changeit";
-  static final Duration NO_SCHEDULED_RELOAD = Duration.ofMillis(0);
 
   private static TrustManagerFactory buildTrustManagerFactory() {
     TrustManagerFactory tmf;
@@ -186,7 +184,7 @@ public void client_certificates_should_reload() throws Exception {
 
     final ReloadingKeyManagerFactory kmf =
         ReloadingKeyManagerFactory.create(
-            TMP_CLIENT_KEYSTORE_PATH, CERTSTORE_PASSWORD, NO_SCHEDULED_RELOAD);
+            TMP_CLIENT_KEYSTORE_PATH, CERTSTORE_PASSWORD, Optional.empty());
     // Need a tmf that tells the server to send its certs
     final TrustManagerFactory tmf = buildTrustManagerFactory();
 

From 7e2c6579af564be6d1b161ec4159ecf517c190b4 Mon Sep 17 00:00:00 2001
From: Bret McGuire <bret.mcguire@datastax.com>
Date: Tue, 6 Feb 2024 15:18:59 -0600
Subject: [PATCH 004/126] CASSANDRA-19352: Support
 native_transport_(address|port) + native_transport_port_ssl for DSE 6.8 (4.x
 edition)

patch by absurdfarce; reviewed by absurdfarce and adutra for CASSANDRA-19352
---
 .../core/metadata/DefaultTopologyMonitor.java |  76 ++++++--
 .../metadata/DefaultTopologyMonitorTest.java  | 180 ++++++++++++++++--
 2 files changed, 223 insertions(+), 33 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/DefaultTopologyMonitor.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/DefaultTopologyMonitor.java
index 87008b05cec..f3dc988cfbc 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/DefaultTopologyMonitor.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/DefaultTopologyMonitor.java
@@ -34,6 +34,7 @@
 import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableSet;
+import com.datastax.oss.driver.shaded.guava.common.collect.Iterators;
 import com.datastax.oss.protocol.internal.ProtocolConstants;
 import com.datastax.oss.protocol.internal.response.Error;
 import edu.umd.cs.findbugs.annotations.NonNull;
@@ -69,6 +70,10 @@ public class DefaultTopologyMonitor implements TopologyMonitor {
   // Assume topology queries never need paging
   private static final int INFINITE_PAGE_SIZE = -1;
 
+  // A few system.peers columns which get special handling below
+  private static final String NATIVE_PORT = "native_port";
+  private static final String NATIVE_TRANSPORT_PORT = "native_transport_port";
+
   private final String logPrefix;
   private final InternalDriverContext context;
   private final ControlConnection controlConnection;
@@ -494,28 +499,65 @@ private void savePort(DriverChannel channel) {
   @Nullable
   protected InetSocketAddress getBroadcastRpcAddress(
       @NonNull AdminRow row, @NonNull EndPoint localEndPoint) {
-    // in system.peers or system.local
-    InetAddress broadcastRpcInetAddress = row.getInetAddress("rpc_address");
+
+    InetAddress broadcastRpcInetAddress = null;
+    Iterator<String> addrCandidates =
+        Iterators.forArray(
+            // in system.peers_v2 (Cassandra >= 4.0)
+            "native_address",
+            // DSE 6.8 introduced native_transport_address and native_transport_port for the
+            // listen address.
+            "native_transport_address",
+            // in system.peers or system.local
+            "rpc_address");
+
+    while (broadcastRpcInetAddress == null && addrCandidates.hasNext())
+      broadcastRpcInetAddress = row.getInetAddress(addrCandidates.next());
+    // This could only happen if system tables are corrupted, but handle gracefully
     if (broadcastRpcInetAddress == null) {
-      // in system.peers_v2 (Cassandra >= 4.0)
-      broadcastRpcInetAddress = row.getInetAddress("native_address");
-      if (broadcastRpcInetAddress == null) {
-        // This could only happen if system tables are corrupted, but handle gracefully
-        return null;
+      LOG.warn(
+          "[{}] Unable to determine broadcast RPC IP address, returning null.  "
+              + "This is likely due to a misconfiguration or invalid system tables.  "
+              + "Please validate the contents of system.local and/or {}.",
+          logPrefix,
+          getPeerTableName());
+      return null;
+    }
+
+    Integer broadcastRpcPort = null;
+    Iterator<String> portCandidates =
+        Iterators.forArray(
+            // in system.peers_v2 (Cassandra >= 4.0)
+            NATIVE_PORT,
+            // DSE 6.8 introduced native_transport_address and native_transport_port for the
+            // listen address.
+            NATIVE_TRANSPORT_PORT,
+            // system.local for Cassandra >= 4.0
+            "rpc_port");
+
+    while ((broadcastRpcPort == null || broadcastRpcPort == 0) && portCandidates.hasNext()) {
+
+      String colName = portCandidates.next();
+      broadcastRpcPort = row.getInteger(colName);
+      // Support override for SSL port (if enabled) in DSE
+      if (NATIVE_TRANSPORT_PORT.equals(colName) && context.getSslEngineFactory().isPresent()) {
+
+        String sslColName = colName + "_ssl";
+        broadcastRpcPort = row.getInteger(sslColName);
       }
     }
-    // system.local for Cassandra >= 4.0
-    Integer broadcastRpcPort = row.getInteger("rpc_port");
+    // use the default port if no port information was found in the row;
+    // note that in rare situations, the default port might not be known, in which case we
+    // report zero, as advertised in the javadocs of Node and NodeInfo.
     if (broadcastRpcPort == null || broadcastRpcPort == 0) {
-      // system.peers_v2
-      broadcastRpcPort = row.getInteger("native_port");
-      if (broadcastRpcPort == null || broadcastRpcPort == 0) {
-        // use the default port if no port information was found in the row;
-        // note that in rare situations, the default port might not be known, in which case we
-        // report zero, as advertised in the javadocs of Node and NodeInfo.
-        broadcastRpcPort = port == -1 ? 0 : port;
-      }
+
+      LOG.warn(
+          "[{}] Unable to determine broadcast RPC port.  "
+              + "Trying to fall back to port used by the control connection.",
+          logPrefix);
+      broadcastRpcPort = port == -1 ? 0 : port;
     }
+
     InetSocketAddress broadcastRpcAddress =
         new InetSocketAddress(broadcastRpcInetAddress, broadcastRpcPort);
     if (row.contains("peer") && broadcastRpcAddress.equals(localEndPoint.resolve())) {
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/DefaultTopologyMonitorTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/DefaultTopologyMonitorTest.java
index cc275eb1624..dd40f233518 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/DefaultTopologyMonitorTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/DefaultTopologyMonitorTest.java
@@ -38,6 +38,7 @@
 import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverConfig;
 import com.datastax.oss.driver.api.core.config.DriverExecutionProfile;
+import com.datastax.oss.driver.api.core.ssl.SslEngineFactory;
 import com.datastax.oss.driver.internal.core.addresstranslation.PassThroughAddressTranslator;
 import com.datastax.oss.driver.internal.core.adminrequest.AdminResult;
 import com.datastax.oss.driver.internal.core.adminrequest.AdminRow;
@@ -50,9 +51,11 @@
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableSet;
 import com.datastax.oss.driver.shaded.guava.common.collect.Iterators;
+import com.datastax.oss.driver.shaded.guava.common.collect.Maps;
 import com.datastax.oss.protocol.internal.Message;
 import com.datastax.oss.protocol.internal.ProtocolConstants;
 import com.datastax.oss.protocol.internal.response.Error;
+import com.google.common.collect.Streams;
 import com.tngtech.java.junit.dataprovider.DataProvider;
 import com.tngtech.java.junit.dataprovider.DataProviderRunner;
 import com.tngtech.java.junit.dataprovider.UseDataProvider;
@@ -95,6 +98,8 @@ public class DefaultTopologyMonitorTest {
   @Mock private Appender<ILoggingEvent> appender;
   @Captor private ArgumentCaptor<ILoggingEvent> loggingEventCaptor;
 
+  @Mock private SslEngineFactory sslEngineFactory;
+
   private DefaultNode node1;
   private DefaultNode node2;
 
@@ -414,18 +419,6 @@ public void should_skip_invalid_peers_row_v2(String columnToCheck) {
             + "This is likely a gossip or snitch issue, this node will be ignored.");
   }
 
-  @DataProvider
-  public static Object[][] columnsToCheckV1() {
-    return new Object[][] {{"rpc_address"}, {"host_id"}, {"data_center"}, {"rack"}, {"tokens"}};
-  }
-
-  @DataProvider
-  public static Object[][] columnsToCheckV2() {
-    return new Object[][] {
-      {"native_address"}, {"native_port"}, {"host_id"}, {"data_center"}, {"rack"}, {"tokens"}
-    };
-  }
-
   @Test
   public void should_stop_executing_queries_once_closed() {
     // Given
@@ -443,9 +436,9 @@ public void should_stop_executing_queries_once_closed() {
   public void should_warn_when_control_host_found_in_system_peers() {
     // Given
     AdminRow local = mockLocalRow(1, node1.getHostId());
-    AdminRow peer3 = mockPeersRow(3, UUID.randomUUID());
-    AdminRow peer2 = mockPeersRow(2, node2.getHostId());
     AdminRow peer1 = mockPeersRow(1, node2.getHostId()); // invalid
+    AdminRow peer2 = mockPeersRow(2, node2.getHostId());
+    AdminRow peer3 = mockPeersRow(3, UUID.randomUUID());
     topologyMonitor.stubQueries(
         new StubbedQuery("SELECT * FROM system.local", mockResult(local)),
         new StubbedQuery("SELECT * FROM system.peers_v2", Collections.emptyMap(), null, true),
@@ -462,7 +455,7 @@ public void should_warn_when_control_host_found_in_system_peers() {
                     .hasSize(3)
                     .extractingResultOf("getEndPoint")
                     .containsOnlyOnce(node1.getEndPoint()));
-    assertLog(
+    assertLogContains(
         Level.WARN,
         "[null] Control node /127.0.0.1:9042 has an entry for itself in system.peers: "
             + "this entry will be ignored. This is likely due to a misconfiguration; "
@@ -492,7 +485,7 @@ public void should_warn_when_control_host_found_in_system_peers_v2() {
                     .hasSize(3)
                     .extractingResultOf("getEndPoint")
                     .containsOnlyOnce(node1.getEndPoint()));
-    assertLog(
+    assertLogContains(
         Level.WARN,
         "[null] Control node /127.0.0.1:9042 has an entry for itself in system.peers_v2: "
             + "this entry will be ignored. This is likely due to a misconfiguration; "
@@ -500,6 +493,116 @@ public void should_warn_when_control_host_found_in_system_peers_v2() {
             + "all nodes in your cluster.");
   }
 
+  // Confirm the base case of extracting peer info from peers_v2, no SSL involved
+  @Test
+  public void should_get_peer_address_info_peers_v2() {
+    // Given
+    AdminRow local = mockLocalRow(1, node1.getHostId());
+    AdminRow peer2 = mockPeersV2Row(3, node2.getHostId());
+    AdminRow peer1 = mockPeersV2Row(2, node1.getHostId());
+    topologyMonitor.isSchemaV2 = true;
+    topologyMonitor.stubQueries(
+        new StubbedQuery("SELECT * FROM system.local", mockResult(local)),
+        new StubbedQuery("SELECT * FROM system.peers_v2", mockResult(peer2, peer1)));
+    when(context.getSslEngineFactory()).thenReturn(Optional.empty());
+
+    // When
+    CompletionStage<Iterable<NodeInfo>> futureInfos = topologyMonitor.refreshNodeList();
+
+    // Then
+    assertThatStage(futureInfos)
+        .isSuccess(
+            infos -> {
+              Iterator<NodeInfo> iterator = infos.iterator();
+              // First NodeInfo is for local, skip past that
+              iterator.next();
+              NodeInfo peer2nodeInfo = iterator.next();
+              assertThat(peer2nodeInfo.getEndPoint().resolve())
+                  .isEqualTo(new InetSocketAddress("127.0.0.3", 9042));
+              NodeInfo peer1nodeInfo = iterator.next();
+              assertThat(peer1nodeInfo.getEndPoint().resolve())
+                  .isEqualTo(new InetSocketAddress("127.0.0.2", 9042));
+            });
+  }
+
+  // Confirm the base case of extracting peer info from DSE peers table, no SSL involved
+  @Test
+  public void should_get_peer_address_info_peers_dse() {
+    // Given
+    AdminRow local = mockLocalRow(1, node1.getHostId());
+    AdminRow peer2 = mockPeersRowDse(3, node2.getHostId());
+    AdminRow peer1 = mockPeersRowDse(2, node1.getHostId());
+    topologyMonitor.isSchemaV2 = true;
+    topologyMonitor.stubQueries(
+        new StubbedQuery("SELECT * FROM system.local", mockResult(local)),
+        new StubbedQuery("SELECT * FROM system.peers_v2", Maps.newHashMap(), null, true),
+        new StubbedQuery("SELECT * FROM system.peers", mockResult(peer2, peer1)));
+    when(context.getSslEngineFactory()).thenReturn(Optional.empty());
+
+    // When
+    CompletionStage<Iterable<NodeInfo>> futureInfos = topologyMonitor.refreshNodeList();
+
+    // Then
+    assertThatStage(futureInfos)
+        .isSuccess(
+            infos -> {
+              Iterator<NodeInfo> iterator = infos.iterator();
+              // First NodeInfo is for local, skip past that
+              iterator.next();
+              NodeInfo peer2nodeInfo = iterator.next();
+              assertThat(peer2nodeInfo.getEndPoint().resolve())
+                  .isEqualTo(new InetSocketAddress("127.0.0.3", 9042));
+              NodeInfo peer1nodeInfo = iterator.next();
+              assertThat(peer1nodeInfo.getEndPoint().resolve())
+                  .isEqualTo(new InetSocketAddress("127.0.0.2", 9042));
+            });
+  }
+
+  // Confirm the base case of extracting peer info from DSE peers table, this time with SSL
+  @Test
+  public void should_get_peer_address_info_peers_dse_with_ssl() {
+    // Given
+    AdminRow local = mockLocalRow(1, node1.getHostId());
+    AdminRow peer2 = mockPeersRowDseWithSsl(3, node2.getHostId());
+    AdminRow peer1 = mockPeersRowDseWithSsl(2, node1.getHostId());
+    topologyMonitor.isSchemaV2 = true;
+    topologyMonitor.stubQueries(
+        new StubbedQuery("SELECT * FROM system.local", mockResult(local)),
+        new StubbedQuery("SELECT * FROM system.peers_v2", Maps.newHashMap(), null, true),
+        new StubbedQuery("SELECT * FROM system.peers", mockResult(peer2, peer1)));
+    when(context.getSslEngineFactory()).thenReturn(Optional.of(sslEngineFactory));
+
+    // When
+    CompletionStage<Iterable<NodeInfo>> futureInfos = topologyMonitor.refreshNodeList();
+
+    // Then
+    assertThatStage(futureInfos)
+        .isSuccess(
+            infos -> {
+              Iterator<NodeInfo> iterator = infos.iterator();
+              // First NodeInfo is for local, skip past that
+              iterator.next();
+              NodeInfo peer2nodeInfo = iterator.next();
+              assertThat(peer2nodeInfo.getEndPoint().resolve())
+                  .isEqualTo(new InetSocketAddress("127.0.0.3", 9043));
+              NodeInfo peer1nodeInfo = iterator.next();
+              assertThat(peer1nodeInfo.getEndPoint().resolve())
+                  .isEqualTo(new InetSocketAddress("127.0.0.2", 9043));
+            });
+  }
+
+  @DataProvider
+  public static Object[][] columnsToCheckV1() {
+    return new Object[][] {{"rpc_address"}, {"host_id"}, {"data_center"}, {"rack"}, {"tokens"}};
+  }
+
+  @DataProvider
+  public static Object[][] columnsToCheckV2() {
+    return new Object[][] {
+      {"native_address"}, {"native_port"}, {"host_id"}, {"data_center"}, {"rack"}, {"tokens"}
+    };
+  }
+
   /** Mocks the query execution logic. */
   private static class TestTopologyMonitor extends DefaultTopologyMonitor {
 
@@ -641,6 +744,43 @@ private AdminRow mockPeersV2Row(int i, UUID hostId) {
     }
   }
 
+  // Mock row for DSE ~6.8
+  private AdminRow mockPeersRowDse(int i, UUID hostId) {
+    try {
+      AdminRow row = mock(AdminRow.class);
+      when(row.contains("peer")).thenReturn(true);
+      when(row.isNull("data_center")).thenReturn(false);
+      when(row.getString("data_center")).thenReturn("dc" + i);
+      when(row.getString("dse_version")).thenReturn("6.8.30");
+      when(row.contains("graph")).thenReturn(true);
+      when(row.isNull("host_id")).thenReturn(hostId == null);
+      when(row.getUuid("host_id")).thenReturn(hostId);
+      when(row.getInetAddress("peer")).thenReturn(InetAddress.getByName("127.0.0." + i));
+      when(row.isNull("rack")).thenReturn(false);
+      when(row.getString("rack")).thenReturn("rack" + i);
+      when(row.isNull("native_transport_address")).thenReturn(false);
+      when(row.getInetAddress("native_transport_address"))
+          .thenReturn(InetAddress.getByName("127.0.0." + i));
+      when(row.isNull("native_transport_port")).thenReturn(false);
+      when(row.getInteger("native_transport_port")).thenReturn(9042);
+      when(row.isNull("tokens")).thenReturn(false);
+      when(row.getSetOfString("tokens")).thenReturn(ImmutableSet.of("token" + i));
+      when(row.isNull("rpc_address")).thenReturn(false);
+
+      return row;
+    } catch (UnknownHostException e) {
+      fail("unexpected", e);
+      return null;
+    }
+  }
+
+  private AdminRow mockPeersRowDseWithSsl(int i, UUID hostId) {
+    AdminRow row = mockPeersRowDse(i, hostId);
+    when(row.isNull("native_transport_port_ssl")).thenReturn(false);
+    when(row.getInteger("native_transport_port_ssl")).thenReturn(9043);
+    return row;
+  }
+
   private AdminResult mockResult(AdminRow... rows) {
     AdminResult result = mock(AdminResult.class);
     when(result.iterator()).thenReturn(Iterators.forArray(rows));
@@ -654,4 +794,12 @@ private void assertLog(Level level, String message) {
     assertThat(logs).hasSize(1);
     assertThat(logs.iterator().next().getFormattedMessage()).contains(message);
   }
+
+  private void assertLogContains(Level level, String message) {
+    verify(appender, atLeast(1)).doAppend(loggingEventCaptor.capture());
+    Iterable<ILoggingEvent> logs =
+        filter(loggingEventCaptor.getAllValues()).with("level", level).get();
+    assertThat(
+        Streams.stream(logs).map(ILoggingEvent::getFormattedMessage).anyMatch(message::contains));
+  }
 }

From 4c7133c72e136d23dbcea795e0041df764568931 Mon Sep 17 00:00:00 2001
From: Andy Tolbert <6889771+tolbertam@users.noreply.github.com>
Date: Tue, 23 Jan 2024 10:21:02 -0600
Subject: [PATCH 005/126] Replace uses of AttributeKey.newInstance

The java driver uses netty channel attributes to decorate a
connection's channel with the cluster name (returned from
the system.local table) and the map from the OPTIONS response, both
of which are obtained on connection initialization.

There's an issue here that I wouldn't expect to see in practice in
that the AttributeKey's used are created using
AttributeKey.newInstance, which throws an exception if an
AttributeKey of that name is defined anywhere else in evaluated code.

This change attempts to resolve this issue by changing AttributeKey
initialiation in DriverChannel from newInstance to valueOf, which avoids
throwing an exception if an AttributeKey of the same name was previously
instantiated.

patch by Andy Tolbert; reviewed by Bret McGuire, Alexandre Dutra, Abe Ratnofsky for CASSANDRA-19290
---
 .../oss/driver/internal/core/channel/DriverChannel.java       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/channel/DriverChannel.java b/core/src/main/java/com/datastax/oss/driver/internal/core/channel/DriverChannel.java
index 50932bed8c8..e40aa6f3097 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/channel/DriverChannel.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/channel/DriverChannel.java
@@ -49,9 +49,9 @@
 @ThreadSafe
 public class DriverChannel {
 
-  static final AttributeKey<String> CLUSTER_NAME_KEY = AttributeKey.newInstance("cluster_name");
+  static final AttributeKey<String> CLUSTER_NAME_KEY = AttributeKey.valueOf("cluster_name");
   static final AttributeKey<Map<String, List<String>>> OPTIONS_KEY =
-      AttributeKey.newInstance("options");
+      AttributeKey.valueOf("options");
 
   @SuppressWarnings("RedundantStringConstructorCall")
   static final Object GRACEFUL_CLOSE_MESSAGE = new String("GRACEFUL_CLOSE_MESSAGE");

From 40a9a49d50fac6abed2a5bb2cc2627e4085a399b Mon Sep 17 00:00:00 2001
From: Ekaterina Dimitrova <ekaterina.dimitrova@datastax.com>
Date: Mon, 29 Jan 2024 14:07:59 -0500
Subject: [PATCH 006/126] Fix data corruption in VectorCodec when using heap
 buffers

patch by Ekaterina Dimitrova; reviewed by Alexandre Dutra and Bret McGuire for CASSANDRA-19333
---
 .../internal/core/type/codec/VectorCodec.java      | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
index 1b663a29d9e..2c4d2200b13 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
@@ -127,17 +127,19 @@ Elements should at least precede themselves with their size (along the lines of
               cqlType.getDimensions(), bytes.remaining()));
     }
 
+    ByteBuffer slice = bytes.slice();
     List<SubtypeT> rv = new ArrayList<SubtypeT>(cqlType.getDimensions());
     for (int i = 0; i < cqlType.getDimensions(); ++i) {
-      ByteBuffer slice = bytes.slice();
-      slice.limit(elementSize);
+      // Set the limit for the current element
+      int originalPosition = slice.position();
+      slice.limit(originalPosition + elementSize);
       rv.add(this.subtypeCodec.decode(slice, protocolVersion));
-      bytes.position(bytes.position() + elementSize);
+      // Move to the start of the next element
+      slice.position(originalPosition + elementSize);
+      // Reset the limit to the end of the buffer
+      slice.limit(slice.capacity());
     }
 
-    /* Restore the input ByteBuffer to its original state */
-    bytes.rewind();
-
     return CqlVector.newInstance(rv);
   }
 

From 98e25040f5e69db1092ccafb6665d8e92779cc46 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Thu, 28 Mar 2024 15:37:22 -0500
Subject: [PATCH 007/126] CASSANDRA-19504: Improve state management for Java
 versions in Jenkinsfile

patch by Bret McGuire; reviewed by Bret McGuire for CASSANDRA-19504
---
 Jenkinsfile | 19 ++++++++++---------
 pom.xml     |  1 +
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index c8247769631..8d2b74c5b08 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -61,12 +61,6 @@ def initializeEnvironment() {
     . ${JABBA_SHELL}
     jabba which 1.8''', returnStdout: true).trim()
 
-  env.TEST_JAVA_HOME = sh(label: 'Get TEST_JAVA_HOME',script: '''#!/bin/bash -le
-    . ${JABBA_SHELL}
-    jabba which ${JABBA_VERSION}''', returnStdout: true).trim()
-  env.TEST_JAVA_VERSION = sh(label: 'Get TEST_JAVA_VERSION',script: '''#!/bin/bash -le
-    echo "${JABBA_VERSION##*.}"''', returnStdout: true).trim()
-
   sh label: 'Download Apache CassandraⓇ or DataStax Enterprise',script: '''#!/bin/bash -le
     . ${JABBA_SHELL}
     jabba use 1.8
@@ -115,7 +109,12 @@ def buildDriver(jabbaVersion) {
 }
 
 def executeTests() {
-  sh label: 'Execute tests', script: '''#!/bin/bash -le
+  def testJavaHome = sh(label: 'Get TEST_JAVA_HOME',script: '''#!/bin/bash -le
+    . ${JABBA_SHELL}
+    jabba which ${JABBA_VERSION}''', returnStdout: true).trim()
+  def testJavaVersion = (JABBA_VERSION =~ /.*\.(\d+)/)[0][1]
+
+  def executeTestScript = '''#!/bin/bash -le
     # Load CCM environment variables
     set -o allexport
     . ${HOME}/environment.txt
@@ -137,8 +136,8 @@ def executeTests() {
     printenv | sort
 
     mvn -B -V ${INTEGRATION_TESTS_FILTER_ARGUMENT} -T 1 verify \
-      -Ptest-jdk-${TEST_JAVA_VERSION} \
-      -DtestJavaHome=${TEST_JAVA_HOME} \
+      -Ptest-jdk-'''+testJavaVersion+''' \
+      -DtestJavaHome='''+testJavaHome+''' \
       -DfailIfNoTests=false \
       -Dmaven.test.failure.ignore=true \
       -Dmaven.javadoc.skip=${SKIP_JAVADOCS} \
@@ -149,6 +148,8 @@ def executeTests() {
       ${ISOLATED_ITS_ARGUMENT} \
       ${PARALLELIZABLE_ITS_ARGUMENT}
   '''
+  echo "Invoking Maven with parameters test-jdk-${testJavaVersion} and testJavaHome = ${testJavaHome}"
+  sh label: 'Execute tests', script: executeTestScript
 }
 
 def executeCodeCoverage() {
diff --git a/pom.xml b/pom.xml
index 221e1f69a86..7decc96633a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -728,6 +728,7 @@ limitations under the License.]]></inlineHeader>
       <plugin>
         <artifactId>maven-surefire-plugin</artifactId>
         <configuration>
+          <jvm>${testing.jvm}/bin/java</jvm>
           <systemPropertyVariables>
             <logback.configurationFile>${project.basedir}/src/test/resources/logback-test.xml</logback.configurationFile>
           </systemPropertyVariables>

From 4aa5abe701e529fd9be0c9b55214dad6f85f0649 Mon Sep 17 00:00:00 2001
From: Emelia <105240296+emeliawilkinson24@users.noreply.github.com>
Date: Fri, 17 Nov 2023 15:22:47 -0500
Subject: [PATCH 008/126] Update README.md

Typo carried over from old docs, needed closing parenthesis.
---
 manual/cloud/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/manual/cloud/README.md b/manual/cloud/README.md
index 48197c49425..9116b03dac3 100644
--- a/manual/cloud/README.md
+++ b/manual/cloud/README.md
@@ -28,10 +28,10 @@ driver is configured in an application and that you will need to obtain a *secur
 1. [Download][Download Maven] and [install][Install Maven] Maven.
 2. Create an Astra database on [AWS/Azure/GCP][Create an Astra database - AWS/Azure/GCP];
    alternatively, have a team member provide access to their
-   Astra database (instructions for [AWS/Azure/GCP][Access an Astra database - AWS/Azure/GCP] to
+   Astra database (see instructions for [AWS/Azure/GCP][Access an Astra database - AWS/Azure/GCP]) to
    obtain database connection details.
-3. Download the secure connect bundle (instructions for 
-   [AWS/Azure/GCP][Download the secure connect bundle - AWS/Azure/GCP], that contains connection
+3. Download the secure connect bundle (see instructions for 
+   [AWS/Azure/GCP][Download the secure connect bundle - AWS/Azure/GCP]) that contains connection
    information such as contact points and certificates.
 
 ### Procedure

From 9c41aab6fd0a55d977a9844610d230b1e69868d7 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Mon, 8 Apr 2024 11:00:46 -0500
Subject: [PATCH 009/126] Update link to JIRA to ASF instance.  Also include
 information about populating the component field.

Patch by Bret McGuire; reviewed by Bret McGuire, Alexandre Dutra
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 2e8fe862f49..c53c8f2db29 100644
--- a/README.md
+++ b/README.md
@@ -74,13 +74,13 @@ See the [Cassandra error handling done right blog](https://www.datastax.com/blog
 
 * [Manual](manual/)
 * [API docs]
-* Bug tracking: [JIRA]
+* Bug tracking: [JIRA].  Make sure to select the "Client/java-driver" component when filing new tickets!
 * [Mailing list]
 * [Changelog]
 * [FAQ]
 
 [API docs]: https://docs.datastax.com/en/drivers/java/4.17
-[JIRA]: https://datastax-oss.atlassian.net/browse/JAVA
+[JIRA]: https://issues.apache.org/jira/issues/?jql=project%20%3D%20CASSANDRA%20AND%20component%20%3D%20%22Client%2Fjava-driver%22%20ORDER%20BY%20key%20DESC
 [Mailing list]: https://groups.google.com/a/lists.datastax.com/forum/#!forum/java-driver-user
 [Changelog]: changelog/
 [FAQ]: faq/

From 6c48329199862215abc22170769fd1a165e80a15 Mon Sep 17 00:00:00 2001
From: Ammar Khaku <ammar.khaku@gmail.com>
Date: Thu, 14 Mar 2024 16:55:59 -0700
Subject: [PATCH 010/126] CASSANDRA-19468 Don't swallow exception during
 metadata refresh

If an exception was thrown while getting new metadata as
part of schema refresh it died on the admin executor instead
of being propagated to the CompletableFuture argument.
Instead, catch those exceptions and hand them off to the
CompletableFuture.

patch by Ammar Khaku; reviewed by Chris Lohfink, Bret McGuire for CASSANDRA-19468
---
 .../core/metadata/MetadataManager.java        | 53 ++++++++++---------
 .../core/metadata/MetadataManagerTest.java    | 23 ++++++++
 2 files changed, 52 insertions(+), 24 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/MetadataManager.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/MetadataManager.java
index 28e8b18f127..c9abfb7a625 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/MetadataManager.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/MetadataManager.java
@@ -437,30 +437,35 @@ private void startSchemaRequest(CompletableFuture<RefreshSchemaResult> refreshFu
                   if (agreementError != null) {
                     refreshFuture.completeExceptionally(agreementError);
                   } else {
-                    schemaQueriesFactory
-                        .newInstance()
-                        .execute()
-                        .thenApplyAsync(this::parseAndApplySchemaRows, adminExecutor)
-                        .whenComplete(
-                            (newMetadata, metadataError) -> {
-                              if (metadataError != null) {
-                                refreshFuture.completeExceptionally(metadataError);
-                              } else {
-                                refreshFuture.complete(
-                                    new RefreshSchemaResult(newMetadata, schemaInAgreement));
-                              }
-
-                              firstSchemaRefreshFuture.complete(null);
-
-                              currentSchemaRefresh = null;
-                              // If another refresh was enqueued during this one, run it now
-                              if (queuedSchemaRefresh != null) {
-                                CompletableFuture<RefreshSchemaResult> tmp =
-                                    this.queuedSchemaRefresh;
-                                this.queuedSchemaRefresh = null;
-                                startSchemaRequest(tmp);
-                              }
-                            });
+                    try {
+                      schemaQueriesFactory
+                              .newInstance()
+                              .execute()
+                              .thenApplyAsync(this::parseAndApplySchemaRows, adminExecutor)
+                              .whenComplete(
+                                      (newMetadata, metadataError) -> {
+                                        if (metadataError != null) {
+                                          refreshFuture.completeExceptionally(metadataError);
+                                        } else {
+                                          refreshFuture.complete(
+                                                  new RefreshSchemaResult(newMetadata, schemaInAgreement));
+                                        }
+
+                                        firstSchemaRefreshFuture.complete(null);
+
+                                        currentSchemaRefresh = null;
+                                        // If another refresh was enqueued during this one, run it now
+                                        if (queuedSchemaRefresh != null) {
+                                          CompletableFuture<RefreshSchemaResult> tmp =
+                                                  this.queuedSchemaRefresh;
+                                          this.queuedSchemaRefresh = null;
+                                          startSchemaRequest(tmp);
+                                        }
+                                      });
+                    } catch (Throwable t) {
+                      LOG.debug("[{}] Exception getting new metadata", logPrefix, t);
+                      refreshFuture.completeExceptionally(t);
+                    }
                   }
                 });
       } else if (queuedSchemaRefresh == null) {
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/MetadataManagerTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/MetadataManagerTest.java
index 460f99abd85..375209d9fcf 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/MetadataManagerTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/MetadataManagerTest.java
@@ -20,6 +20,7 @@
 import static com.datastax.oss.driver.Assertions.assertThat;
 import static com.datastax.oss.driver.Assertions.assertThatStage;
 import static org.awaitility.Awaitility.await;
+import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
@@ -33,6 +34,7 @@
 import com.datastax.oss.driver.internal.core.context.EventBus;
 import com.datastax.oss.driver.internal.core.context.InternalDriverContext;
 import com.datastax.oss.driver.internal.core.context.NettyOptions;
+import com.datastax.oss.driver.internal.core.control.ControlConnection;
 import com.datastax.oss.driver.internal.core.metadata.schema.parsing.SchemaParserFactory;
 import com.datastax.oss.driver.internal.core.metadata.schema.queries.SchemaQueriesFactory;
 import com.datastax.oss.driver.internal.core.metrics.MetricsFactory;
@@ -64,6 +66,7 @@ public class MetadataManagerTest {
 
   @Mock private InternalDriverContext context;
   @Mock private NettyOptions nettyOptions;
+  @Mock private ControlConnection controlConnection;
   @Mock private TopologyMonitor topologyMonitor;
   @Mock private DriverConfig config;
   @Mock private DriverExecutionProfile defaultProfile;
@@ -85,6 +88,7 @@ public void setup() {
     when(context.getNettyOptions()).thenReturn(nettyOptions);
 
     when(context.getTopologyMonitor()).thenReturn(topologyMonitor);
+    when(context.getControlConnection()).thenReturn(controlConnection);
 
     when(defaultProfile.getDuration(DefaultDriverOption.METADATA_SCHEMA_WINDOW))
         .thenReturn(Duration.ZERO);
@@ -286,6 +290,25 @@ public void should_remove_node() {
     assertThat(refresh.broadcastRpcAddressToRemove).isEqualTo(broadcastRpcAddress2);
   }
 
+  @Test
+  public void refreshSchema_should_work() {
+    // Given
+    IllegalStateException expectedException = new IllegalStateException("Error we're testing");
+    when(schemaQueriesFactory.newInstance()).thenThrow(expectedException);
+    when(topologyMonitor.refreshNodeList()).thenReturn(CompletableFuture.completedFuture(ImmutableList.of(mock(NodeInfo.class))));
+    when(topologyMonitor.checkSchemaAgreement()).thenReturn(CompletableFuture.completedFuture(Boolean.TRUE));
+    when(controlConnection.init(anyBoolean(), anyBoolean(), anyBoolean())).thenReturn(CompletableFuture.completedFuture(null));
+    metadataManager.refreshNodes(); // required internal state setup for this
+    waitForPendingAdminTasks(() -> metadataManager.refreshes.size() == 1); // sanity check
+
+    // When
+    CompletionStage<MetadataManager.RefreshSchemaResult> result = metadataManager.refreshSchema("foo", true, true);
+
+    // Then
+    waitForPendingAdminTasks(() -> result.toCompletableFuture().isDone());
+    assertThatStage(result).isFailed(t -> assertThat(t).isEqualTo(expectedException));
+  }
+
   private static class TestMetadataManager extends MetadataManager {
 
     private List<MetadataRefresh> refreshes = new CopyOnWriteArrayList<>();

From 388a46b9c10b5653c71ac8840bcda0c91b59bce4 Mon Sep 17 00:00:00 2001
From: janehe <siyaoh4@uci.edu>
Date: Fri, 12 Apr 2024 13:20:33 -0700
Subject: [PATCH 011/126] patch by Jane He; reviewed by Alexandre Dutra and
 Bret McGuire for CASSANDRA-19457

---
 .../core/metrics/AbstractMetricUpdater.java       |  2 --
 .../core/metrics/DropwizardMetricUpdater.java     |  2 +-
 .../internal/core/metrics/MetricUpdater.java      |  2 ++
 .../core/metrics/NoopNodeMetricUpdater.java       |  5 +++++
 .../core/metrics/NoopSessionMetricUpdater.java    |  3 +++
 .../internal/core/session/DefaultSession.java     | 15 +++++++++++++++
 .../driver/core/metrics/DropwizardMetricsIT.java  |  6 ++++++
 .../oss/driver/core/metrics/MetricsITBase.java    | 10 ++++++++--
 .../metrics/micrometer/MicrometerMetricsIT.java   |  6 ++++++
 .../microprofile/MicroProfileMetricsIT.java       |  6 ++++++
 .../micrometer/MicrometerMetricUpdater.java       |  2 +-
 .../microprofile/MicroProfileMetricUpdater.java   |  2 +-
 12 files changed, 54 insertions(+), 7 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/AbstractMetricUpdater.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/AbstractMetricUpdater.java
index fcfe56b605e..5e2392a2e7f 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/AbstractMetricUpdater.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/AbstractMetricUpdater.java
@@ -180,6 +180,4 @@ protected Timeout newTimeout() {
             expireAfter.toNanos(),
             TimeUnit.NANOSECONDS);
   }
-
-  protected abstract void clearMetrics();
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/DropwizardMetricUpdater.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/DropwizardMetricUpdater.java
index 8590917be21..9377fb3a17e 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/DropwizardMetricUpdater.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/DropwizardMetricUpdater.java
@@ -91,7 +91,7 @@ public void updateTimer(
   }
 
   @Override
-  protected void clearMetrics() {
+  public void clearMetrics() {
     for (MetricT metric : metrics.keySet()) {
       MetricId id = getMetricId(metric);
       registry.remove(id.getName());
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/MetricUpdater.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/MetricUpdater.java
index c4b432f3c50..c07d1b136af 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/MetricUpdater.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/MetricUpdater.java
@@ -46,4 +46,6 @@ default void markMeter(MetricT metric, @Nullable String profileName) {
   void updateTimer(MetricT metric, @Nullable String profileName, long duration, TimeUnit unit);
 
   boolean isEnabled(MetricT metric, @Nullable String profileName);
+
+  void clearMetrics();
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/NoopNodeMetricUpdater.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/NoopNodeMetricUpdater.java
index 45f0797c7b5..8d216990331 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/NoopNodeMetricUpdater.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/NoopNodeMetricUpdater.java
@@ -53,4 +53,9 @@ public boolean isEnabled(NodeMetric metric, String profileName) {
     // since methods don't do anything, return false
     return false;
   }
+
+  @Override
+  public void clearMetrics() {
+    // nothing to do
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/NoopSessionMetricUpdater.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/NoopSessionMetricUpdater.java
index 1666261590c..7099a8ddcac 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/NoopSessionMetricUpdater.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/NoopSessionMetricUpdater.java
@@ -53,4 +53,7 @@ public boolean isEnabled(SessionMetric metric, String profileName) {
     // since methods don't do anything, return false
     return false;
   }
+
+  @Override
+  public void clearMetrics() {}
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java b/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
index af9dc183f7e..cb1271c9cba 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
@@ -34,6 +34,7 @@
 import com.datastax.oss.driver.internal.core.channel.DriverChannel;
 import com.datastax.oss.driver.internal.core.context.InternalDriverContext;
 import com.datastax.oss.driver.internal.core.context.LifecycleListener;
+import com.datastax.oss.driver.internal.core.metadata.DefaultNode;
 import com.datastax.oss.driver.internal.core.metadata.MetadataManager;
 import com.datastax.oss.driver.internal.core.metadata.MetadataManager.RefreshSchemaResult;
 import com.datastax.oss.driver.internal.core.metadata.NodeStateEvent;
@@ -546,6 +547,13 @@ private void close() {
 
       closePolicies();
 
+      // clear metrics to prevent memory leak
+      for (Node n : metadataManager.getMetadata().getNodes().values()) {
+        ((DefaultNode) n).getMetricUpdater().clearMetrics();
+      }
+
+      DefaultSession.this.metricUpdater.clearMetrics();
+
       List<CompletionStage<Void>> childrenCloseStages = new ArrayList<>();
       for (AsyncAutoCloseable closeable : internalComponentsToClose()) {
         childrenCloseStages.add(closeable.closeAsync());
@@ -565,6 +573,13 @@ private void forceClose() {
           logPrefix,
           (closeWasCalled ? "" : "not "));
 
+      // clear metrics to prevent memory leak
+      for (Node n : metadataManager.getMetadata().getNodes().values()) {
+        ((DefaultNode) n).getMetricUpdater().clearMetrics();
+      }
+
+      DefaultSession.this.metricUpdater.clearMetrics();
+
       if (closeWasCalled) {
         // onChildrenClosed has already been scheduled
         for (AsyncAutoCloseable closeable : internalComponentsToClose()) {
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/DropwizardMetricsIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/DropwizardMetricsIT.java
index 6cbe443f2a6..e0184516e21 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/DropwizardMetricsIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/DropwizardMetricsIT.java
@@ -198,6 +198,12 @@ protected void assertNodeMetricsNotEvicted(CqlSession session, Node node) {
     }
   }
 
+  @Override
+  protected void assertMetricsNotPresent(Object registry) {
+    MetricRegistry dropwizardRegistry = (MetricRegistry) registry;
+    assertThat(dropwizardRegistry.getMetrics()).isEmpty();
+  }
+
   @Override
   protected void assertNodeMetricsEvicted(CqlSession session, Node node) {
     InternalDriverContext context = (InternalDriverContext) session.getContext();
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/MetricsITBase.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/MetricsITBase.java
index 7fac3f98f52..e6121217619 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/MetricsITBase.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/MetricsITBase.java
@@ -83,8 +83,10 @@ public void resetSimulacron() {
 
   @Test
   @UseDataProvider("descriptorsAndPrefixes")
-  public void should_expose_metrics_if_enabled(Class<?> metricIdGenerator, String prefix) {
+  public void should_expose_metrics_if_enabled_and_clear_metrics_if_closed(
+      Class<?> metricIdGenerator, String prefix) {
 
+    Object registry = newMetricRegistry();
     Assume.assumeFalse(
         "Cannot use metric tags with Dropwizard",
         metricIdGenerator.getSimpleName().contains("Tagging")
@@ -101,12 +103,14 @@ public void should_expose_metrics_if_enabled(Class<?> metricIdGenerator, String
         CqlSession.builder()
             .addContactEndPoints(simulacron().getContactPoints())
             .withConfigLoader(loader)
-            .withMetricRegistry(newMetricRegistry())
+            .withMetricRegistry(registry)
             .build()) {
 
       session.prepare("irrelevant");
       queryAllNodes(session);
       assertMetricsPresent(session);
+    } finally {
+      assertMetricsNotPresent(registry);
     }
   }
 
@@ -262,4 +266,6 @@ private DefaultNode findNode(CqlSession session, int id) {
     return (DefaultNode)
         session.getMetadata().findNode(address1).orElseThrow(IllegalStateException::new);
   }
+
+  protected abstract void assertMetricsNotPresent(Object registry);
 }
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/metrics/micrometer/MicrometerMetricsIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/metrics/micrometer/MicrometerMetricsIT.java
index 5fe64719327..c38df1e2026 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/metrics/micrometer/MicrometerMetricsIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/metrics/micrometer/MicrometerMetricsIT.java
@@ -186,6 +186,12 @@ protected void assertNodeMetricsNotEvicted(CqlSession session, Node node) {
     }
   }
 
+  @Override
+  protected void assertMetricsNotPresent(Object registry) {
+    MeterRegistry micrometerRegistry = (MeterRegistry) registry;
+    assertThat(micrometerRegistry.getMeters()).isEmpty();
+  }
+
   @Override
   protected void assertNodeMetricsEvicted(CqlSession session, Node node) {
     InternalDriverContext context = (InternalDriverContext) session.getContext();
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/metrics/microprofile/MicroProfileMetricsIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/metrics/microprofile/MicroProfileMetricsIT.java
index 1294be3deae..aa04c058a49 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/metrics/microprofile/MicroProfileMetricsIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/metrics/microprofile/MicroProfileMetricsIT.java
@@ -188,6 +188,12 @@ protected void assertNodeMetricsNotEvicted(CqlSession session, Node node) {
     }
   }
 
+  @Override
+  protected void assertMetricsNotPresent(Object registry) {
+    MetricRegistry metricRegistry = (MetricRegistry) registry;
+    assertThat(metricRegistry.getMetrics()).isEmpty();
+  }
+
   @Override
   protected void assertNodeMetricsEvicted(CqlSession session, Node node) {
     InternalDriverContext context = (InternalDriverContext) session.getContext();
diff --git a/metrics/micrometer/src/main/java/com/datastax/oss/driver/internal/metrics/micrometer/MicrometerMetricUpdater.java b/metrics/micrometer/src/main/java/com/datastax/oss/driver/internal/metrics/micrometer/MicrometerMetricUpdater.java
index 7a4a27991e3..b9507c8b7cf 100644
--- a/metrics/micrometer/src/main/java/com/datastax/oss/driver/internal/metrics/micrometer/MicrometerMetricUpdater.java
+++ b/metrics/micrometer/src/main/java/com/datastax/oss/driver/internal/metrics/micrometer/MicrometerMetricUpdater.java
@@ -83,7 +83,7 @@ public void updateTimer(
   }
 
   @Override
-  protected void clearMetrics() {
+  public void clearMetrics() {
     for (Meter metric : metrics.values()) {
       registry.remove(metric);
     }
diff --git a/metrics/microprofile/src/main/java/com/datastax/oss/driver/internal/metrics/microprofile/MicroProfileMetricUpdater.java b/metrics/microprofile/src/main/java/com/datastax/oss/driver/internal/metrics/microprofile/MicroProfileMetricUpdater.java
index a46e82ee624..df44fd69c51 100644
--- a/metrics/microprofile/src/main/java/com/datastax/oss/driver/internal/metrics/microprofile/MicroProfileMetricUpdater.java
+++ b/metrics/microprofile/src/main/java/com/datastax/oss/driver/internal/metrics/microprofile/MicroProfileMetricUpdater.java
@@ -83,7 +83,7 @@ public void updateTimer(
   }
 
   @Override
-  protected void clearMetrics() {
+  public void clearMetrics() {
     for (MetricT metric : metrics.keySet()) {
       MetricId id = getMetricId(metric);
       Tag[] tags = MicroProfileTags.toMicroProfileTags(id.getTags());

From c8b17ac38b48ca580b4862571cdfd7b7633a5793 Mon Sep 17 00:00:00 2001
From: Bret McGuire <bret.mcguire@datastax.com>
Date: Mon, 19 Feb 2024 23:07:18 -0600
Subject: [PATCH 012/126] Changelog updates to reflect work that went out in
 4.18.0

Patch by Bret McGuire; reviewed by Bret McGuire, Alexandre Dutra for PR 1914
---
 changelog/README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/changelog/README.md b/changelog/README.md
index 8ff2913b72d..7807ef15f95 100644
--- a/changelog/README.md
+++ b/changelog/README.md
@@ -21,6 +21,16 @@ under the License.
 
 <!-- Note: contrary to 3.x, insert new entries *first* in their section -->
 
+### 4.18.0
+
+- [improvement] PR 1689: Add support for publishing percentile time series for the histogram metrics (nparaddi-walmart)
+- [improvement] JAVA-3104: Do not eagerly pre-allocate array when deserializing CqlVector
+- [improvement] JAVA-3111: upgrade jackson-databind to 2.13.4.2 to address gradle dependency issue
+- [improvement] PR 1617: Improve ByteBufPrimitiveCodec readBytes (chibenwa)
+- [improvement] JAVA-3095: Fix CREATE keyword in vector search example in upgrade guide
+- [improvement] JAVA-3100: Update jackson-databind to 2.13.4.1 and jackson-jaxrs-json-provider to 2.13.4 to address recent CVEs
+- [improvement] JAVA-3089: Forbid wildcard imports
+
 ### 4.17.0
 
 - [improvement] JAVA-3070: Make CqlVector and CqlDuration serializable

From 3c08f8efa24cddb33b807a5e1f8f16824632a611 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Wed, 17 Apr 2024 01:34:40 -0500
Subject: [PATCH 013/126] Fixes to get past code formatting issues

patch by Bret McGuire; reviewed by Bret McGuire for PR 1928
---
 .../core/metadata/MetadataManager.java        | 46 +++++++++----------
 .../core/metadata/MetadataManagerTest.java    | 12 +++--
 2 files changed, 31 insertions(+), 27 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/MetadataManager.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/MetadataManager.java
index c9abfb7a625..efb04bde5e1 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/MetadataManager.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/MetadataManager.java
@@ -439,29 +439,29 @@ private void startSchemaRequest(CompletableFuture<RefreshSchemaResult> refreshFu
                   } else {
                     try {
                       schemaQueriesFactory
-                              .newInstance()
-                              .execute()
-                              .thenApplyAsync(this::parseAndApplySchemaRows, adminExecutor)
-                              .whenComplete(
-                                      (newMetadata, metadataError) -> {
-                                        if (metadataError != null) {
-                                          refreshFuture.completeExceptionally(metadataError);
-                                        } else {
-                                          refreshFuture.complete(
-                                                  new RefreshSchemaResult(newMetadata, schemaInAgreement));
-                                        }
-
-                                        firstSchemaRefreshFuture.complete(null);
-
-                                        currentSchemaRefresh = null;
-                                        // If another refresh was enqueued during this one, run it now
-                                        if (queuedSchemaRefresh != null) {
-                                          CompletableFuture<RefreshSchemaResult> tmp =
-                                                  this.queuedSchemaRefresh;
-                                          this.queuedSchemaRefresh = null;
-                                          startSchemaRequest(tmp);
-                                        }
-                                      });
+                          .newInstance()
+                          .execute()
+                          .thenApplyAsync(this::parseAndApplySchemaRows, adminExecutor)
+                          .whenComplete(
+                              (newMetadata, metadataError) -> {
+                                if (metadataError != null) {
+                                  refreshFuture.completeExceptionally(metadataError);
+                                } else {
+                                  refreshFuture.complete(
+                                      new RefreshSchemaResult(newMetadata, schemaInAgreement));
+                                }
+
+                                firstSchemaRefreshFuture.complete(null);
+
+                                currentSchemaRefresh = null;
+                                // If another refresh was enqueued during this one, run it now
+                                if (queuedSchemaRefresh != null) {
+                                  CompletableFuture<RefreshSchemaResult> tmp =
+                                      this.queuedSchemaRefresh;
+                                  this.queuedSchemaRefresh = null;
+                                  startSchemaRequest(tmp);
+                                }
+                              });
                     } catch (Throwable t) {
                       LOG.debug("[{}] Exception getting new metadata", logPrefix, t);
                       refreshFuture.completeExceptionally(t);
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/MetadataManagerTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/MetadataManagerTest.java
index 375209d9fcf..f9a909400f9 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/MetadataManagerTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/MetadataManagerTest.java
@@ -295,14 +295,18 @@ public void refreshSchema_should_work() {
     // Given
     IllegalStateException expectedException = new IllegalStateException("Error we're testing");
     when(schemaQueriesFactory.newInstance()).thenThrow(expectedException);
-    when(topologyMonitor.refreshNodeList()).thenReturn(CompletableFuture.completedFuture(ImmutableList.of(mock(NodeInfo.class))));
-    when(topologyMonitor.checkSchemaAgreement()).thenReturn(CompletableFuture.completedFuture(Boolean.TRUE));
-    when(controlConnection.init(anyBoolean(), anyBoolean(), anyBoolean())).thenReturn(CompletableFuture.completedFuture(null));
+    when(topologyMonitor.refreshNodeList())
+        .thenReturn(CompletableFuture.completedFuture(ImmutableList.of(mock(NodeInfo.class))));
+    when(topologyMonitor.checkSchemaAgreement())
+        .thenReturn(CompletableFuture.completedFuture(Boolean.TRUE));
+    when(controlConnection.init(anyBoolean(), anyBoolean(), anyBoolean()))
+        .thenReturn(CompletableFuture.completedFuture(null));
     metadataManager.refreshNodes(); // required internal state setup for this
     waitForPendingAdminTasks(() -> metadataManager.refreshes.size() == 1); // sanity check
 
     // When
-    CompletionStage<MetadataManager.RefreshSchemaResult> result = metadataManager.refreshSchema("foo", true, true);
+    CompletionStage<MetadataManager.RefreshSchemaResult> result =
+        metadataManager.refreshSchema("foo", true, true);
 
     // Then
     waitForPendingAdminTasks(() -> result.toCompletableFuture().isDone());

From 07265b4a6830a47752bf31eb4f631b9917863da2 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Tue, 23 Apr 2024 00:38:48 -0500
Subject: [PATCH 014/126] Initial fix to unit tests

patch by Bret McGuire; reviewed by Bret McGuire for PR 1930
---
 .../driver/internal/core/session/DefaultSession.java  | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java b/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
index cb1271c9cba..6f063ae9a50 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
@@ -39,6 +39,7 @@
 import com.datastax.oss.driver.internal.core.metadata.MetadataManager.RefreshSchemaResult;
 import com.datastax.oss.driver.internal.core.metadata.NodeStateEvent;
 import com.datastax.oss.driver.internal.core.metadata.NodeStateManager;
+import com.datastax.oss.driver.internal.core.metrics.NodeMetricUpdater;
 import com.datastax.oss.driver.internal.core.metrics.SessionMetricUpdater;
 import com.datastax.oss.driver.internal.core.pool.ChannelPool;
 import com.datastax.oss.driver.internal.core.util.Loggers;
@@ -549,10 +550,11 @@ private void close() {
 
       // clear metrics to prevent memory leak
       for (Node n : metadataManager.getMetadata().getNodes().values()) {
-        ((DefaultNode) n).getMetricUpdater().clearMetrics();
+        NodeMetricUpdater updater = ((DefaultNode) n).getMetricUpdater();
+        if (updater != null) updater.clearMetrics();
       }
 
-      DefaultSession.this.metricUpdater.clearMetrics();
+      if (metricUpdater != null) metricUpdater.clearMetrics();
 
       List<CompletionStage<Void>> childrenCloseStages = new ArrayList<>();
       for (AsyncAutoCloseable closeable : internalComponentsToClose()) {
@@ -575,10 +577,11 @@ private void forceClose() {
 
       // clear metrics to prevent memory leak
       for (Node n : metadataManager.getMetadata().getNodes().values()) {
-        ((DefaultNode) n).getMetricUpdater().clearMetrics();
+        NodeMetricUpdater updater = ((DefaultNode) n).getMetricUpdater();
+        if (updater != null) updater.clearMetrics();
       }
 
-      DefaultSession.this.metricUpdater.clearMetrics();
+      if (metricUpdater != null) metricUpdater.clearMetrics();
 
       if (closeWasCalled) {
         // onChildrenClosed has already been scheduled

From 1492d6ced9d54bdd68deb043a0bfe232eaa2a8fc Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Fri, 29 Mar 2024 00:46:46 -0500
Subject: [PATCH 015/126] CASSANDRA-19292: Enable Jenkins to test against
 Cassandra 4.1.x

patch by Bret McGuire; reviewed by Bret McGuire, Alexandre Dutra for CASSANDRA-19292
---
 Jenkinsfile                                   | 20 ++++--
 .../datastax/oss/driver/api/core/Version.java |  1 +
 .../oss/driver/core/metadata/SchemaIT.java    | 13 ++++
 .../driver/api/testinfra/ccm/CcmBridge.java   | 61 ++++++++++++++++++-
 4 files changed, 86 insertions(+), 9 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 8d2b74c5b08..0bfa4ca7f4a 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -256,8 +256,10 @@ pipeline {
       choices: ['2.1',       // Legacy Apache CassandraⓇ
                 '2.2',       // Legacy Apache CassandraⓇ
                 '3.0',       // Previous Apache CassandraⓇ
-                '3.11',      // Current Apache CassandraⓇ
-                '4.0',       // Development Apache CassandraⓇ
+                '3.11',      // Previous Apache CassandraⓇ
+                '4.0',       // Previous Apache CassandraⓇ
+                '4.1',       // Current Apache CassandraⓇ
+                '5.0',       // Development Apache CassandraⓇ
                 'dse-4.8.16',   // Previous EOSL DataStax Enterprise
                 'dse-5.0.15',   // Long Term Support DataStax Enterprise
                 'dse-5.1.35',   // Legacy DataStax Enterprise
@@ -291,7 +293,11 @@ pipeline {
                         </tr>
                         <tr>
                           <td><strong>4.0</strong></td>
-                          <td>Apache Cassandra&reg; v4.x (<b>CURRENTLY UNDER DEVELOPMENT</b>)</td>
+                          <td>Apache Cassandra&reg; v4.0.x</td>
+                        </tr>
+                        <tr>
+                          <td><strong>4.1</strong></td>
+                          <td>Apache Cassandra&reg; v4.1.x</td>
                         </tr>
                         <tr>
                           <td><strong>dse-4.8.16</strong></td>
@@ -445,7 +451,7 @@ pipeline {
           axis {
             name 'SERVER_VERSION'
             values '3.11',     // Latest stable Apache CassandraⓇ
-                   '4.0',      // Development Apache CassandraⓇ
+                   '4.1',      // Development Apache CassandraⓇ
                    'dse-6.8.30' // Current DataStax Enterprise
           }
           axis {
@@ -554,8 +560,10 @@ pipeline {
             name 'SERVER_VERSION'
             values '2.1',       // Legacy Apache CassandraⓇ
                    '3.0',       // Previous Apache CassandraⓇ
-                   '3.11',      // Current Apache CassandraⓇ
-                   '4.0',       // Development Apache CassandraⓇ
+                   '3.11',      // Previous Apache CassandraⓇ
+                   '4.0',       // Previous Apache CassandraⓇ
+                   '4.1',       // Current Apache CassandraⓇ
+                   '5.0',       // Development Apache CassandraⓇ
                    'dse-4.8.16',   // Previous EOSL DataStax Enterprise
                    'dse-5.0.15',   // Last EOSL DataStax Enterprise
                    'dse-5.1.35',   // Legacy DataStax Enterprise
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/Version.java b/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
index cc4931fe2fa..3f12c54faf7 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
@@ -52,6 +52,7 @@ public class Version implements Comparable<Version>, Serializable {
   @NonNull public static final Version V2_2_0 = Objects.requireNonNull(parse("2.2.0"));
   @NonNull public static final Version V3_0_0 = Objects.requireNonNull(parse("3.0.0"));
   @NonNull public static final Version V4_0_0 = Objects.requireNonNull(parse("4.0.0"));
+  @NonNull public static final Version V4_1_0 = Objects.requireNonNull(parse("4.1.0"));
   @NonNull public static final Version V5_0_0 = Objects.requireNonNull(parse("5.0.0"));
   @NonNull public static final Version V6_7_0 = Objects.requireNonNull(parse("6.7.0"));
   @NonNull public static final Version V6_8_0 = Objects.requireNonNull(parse("6.8.0"));
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
index caa96a647be..6495b451df7 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
@@ -265,6 +265,19 @@ public void should_get_virtual_metadata() {
                   + "    total bigint,\n"
                   + "    unit text,\n"
                   + "    PRIMARY KEY (keyspace_name, table_name, task_id)\n"
+                  + "); */",
+              // Cassandra 4.1
+              "/* VIRTUAL TABLE system_views.sstable_tasks (\n"
+                  + "    keyspace_name text,\n"
+                  + "    table_name text,\n"
+                  + "    task_id timeuuid,\n"
+                  + "    completion_ratio double,\n"
+                  + "    kind text,\n"
+                  + "    progress bigint,\n"
+                  + "    sstables int,\n"
+                  + "    total bigint,\n"
+                  + "    unit text,\n"
+                  + "    PRIMARY KEY (keyspace_name, table_name, task_id)\n"
                   + "); */");
       // ColumnMetadata is as expected
       ColumnMetadata cm = tm.getColumn("progress").get();
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
index 5f845243bf8..98739e7715d 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
@@ -236,12 +236,33 @@ public void create() {
           Arrays.stream(nodes).mapToObj(n -> "" + n).collect(Collectors.joining(":")),
           createOptions.stream().collect(Collectors.joining(" ")));
 
+      Version cassandraVersion = getCassandraVersion();
       for (Map.Entry<String, Object> conf : cassandraConfiguration.entrySet()) {
-        execute("updateconf", String.format("%s:%s", conf.getKey(), conf.getValue()));
+        String originalKey = conf.getKey();
+        Object originalValue = conf.getValue();
+        execute(
+            "updateconf",
+            String.join(
+                ":",
+                getConfigKey(originalKey, originalValue, cassandraVersion),
+                getConfigValue(originalKey, originalValue, cassandraVersion)));
       }
-      if (getCassandraVersion().compareTo(Version.V2_2_0) >= 0) {
-        execute("updateconf", "enable_user_defined_functions:true");
+
+      // If we're dealing with anything more recent than 2.2 explicitly enable UDF... but run it
+      // through our conversion process to make
+      // sure more recent versions don't have a problem.
+      if (cassandraVersion.compareTo(Version.V2_2_0) >= 0) {
+        String originalKey = "enable_user_defined_functions";
+        Object originalValue = "true";
+        execute(
+            "updateconf",
+            String.join(
+                ":",
+                getConfigKey(originalKey, originalValue, cassandraVersion),
+                getConfigValue(originalKey, originalValue, cassandraVersion)));
       }
+
+      // Note that we aren't performing any substitution on DSE key/value props (at least for now)
       if (DSE_ENABLEMENT) {
         for (Map.Entry<String, Object> conf : dseConfiguration.entrySet()) {
           execute("updatedseconf", String.format("%s:%s", conf.getKey(), conf.getValue()));
@@ -463,6 +484,40 @@ private Optional<Integer> overrideJvmVersionForDseWorkloads() {
     return Optional.empty();
   }
 
+  private static String IN_MS_STR = "_in_ms";
+  private static int IN_MS_STR_LENGTH = IN_MS_STR.length();
+  private static String ENABLE_STR = "enable_";
+  private static int ENABLE_STR_LENGTH = ENABLE_STR.length();
+  private static String IN_KB_STR = "_in_kb";
+  private static int IN_KB_STR_LENGTH = IN_KB_STR.length();
+
+  @SuppressWarnings("unused")
+  private String getConfigKey(String originalKey, Object originalValue, Version cassandraVersion) {
+
+    // At least for now we won't support substitutions on nested keys.  This requires an extra
+    // traversal of the string
+    // but we'll live with that for now
+    if (originalKey.contains(".")) return originalKey;
+    if (cassandraVersion.compareTo(Version.V4_1_0) < 0) return originalKey;
+    if (originalKey.endsWith(IN_MS_STR))
+      return originalKey.substring(0, originalKey.length() - IN_MS_STR_LENGTH);
+    if (originalKey.startsWith(ENABLE_STR))
+      return originalKey.substring(ENABLE_STR_LENGTH) + "_enabled";
+    if (originalKey.endsWith(IN_KB_STR))
+      return originalKey.substring(0, originalKey.length() - IN_KB_STR_LENGTH);
+    return originalKey;
+  }
+
+  private String getConfigValue(
+      String originalKey, Object originalValue, Version cassandraVersion) {
+
+    String originalValueStr = originalValue.toString();
+    if (cassandraVersion.compareTo(Version.V4_1_0) < 0) return originalValueStr;
+    if (originalKey.endsWith(IN_MS_STR)) return originalValueStr + "ms";
+    if (originalKey.endsWith(IN_KB_STR)) return originalValueStr + "KiB";
+    return originalValueStr;
+  }
+
   public static Builder builder() {
     return new Builder();
   }

From b9760b473b6e6e30f5da5f743e37e02150e13e39 Mon Sep 17 00:00:00 2001
From: Nitin Chhabra <nitin.chhabra@walmartlabs.com>
Date: Thu, 30 Nov 2023 12:38:23 -0800
Subject: [PATCH 016/126] JAVA-3142: Ability to specify ordering of remote
 local dc's via new configuration for graceful automatic failovers

patch by Nitin Chhabra; reviewed by Alexandre Dutra, Andy Tolbert, and Bret McGuire for JAVA-3142
---
 .../api/core/config/DefaultDriverOption.java  |   8 +-
 .../driver/api/core/config/OptionsMap.java    |   2 +
 .../api/core/config/TypedDriverOption.java    |  10 +
 .../BasicLoadBalancingPolicy.java             |  84 ++++++--
 core/src/main/resources/reference.conf        |   5 +
 ...BalancingPolicyPreferredRemoteDcsTest.java | 184 ++++++++++++++++++
 6 files changed, 271 insertions(+), 22 deletions(-)
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicyPreferredRemoteDcsTest.java

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
index afe16e96886..11f2702c3cf 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
@@ -982,7 +982,13 @@ public enum DefaultDriverOption implements DriverOption {
    * <p>Value-type: {@link java.time.Duration}
    */
   SSL_KEYSTORE_RELOAD_INTERVAL("advanced.ssl-engine-factory.keystore-reload-interval"),
-  ;
+  /**
+   * Ordered preference list of remote dcs optionally supplied for automatic failover.
+   *
+   * <p>Value type: {@link java.util.List List}&#60;{@link String}&#62;
+   */
+  LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS(
+      "advanced.load-balancing-policy.dc-failover.preferred-remote-dcs");
 
   private final String path;
 
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/OptionsMap.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/OptionsMap.java
index 8906e1dd349..98faf3e590c 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/OptionsMap.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/OptionsMap.java
@@ -381,6 +381,8 @@ protected static void fillWithDriverDefaults(OptionsMap map) {
     map.put(TypedDriverOption.LOAD_BALANCING_DC_FAILOVER_MAX_NODES_PER_REMOTE_DC, 0);
     map.put(TypedDriverOption.LOAD_BALANCING_DC_FAILOVER_ALLOW_FOR_LOCAL_CONSISTENCY_LEVELS, false);
     map.put(TypedDriverOption.METRICS_GENERATE_AGGREGABLE_HISTOGRAMS, true);
+    map.put(
+        TypedDriverOption.LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS, ImmutableList.of(""));
   }
 
   @Immutable
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
index 88c012fa351..ca60b67f0ba 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
@@ -892,6 +892,16 @@ public String toString() {
               DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_ALLOW_FOR_LOCAL_CONSISTENCY_LEVELS,
               GenericType.BOOLEAN);
 
+  /**
+   * Ordered preference list of remote dcs optionally supplied for automatic failover and included
+   * in query plan. This feature is enabled only when max-nodes-per-remote-dc is greater than 0.
+   */
+  public static final TypedDriverOption<List<String>>
+      LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS =
+          new TypedDriverOption<>(
+              DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS,
+              GenericType.listOf(String.class));
+
   private static Iterable<TypedDriverOption<?>> introspectBuiltInValues() {
     try {
       ImmutableList.Builder<TypedDriverOption<?>> result = ImmutableList.builder();
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java
index b1adec3f143..587ef4183bd 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java
@@ -45,10 +45,14 @@
 import com.datastax.oss.driver.internal.core.util.collection.QueryPlan;
 import com.datastax.oss.driver.internal.core.util.collection.SimpleQueryPlan;
 import com.datastax.oss.driver.shaded.guava.common.base.Predicates;
+import com.datastax.oss.driver.shaded.guava.common.collect.Lists;
+import com.datastax.oss.driver.shaded.guava.common.collect.Sets;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
 import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -117,6 +121,7 @@ public class BasicLoadBalancingPolicy implements LoadBalancingPolicy {
   private volatile NodeDistanceEvaluator nodeDistanceEvaluator;
   private volatile String localDc;
   private volatile NodeSet liveNodes;
+  private final LinkedHashSet<String> preferredRemoteDcs;
 
   public BasicLoadBalancingPolicy(@NonNull DriverContext context, @NonNull String profileName) {
     this.context = (InternalDriverContext) context;
@@ -131,6 +136,11 @@ public BasicLoadBalancingPolicy(@NonNull DriverContext context, @NonNull String
         this.context
             .getConsistencyLevelRegistry()
             .nameToLevel(profile.getString(DefaultDriverOption.REQUEST_CONSISTENCY));
+
+    preferredRemoteDcs =
+        new LinkedHashSet<>(
+            profile.getStringList(
+                DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS));
   }
 
   /**
@@ -320,27 +330,59 @@ protected Queue<Node> maybeAddDcFailover(@Nullable Request request, @NonNull Que
         return local;
       }
     }
-    QueryPlan remote =
-        new LazyQueryPlan() {
-
-          @Override
-          protected Object[] computeNodes() {
-            Object[] remoteNodes =
-                liveNodes.dcs().stream()
-                    .filter(Predicates.not(Predicates.equalTo(localDc)))
-                    .flatMap(dc -> liveNodes.dc(dc).stream().limit(maxNodesPerRemoteDc))
-                    .toArray();
-
-            int remoteNodesLength = remoteNodes.length;
-            if (remoteNodesLength == 0) {
-              return EMPTY_NODES;
-            }
-            shuffleHead(remoteNodes, remoteNodesLength);
-            return remoteNodes;
-          }
-        };
-
-    return new CompositeQueryPlan(local, remote);
+    if (preferredRemoteDcs.isEmpty()) {
+      return new CompositeQueryPlan(local, buildRemoteQueryPlanAll());
+    }
+    return new CompositeQueryPlan(local, buildRemoteQueryPlanPreferred());
+  }
+
+  private QueryPlan buildRemoteQueryPlanAll() {
+
+    return new LazyQueryPlan() {
+      @Override
+      protected Object[] computeNodes() {
+
+        Object[] remoteNodes =
+            liveNodes.dcs().stream()
+                .filter(Predicates.not(Predicates.equalTo(localDc)))
+                .flatMap(dc -> liveNodes.dc(dc).stream().limit(maxNodesPerRemoteDc))
+                .toArray();
+        if (remoteNodes.length == 0) {
+          return EMPTY_NODES;
+        }
+        shuffleHead(remoteNodes, remoteNodes.length);
+        return remoteNodes;
+      }
+    };
+  }
+
+  private QueryPlan buildRemoteQueryPlanPreferred() {
+
+    Set<String> dcs = liveNodes.dcs();
+    List<String> orderedDcs = Lists.newArrayListWithCapacity(dcs.size());
+    orderedDcs.addAll(preferredRemoteDcs);
+    orderedDcs.addAll(Sets.difference(dcs, preferredRemoteDcs));
+
+    QueryPlan[] queryPlans =
+        orderedDcs.stream()
+            .filter(Predicates.not(Predicates.equalTo(localDc)))
+            .map(
+                (dc) -> {
+                  return new LazyQueryPlan() {
+                    @Override
+                    protected Object[] computeNodes() {
+                      Object[] rv = liveNodes.dc(dc).stream().limit(maxNodesPerRemoteDc).toArray();
+                      if (rv.length == 0) {
+                        return EMPTY_NODES;
+                      }
+                      shuffleHead(rv, rv.length);
+                      return rv;
+                    }
+                  };
+                })
+            .toArray(QueryPlan[]::new);
+
+    return new CompositeQueryPlan(queryPlans);
   }
 
   /** Exposed as a protected method so that it can be accessed by tests */
diff --git a/core/src/main/resources/reference.conf b/core/src/main/resources/reference.conf
index d1ac22e553b..7a56a18e9f1 100644
--- a/core/src/main/resources/reference.conf
+++ b/core/src/main/resources/reference.conf
@@ -574,6 +574,11 @@ datastax-java-driver {
       # Modifiable at runtime: no
       # Overridable in a profile: yes
       allow-for-local-consistency-levels = false
+      # Ordered preference list of remote dc's (in order) optionally supplied for automatic failover. While building a query plan, the driver uses the DC's supplied in order together with max-nodes-per-remote-dc
+      # Required: no
+      # Modifiable at runtime: no
+      # Overridable in a profile: no
+      preferred-remote-dcs = [""]
     }
   }
 
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicyPreferredRemoteDcsTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicyPreferredRemoteDcsTest.java
new file mode 100644
index 00000000000..cefdfd31189
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicyPreferredRemoteDcsTest.java
@@ -0,0 +1,184 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.loadbalancing;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
+import com.datastax.oss.driver.api.core.config.DriverExecutionProfile;
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.datastax.oss.driver.internal.core.metadata.DefaultNode;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableSet;
+import java.util.Map;
+import java.util.UUID;
+import org.junit.Test;
+import org.mockito.Mock;
+
+public class BasicLoadBalancingPolicyPreferredRemoteDcsTest
+    extends BasicLoadBalancingPolicyDcFailoverTest {
+  @Mock protected DefaultNode node10;
+  @Mock protected DefaultNode node11;
+  @Mock protected DefaultNode node12;
+  @Mock protected DefaultNode node13;
+  @Mock protected DefaultNode node14;
+
+  @Override
+  @Test
+  public void should_prioritize_single_replica() {
+    when(request.getRoutingKeyspace()).thenReturn(KEYSPACE);
+    when(request.getRoutingKey()).thenReturn(ROUTING_KEY);
+    when(tokenMap.getReplicas(KEYSPACE, ROUTING_KEY)).thenReturn(ImmutableSet.of(node3));
+
+    // node3 always first, round-robin on the rest
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node3, node1, node2, node4, node5, node9, node10, node6, node7, node12, node13);
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node3, node2, node4, node5, node1, node9, node10, node6, node7, node12, node13);
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node3, node4, node5, node1, node2, node9, node10, node6, node7, node12, node13);
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node3, node5, node1, node2, node4, node9, node10, node6, node7, node12, node13);
+
+    // Should not shuffle replicas since there is only one
+    verify(policy, never()).shuffleHead(any(), eq(1));
+    // But should shuffle remote nodes
+    verify(policy, times(12)).shuffleHead(any(), eq(2));
+  }
+
+  @Override
+  @Test
+  public void should_prioritize_and_shuffle_replicas() {
+    when(request.getRoutingKeyspace()).thenReturn(KEYSPACE);
+    when(request.getRoutingKey()).thenReturn(ROUTING_KEY);
+    when(tokenMap.getReplicas(KEYSPACE, ROUTING_KEY))
+        .thenReturn(ImmutableSet.of(node1, node2, node3, node6, node9));
+
+    // node 6 and 9 being in a remote DC, they don't get a boost for being a replica
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node1, node2, node3, node4, node5, node9, node10, node6, node7, node12, node13);
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node1, node2, node3, node5, node4, node9, node10, node6, node7, node12, node13);
+
+    // should shuffle replicas
+    verify(policy, times(2)).shuffleHead(any(), eq(3));
+    // should shuffle remote nodes
+    verify(policy, times(6)).shuffleHead(any(), eq(2));
+    // No power of two choices with only two replicas
+    verify(session, never()).getPools();
+  }
+
+  @Override
+  protected void assertRoundRobinQueryPlans() {
+    for (int i = 0; i < 3; i++) {
+      assertThat(policy.newQueryPlan(request, session))
+          .containsExactly(
+              node1, node2, node3, node4, node5, node9, node10, node6, node7, node12, node13);
+      assertThat(policy.newQueryPlan(request, session))
+          .containsExactly(
+              node2, node3, node4, node5, node1, node9, node10, node6, node7, node12, node13);
+      assertThat(policy.newQueryPlan(request, session))
+          .containsExactly(
+              node3, node4, node5, node1, node2, node9, node10, node6, node7, node12, node13);
+      assertThat(policy.newQueryPlan(request, session))
+          .containsExactly(
+              node4, node5, node1, node2, node3, node9, node10, node6, node7, node12, node13);
+      assertThat(policy.newQueryPlan(request, session))
+          .containsExactly(
+              node5, node1, node2, node3, node4, node9, node10, node6, node7, node12, node13);
+    }
+
+    verify(policy, atLeast(15)).shuffleHead(any(), eq(2));
+  }
+
+  @Override
+  protected BasicLoadBalancingPolicy createAndInitPolicy() {
+    when(node4.getDatacenter()).thenReturn("dc1");
+    when(node5.getDatacenter()).thenReturn("dc1");
+    when(node6.getDatacenter()).thenReturn("dc2");
+    when(node7.getDatacenter()).thenReturn("dc2");
+    when(node8.getDatacenter()).thenReturn("dc2");
+    when(node9.getDatacenter()).thenReturn("dc3");
+    when(node10.getDatacenter()).thenReturn("dc3");
+    when(node11.getDatacenter()).thenReturn("dc3");
+    when(node12.getDatacenter()).thenReturn("dc4");
+    when(node13.getDatacenter()).thenReturn("dc4");
+    when(node14.getDatacenter()).thenReturn("dc4");
+
+    // Accept 2 nodes per remote DC
+    when(defaultProfile.getInt(
+            DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_MAX_NODES_PER_REMOTE_DC))
+        .thenReturn(2);
+    when(defaultProfile.getBoolean(
+            DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_ALLOW_FOR_LOCAL_CONSISTENCY_LEVELS))
+        .thenReturn(false);
+
+    when(defaultProfile.getStringList(
+            DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS))
+        .thenReturn(ImmutableList.of("dc3", "dc2"));
+
+    // Use a subclass to disable shuffling, we just spy to make sure that the shuffling method was
+    // called (makes tests easier)
+    BasicLoadBalancingPolicy policy =
+        spy(
+            new BasicLoadBalancingPolicy(context, DriverExecutionProfile.DEFAULT_NAME) {
+              @Override
+              protected void shuffleHead(Object[] currentNodes, int headLength) {
+                // nothing (keep in same order)
+              }
+            });
+    Map<UUID, Node> nodes =
+        ImmutableMap.<UUID, Node>builder()
+            .put(UUID.randomUUID(), node1)
+            .put(UUID.randomUUID(), node2)
+            .put(UUID.randomUUID(), node3)
+            .put(UUID.randomUUID(), node4)
+            .put(UUID.randomUUID(), node5)
+            .put(UUID.randomUUID(), node6)
+            .put(UUID.randomUUID(), node7)
+            .put(UUID.randomUUID(), node8)
+            .put(UUID.randomUUID(), node9)
+            .put(UUID.randomUUID(), node10)
+            .put(UUID.randomUUID(), node11)
+            .put(UUID.randomUUID(), node12)
+            .put(UUID.randomUUID(), node13)
+            .put(UUID.randomUUID(), node14)
+            .build();
+    policy.init(nodes, distanceReporter);
+    assertThat(policy.getLiveNodes().dc("dc1")).containsExactly(node1, node2, node3, node4, node5);
+    assertThat(policy.getLiveNodes().dc("dc2")).containsExactly(node6, node7); // only 2 allowed
+    assertThat(policy.getLiveNodes().dc("dc3")).containsExactly(node9, node10); // only 2 allowed
+    assertThat(policy.getLiveNodes().dc("dc4")).containsExactly(node12, node13); // only 2 allowed
+    return policy;
+  }
+}

From 3a687377449f736ba1ed28bfcff824982b3138c4 Mon Sep 17 00:00:00 2001
From: janehe <siyaoh4@uci.edu>
Date: Wed, 17 Apr 2024 14:59:59 -0700
Subject: [PATCH 017/126] CASSANDRA-19568: Use Jabba to specify Java 1.8 for
 building the driver

patch by Jane He and Bret McGuire; reviewed by Bret McGuire for CASSANDRA-19568
---
 Jenkinsfile | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 0bfa4ca7f4a..69ee0a294c0 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -98,14 +98,16 @@ ENVIRONMENT_EOF
 }
 
 def buildDriver(jabbaVersion) {
-  withEnv(["BUILD_JABBA_VERSION=${jabbaVersion}"]) {
-    sh label: 'Build driver', script: '''#!/bin/bash -le
-      . ${JABBA_SHELL}
-      jabba use ${BUILD_JABBA_VERSION}
+  def buildDriverScript = '''#!/bin/bash -le
 
-      mvn -B -V install -DskipTests -Dmaven.javadoc.skip=true
-    '''
-  }
+    . ${JABBA_SHELL}
+    jabba use '''+jabbaVersion+'''
+
+    echo "Building with Java version '''+jabbaVersion+'''
+
+    mvn -B -V install -DskipTests -Dmaven.javadoc.skip=true
+  '''
+  sh label: 'Build driver', script: buildDriverScript
 }
 
 def executeTests() {
@@ -484,7 +486,7 @@ pipeline {
           }
           stage('Build-Driver') {
             steps {
-              buildDriver('default')
+              buildDriver('1.8')
             }
           }
           stage('Execute-Tests') {
@@ -600,8 +602,7 @@ pipeline {
           }
           stage('Build-Driver') {
             steps {
-              // Jabba default should be a JDK8 for now
-              buildDriver('default')
+              buildDriver('1.8')
             }
           }
           stage('Execute-Tests') {

From 4bc346885fd373906ed6106b76df6d494cb51b67 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Wed, 8 May 2024 21:37:02 -0500
Subject: [PATCH 018/126] ninja-fix CASSANDRA-19568: fixing mangled Groovy

---
 Jenkinsfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 69ee0a294c0..d38b7c63849 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -103,7 +103,7 @@ def buildDriver(jabbaVersion) {
     . ${JABBA_SHELL}
     jabba use '''+jabbaVersion+'''
 
-    echo "Building with Java version '''+jabbaVersion+'''
+    echo "Building with Java version '''+jabbaVersion+'''"
 
     mvn -B -V install -DskipTests -Dmaven.javadoc.skip=true
   '''

From ac452336356c30b125524f31dfa82cf8a465d716 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Thu, 16 May 2024 20:55:25 -0500
Subject: [PATCH 019/126] ninja-fix updating repo for releases

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 7decc96633a..b4102b3380f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -755,7 +755,7 @@ limitations under the License.]]></inlineHeader>
         <extensions>true</extensions>
         <configuration>
           <serverId>ossrh</serverId>
-          <nexusUrl>https://oss.sonatype.org/</nexusUrl>
+          <nexusUrl>https://repository.apache.org/</nexusUrl>
           <autoReleaseAfterClose>false</autoReleaseAfterClose>
           <skipLocalStaging>true</skipLocalStaging>
         </configuration>

From 3151129f7043a1b222131989584b07288c404be8 Mon Sep 17 00:00:00 2001
From: Nitin Chhabra <nitin.chhabra@walmartlabs.com>
Date: Wed, 8 May 2024 16:54:43 -0700
Subject: [PATCH 020/126] JAVA-3142: Improving the documentation for remote
 local dc's feature

patch by Nitin Chhabra; reviewed by Bret McGuire for JAVA-3142
---
 core/src/main/resources/reference.conf | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/core/src/main/resources/reference.conf b/core/src/main/resources/reference.conf
index 7a56a18e9f1..7b1c43f8bea 100644
--- a/core/src/main/resources/reference.conf
+++ b/core/src/main/resources/reference.conf
@@ -574,7 +574,9 @@ datastax-java-driver {
       # Modifiable at runtime: no
       # Overridable in a profile: yes
       allow-for-local-consistency-levels = false
+      
       # Ordered preference list of remote dc's (in order) optionally supplied for automatic failover. While building a query plan, the driver uses the DC's supplied in order together with max-nodes-per-remote-dc
+      # Users are not required to specify all DCs, when listing preferences via this config
       # Required: no
       # Modifiable at runtime: no
       # Overridable in a profile: no

From f60e75842fa99cbb728a716c0236a89caa19b39c Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Fri, 17 May 2024 12:27:53 -0500
Subject: [PATCH 021/126] ninja-fix changlog updates for 4.18.1

---
 changelog/README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/changelog/README.md b/changelog/README.md
index 7807ef15f95..83ebb44239f 100644
--- a/changelog/README.md
+++ b/changelog/README.md
@@ -21,6 +21,16 @@ under the License.
 
 <!-- Note: contrary to 3.x, insert new entries *first* in their section -->
 
+### 4.18.1
+
+- [improvement] JAVA-3142: Ability to specify ordering of remote local dc's via new configuration for graceful automatic failovers
+- [bug] CASSANDRA-19457: Object reference in Micrometer metrics prevent GC from reclaiming Session instances
+- [improvement] CASSANDRA-19468: Don't swallow exception during metadata refresh
+- [bug] CASSANDRA-19333: Fix data corruption in VectorCodec when using heap buffers
+- [improvement] CASSANDRA-19290: Replace uses of AttributeKey.newInstance
+- [improvement] CASSANDRA-19352: Support native_transport_(address|port) + native_transport_port_ssl for DSE 6.8 (4.x edition)
+- [improvement] CASSANDRA-19180: Support reloading keystore in cassandra-java-driver
+
 ### 4.18.0
 
 - [improvement] PR 1689: Add support for publishing percentile time series for the histogram metrics (nparaddi-walmart)

From cbdde2878786fa6c4077a21352cbe738875f2106 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Mon, 20 May 2024 09:57:23 -0500
Subject: [PATCH 022/126] [maven-release-plugin] prepare release 4.18.1

---
 bom/pom.xml                  | 18 +++++++++---------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 16 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 72e00c48355..87920ed984a 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,42 +33,42 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.18.1-SNAPSHOT</version>
+        <version>4.18.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.18.1-SNAPSHOT</version>
+        <version>4.18.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.18.1-SNAPSHOT</version>
+        <version>4.18.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.18.1-SNAPSHOT</version>
+        <version>4.18.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.18.1-SNAPSHOT</version>
+        <version>4.18.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.18.1-SNAPSHOT</version>
+        <version>4.18.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.18.1-SNAPSHOT</version>
+        <version>4.18.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.18.1-SNAPSHOT</version>
+        <version>4.18.1</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index c2768c3a642..93a74696c1b 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index c54c6b8c642..59465763c71 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index 8c4f695afdd..dc0cdfd1a43 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 099bddba900..11a0797b3cf 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 8933d3f5f3a..8bfbeecd8b0 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 7e2d7f1b6d0..0cf0c6389ec 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 5c684e90b2a..f867bcce7db 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 768327591d6..47f816bdc0d 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 95ead75ddd8..ca3a27367c5 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 1405ae0b6c2..e0e4e3fe709 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 6ba084396d1..fcbc7e1a54f 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 859a69400b9..e48be59f1c1 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index b4102b3380f..14d5d9c84ff 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.18.1-SNAPSHOT</version>
+  <version>4.18.1</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1017,7 +1017,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>HEAD</tag>
+    <tag>4.18.1</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index f1828b62462..eaa974030d3 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 9089d4d1019..25a8ad2f147 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1-SNAPSHOT</version>
+    <version>4.18.1</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From db4c8075e11d6dc020552d711c2a2e96dc651ad4 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Mon, 20 May 2024 09:57:26 -0500
Subject: [PATCH 023/126] [maven-release-plugin] prepare for next development
 iteration

---
 bom/pom.xml                  | 18 +++++++++---------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 16 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 87920ed984a..96b7a6ceb18 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,42 +33,42 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.18.1</version>
+        <version>4.18.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.18.1</version>
+        <version>4.18.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.18.1</version>
+        <version>4.18.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.18.1</version>
+        <version>4.18.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.18.1</version>
+        <version>4.18.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.18.1</version>
+        <version>4.18.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.18.1</version>
+        <version>4.18.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.18.1</version>
+        <version>4.18.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 93a74696c1b..6c139aab127 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 59465763c71..33688754f1b 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index dc0cdfd1a43..ee5b52958c3 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 11a0797b3cf..fafd8c4678b 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 8bfbeecd8b0..dfc406baf43 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 0cf0c6389ec..a76cc8d2bf1 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index f867bcce7db..32cabdb34a7 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 47f816bdc0d..61906f41987 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index ca3a27367c5..28483ee93ff 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index e0e4e3fe709..8ab939cbb37 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index fcbc7e1a54f..521a67f9075 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index e48be59f1c1..5947aff1bc5 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 14d5d9c84ff..082daeb3566 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.18.1</version>
+  <version>4.18.2-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1017,7 +1017,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>4.18.1</tag>
+    <tag>HEAD</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index eaa974030d3..bae0e0c6ca0 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 25a8ad2f147..262627e5536 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.1</version>
+    <version>4.18.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 432e107bc6a2dda19385b7c423d2768e3a879965 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Thu, 16 May 2024 14:13:05 +0200
Subject: [PATCH 024/126] CASSANDRA-19635: Run integration tests with C* 5.x

patch by Lukasz Antoniak; reviewed by Andy Tolbert, and Bret McGuire for CASSANDRA-19635
---
 integration-tests/pom.xml                     |  3 +
 .../core/auth/DseProxyAuthenticationIT.java   | 60 ++++++++-------
 .../oss/driver/core/cql/AsyncResultSetIT.java | 18 +++--
 .../oss/driver/core/cql/BatchStatementIT.java | 18 +++--
 .../driver/core/cql/BoundStatementCcmIT.java  | 73 ++++++++++---------
 .../core/cql/ExecutionInfoWarningsIT.java     | 17 +++--
 .../oss/driver/core/cql/PagingStateIT.java    | 14 ++--
 .../driver/core/cql/PerRequestKeyspaceIT.java | 60 ++++++++-------
 .../core/cql/PreparedStatementCachingIT.java  | 49 ++++++++++---
 .../reactive/DefaultReactiveResultSetIT.java  | 32 ++++----
 .../oss/driver/core/metadata/DescribeIT.java  | 23 +++---
 .../oss/driver/core/metadata/SchemaIT.java    | 14 ++++
 .../type/codec/registry/CodecRegistryIT.java  | 63 ++++++++--------
 .../datastax/oss/driver/mapper/DeleteIT.java  |  9 +--
 .../oss/driver/mapper/DeleteReactiveIT.java   | 18 +++--
 .../driver/mapper/EntityPolymorphismIT.java   | 38 ++++++----
 .../oss/driver/mapper/ImmutableEntityIT.java  | 14 +++-
 .../oss/driver/mapper/InventoryITBase.java    |  8 +-
 .../oss/driver/mapper/NestedUdtIT.java        | 48 ++++++------
 .../mapper/SelectCustomWhereClauseIT.java     | 14 +++-
 .../oss/driver/mapper/SelectReactiveIT.java   | 14 +++-
 .../datastax/oss/driver/mapper/UpdateIT.java  | 21 ++++--
 .../osgi/support/CcmStagedReactor.java        |  2 +-
 pom.xml                                       | 11 +++
 .../driver/api/testinfra/ccm/BaseCcmRule.java |  4 +-
 .../driver/api/testinfra/ccm/CcmBridge.java   | 20 +++--
 .../ccm/SchemaChangeSynchronizer.java         | 42 +++++++++++
 .../api/testinfra/session/SessionRule.java    |  6 +-
 28 files changed, 455 insertions(+), 258 deletions(-)
 create mode 100644 test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/SchemaChangeSynchronizer.java

diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 32cabdb34a7..d1b0a736bb0 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -242,6 +242,8 @@
               <threadCountClasses>8</threadCountClasses>
               <summaryFile>${project.build.directory}/failsafe-reports/failsafe-summary-parallelized.xml</summaryFile>
               <skipITs>${skipParallelizableITs}</skipITs>
+              <argLine>${blockhound.argline}</argLine>
+              <jvm>${testing.jvm}/bin/java</jvm>
             </configuration>
           </execution>
           <execution>
@@ -253,6 +255,7 @@
               <excludedGroups>com.datastax.oss.driver.categories.ParallelizableTests, com.datastax.oss.driver.categories.IsolatedTests</excludedGroups>
               <summaryFile>${project.build.directory}/failsafe-reports/failsafe-summary-serial.xml</summaryFile>
               <skipITs>${skipSerialITs}</skipITs>
+              <argLine>${blockhound.argline}</argLine>
               <jvm>${testing.jvm}/bin/java</jvm>
             </configuration>
           </execution>
diff --git a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/auth/DseProxyAuthenticationIT.java b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/auth/DseProxyAuthenticationIT.java
index 126a110da1a..a3f1c04afc0 100644
--- a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/auth/DseProxyAuthenticationIT.java
+++ b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/auth/DseProxyAuthenticationIT.java
@@ -29,6 +29,7 @@
 import com.datastax.oss.driver.api.core.cql.ResultSet;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.servererrors.UnauthorizedException;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
@@ -57,33 +58,38 @@ public static void addUsers() {
   @Before
   public void setupRoles() {
 
-    try (CqlSession session = ads.newKeyTabSession()) {
-      session.execute(
-          "CREATE ROLE IF NOT EXISTS alice WITH PASSWORD = 'fakePasswordForAlice' AND LOGIN = FALSE");
-      session.execute(
-          "CREATE ROLE IF NOT EXISTS ben WITH PASSWORD = 'fakePasswordForBen' AND LOGIN = TRUE");
-      session.execute("CREATE ROLE IF NOT EXISTS 'bob@DATASTAX.COM' WITH LOGIN = TRUE");
-      session.execute(
-          "CREATE ROLE IF NOT EXISTS 'charlie@DATASTAX.COM' WITH PASSWORD = 'fakePasswordForCharlie' AND LOGIN = TRUE");
-      session.execute(
-          "CREATE ROLE IF NOT EXISTS steve WITH PASSWORD = 'fakePasswordForSteve' AND LOGIN = TRUE");
-      session.execute(
-          "CREATE KEYSPACE IF NOT EXISTS aliceks WITH REPLICATION = {'class':'SimpleStrategy', 'replication_factor':'1'}");
-      session.execute(
-          "CREATE TABLE IF NOT EXISTS aliceks.alicetable (key text PRIMARY KEY, value text)");
-      session.execute("INSERT INTO aliceks.alicetable (key, value) VALUES ('hello', 'world')");
-      session.execute("GRANT ALL ON KEYSPACE aliceks TO alice");
-      session.execute("GRANT EXECUTE ON ALL AUTHENTICATION SCHEMES TO 'ben'");
-      session.execute("GRANT EXECUTE ON ALL AUTHENTICATION SCHEMES TO 'bob@DATASTAX.COM'");
-      session.execute("GRANT EXECUTE ON ALL AUTHENTICATION SCHEMES TO 'steve'");
-      session.execute("GRANT EXECUTE ON ALL AUTHENTICATION SCHEMES TO 'charlie@DATASTAX.COM'");
-      session.execute("GRANT PROXY.LOGIN ON ROLE 'alice' TO 'ben'");
-      session.execute("GRANT PROXY.LOGIN ON ROLE 'alice' TO 'bob@DATASTAX.COM'");
-      session.execute("GRANT PROXY.EXECUTE ON ROLE 'alice' TO 'steve'");
-      session.execute("GRANT PROXY.EXECUTE ON ROLE 'alice' TO 'charlie@DATASTAX.COM'");
-      // ben and bob are allowed to login as alice, but not execute as alice.
-      // charlie and steve are allowed to execute as alice, but not login as alice.
-    }
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          try (CqlSession session = ads.newKeyTabSession()) {
+            session.execute(
+                "CREATE ROLE IF NOT EXISTS alice WITH PASSWORD = 'fakePasswordForAlice' AND LOGIN = FALSE");
+            session.execute(
+                "CREATE ROLE IF NOT EXISTS ben WITH PASSWORD = 'fakePasswordForBen' AND LOGIN = TRUE");
+            session.execute("CREATE ROLE IF NOT EXISTS 'bob@DATASTAX.COM' WITH LOGIN = TRUE");
+            session.execute(
+                "CREATE ROLE IF NOT EXISTS 'charlie@DATASTAX.COM' WITH PASSWORD = 'fakePasswordForCharlie' AND LOGIN = TRUE");
+            session.execute(
+                "CREATE ROLE IF NOT EXISTS steve WITH PASSWORD = 'fakePasswordForSteve' AND LOGIN = TRUE");
+            session.execute(
+                "CREATE KEYSPACE IF NOT EXISTS aliceks WITH REPLICATION = {'class':'SimpleStrategy', 'replication_factor':'1'}");
+            session.execute(
+                "CREATE TABLE IF NOT EXISTS aliceks.alicetable (key text PRIMARY KEY, value text)");
+            session.execute(
+                "INSERT INTO aliceks.alicetable (key, value) VALUES ('hello', 'world')");
+            session.execute("GRANT ALL ON KEYSPACE aliceks TO alice");
+            session.execute("GRANT EXECUTE ON ALL AUTHENTICATION SCHEMES TO 'ben'");
+            session.execute("GRANT EXECUTE ON ALL AUTHENTICATION SCHEMES TO 'bob@DATASTAX.COM'");
+            session.execute("GRANT EXECUTE ON ALL AUTHENTICATION SCHEMES TO 'steve'");
+            session.execute(
+                "GRANT EXECUTE ON ALL AUTHENTICATION SCHEMES TO 'charlie@DATASTAX.COM'");
+            session.execute("GRANT PROXY.LOGIN ON ROLE 'alice' TO 'ben'");
+            session.execute("GRANT PROXY.LOGIN ON ROLE 'alice' TO 'bob@DATASTAX.COM'");
+            session.execute("GRANT PROXY.EXECUTE ON ROLE 'alice' TO 'steve'");
+            session.execute("GRANT PROXY.EXECUTE ON ROLE 'alice' TO 'charlie@DATASTAX.COM'");
+            // ben and bob are allowed to login as alice, but not execute as alice.
+            // charlie and steve are allowed to execute as alice, but not login as alice.
+          }
+        });
   }
   /**
    * Validates that a connection may be successfully made as user 'alice' using the credentials of a
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/AsyncResultSetIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/AsyncResultSetIT.java
index 2d01043b46a..e109c28525e 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/AsyncResultSetIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/AsyncResultSetIT.java
@@ -29,6 +29,7 @@
 import com.datastax.oss.driver.api.core.cql.Row;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.ParallelizableTests;
@@ -67,13 +68,16 @@ public class AsyncResultSetIT {
   @BeforeClass
   public static void setupSchema() {
     // create table and load data across two partitions so we can test paging across tokens.
-    SESSION_RULE
-        .session()
-        .execute(
-            SimpleStatement.builder(
-                    "CREATE TABLE IF NOT EXISTS test (k0 text, k1 int, v int, PRIMARY KEY(k0, k1))")
-                .setExecutionProfile(SESSION_RULE.slowProfile())
-                .build());
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          SESSION_RULE
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS test (k0 text, k1 int, v int, PRIMARY KEY(k0, k1))")
+                      .setExecutionProfile(SESSION_RULE.slowProfile())
+                      .build());
+        });
 
     PreparedStatement prepared =
         SESSION_RULE.session().prepare("INSERT INTO test (k0, k1, v) VALUES (?, ?, ?)");
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/BatchStatementIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/BatchStatementIT.java
index 04e5798be5a..8b652638729 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/BatchStatementIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/BatchStatementIT.java
@@ -34,6 +34,7 @@
 import com.datastax.oss.driver.api.core.cql.Statement;
 import com.datastax.oss.driver.api.core.servererrors.InvalidQueryException;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
@@ -72,13 +73,16 @@ public void createTable() {
           "CREATE TABLE counter3 (k0 text PRIMARY KEY, c counter)",
         };
 
-    for (String schemaStatement : schemaStatements) {
-      sessionRule
-          .session()
-          .execute(
-              SimpleStatement.newInstance(schemaStatement)
-                  .setExecutionProfile(sessionRule.slowProfile()));
-    }
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          for (String schemaStatement : schemaStatements) {
+            sessionRule
+                .session()
+                .execute(
+                    SimpleStatement.newInstance(schemaStatement)
+                        .setExecutionProfile(sessionRule.slowProfile()));
+          }
+        });
   }
 
   @Test
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/BoundStatementCcmIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/BoundStatementCcmIT.java
index 79156fcce50..9e4b62cd230 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/BoundStatementCcmIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/BoundStatementCcmIT.java
@@ -40,6 +40,7 @@
 import com.datastax.oss.driver.api.core.metadata.token.Token;
 import com.datastax.oss.driver.api.core.type.codec.TypeCodecs;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
@@ -94,40 +95,44 @@ public class BoundStatementCcmIT {
   @Before
   public void setupSchema() {
     // table where every column forms the primary key.
-    sessionRule
-        .session()
-        .execute(
-            SimpleStatement.builder(
-                    "CREATE TABLE IF NOT EXISTS test (k text, v int, PRIMARY KEY(k, v))")
-                .setExecutionProfile(sessionRule.slowProfile())
-                .build());
-    for (int i = 0; i < 100; i++) {
-      sessionRule
-          .session()
-          .execute(
-              SimpleStatement.builder("INSERT INTO test (k, v) VALUES (?, ?)")
-                  .addPositionalValues(KEY, i)
-                  .build());
-    }
-
-    // table with simple primary key, single cell.
-    sessionRule
-        .session()
-        .execute(
-            SimpleStatement.builder("CREATE TABLE IF NOT EXISTS test2 (k text primary key, v0 int)")
-                .setExecutionProfile(sessionRule.slowProfile())
-                .build());
-
-    // table with composite partition key
-    sessionRule
-        .session()
-        .execute(
-            SimpleStatement.builder(
-                    "CREATE TABLE IF NOT EXISTS test3 "
-                        + "(pk1 int, pk2 int, v int, "
-                        + "PRIMARY KEY ((pk1, pk2)))")
-                .setExecutionProfile(sessionRule.slowProfile())
-                .build());
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          sessionRule
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS test (k text, v int, PRIMARY KEY(k, v))")
+                      .setExecutionProfile(sessionRule.slowProfile())
+                      .build());
+          for (int i = 0; i < 100; i++) {
+            sessionRule
+                .session()
+                .execute(
+                    SimpleStatement.builder("INSERT INTO test (k, v) VALUES (?, ?)")
+                        .addPositionalValues(KEY, i)
+                        .build());
+          }
+
+          // table with simple primary key, single cell.
+          sessionRule
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS test2 (k text primary key, v0 int)")
+                      .setExecutionProfile(sessionRule.slowProfile())
+                      .build());
+
+          // table with composite partition key
+          sessionRule
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS test3 "
+                              + "(pk1 int, pk2 int, v int, "
+                              + "PRIMARY KEY ((pk1, pk2)))")
+                      .setExecutionProfile(sessionRule.slowProfile())
+                      .build());
+        });
   }
 
   @Test
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/ExecutionInfoWarningsIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/ExecutionInfoWarningsIT.java
index 5907206d11a..edee9723a38 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/ExecutionInfoWarningsIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/ExecutionInfoWarningsIT.java
@@ -33,6 +33,7 @@
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.cql.Statement;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
@@ -88,12 +89,16 @@ public class ExecutionInfoWarningsIT {
   @Before
   public void createSchema() {
     // table with simple primary key, single cell.
-    sessionRule
-        .session()
-        .execute(
-            SimpleStatement.builder("CREATE TABLE IF NOT EXISTS test (k int primary key, v text)")
-                .setExecutionProfile(sessionRule.slowProfile())
-                .build());
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          sessionRule
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS test (k int primary key, v text)")
+                      .setExecutionProfile(sessionRule.slowProfile())
+                      .build());
+        });
     for (int i = 0; i < 100; i++) {
       sessionRule
           .session()
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PagingStateIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PagingStateIT.java
index dcd801f19a4..6d33f35238a 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PagingStateIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PagingStateIT.java
@@ -30,6 +30,7 @@
 import com.datastax.oss.driver.api.core.type.codec.MappingCodec;
 import com.datastax.oss.driver.api.core.type.reflect.GenericType;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.ParallelizableTests;
@@ -55,11 +56,14 @@ public class PagingStateIT {
   @Before
   public void setupSchema() {
     CqlSession session = SESSION_RULE.session();
-    session.execute(
-        SimpleStatement.builder(
-                "CREATE TABLE IF NOT EXISTS foo (k int, cc int, v int, PRIMARY KEY(k, cc))")
-            .setExecutionProfile(SESSION_RULE.slowProfile())
-            .build());
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          session.execute(
+              SimpleStatement.builder(
+                      "CREATE TABLE IF NOT EXISTS foo (k int, cc int, v int, PRIMARY KEY(k, cc))")
+                  .setExecutionProfile(SESSION_RULE.slowProfile())
+                  .build());
+        });
     for (int i = 0; i < 20; i++) {
       session.execute(
           SimpleStatement.newInstance("INSERT INTO foo (k, cc, v) VALUES (1, ?, ?)", i, i));
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PerRequestKeyspaceIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PerRequestKeyspaceIT.java
index 2b418e76f75..9eb883144db 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PerRequestKeyspaceIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PerRequestKeyspaceIT.java
@@ -31,6 +31,7 @@
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.cql.Statement;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
@@ -67,13 +68,16 @@ public class PerRequestKeyspaceIT {
 
   @Before
   public void setupSchema() {
-    sessionRule
-        .session()
-        .execute(
-            SimpleStatement.builder(
-                    "CREATE TABLE IF NOT EXISTS foo (k text, cc int, v int, PRIMARY KEY(k, cc))")
-                .setExecutionProfile(sessionRule.slowProfile())
-                .build());
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          sessionRule
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS foo (k text, cc int, v int, PRIMARY KEY(k, cc))")
+                      .setExecutionProfile(sessionRule.slowProfile())
+                      .build());
+        });
   }
 
   @Test
@@ -220,27 +224,31 @@ public void should_prepare_statement_with_keyspace() {
   @BackendRequirement(type = BackendType.CASSANDRA, minInclusive = "4.0")
   public void should_reprepare_statement_with_keyspace_on_the_fly() {
     // Create a separate session because we don't want it to have a default keyspace
-    try (CqlSession session = SessionUtils.newSession(ccmRule)) {
-      executeDdl(
-          session,
-          String.format(
-              "CREATE TABLE IF NOT EXISTS %s.bar (k int primary key)", sessionRule.keyspace()));
-      PreparedStatement pst =
-          session.prepare(
-              SimpleStatement.newInstance("SELECT * FROM bar WHERE k=?")
-                  .setKeyspace(sessionRule.keyspace()));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          try (CqlSession session = SessionUtils.newSession(ccmRule)) {
+            executeDdl(
+                session,
+                String.format(
+                    "CREATE TABLE IF NOT EXISTS %s.bar (k int primary key)",
+                    sessionRule.keyspace()));
+            PreparedStatement pst =
+                session.prepare(
+                    SimpleStatement.newInstance("SELECT * FROM bar WHERE k=?")
+                        .setKeyspace(sessionRule.keyspace()));
 
-      // Drop and re-create the table to invalidate the prepared statement server side
-      executeDdl(session, String.format("DROP TABLE %s.bar", sessionRule.keyspace()));
-      executeDdl(
-          session,
-          String.format("CREATE TABLE %s.bar (k int primary key)", sessionRule.keyspace()));
-      assertThat(preparedStatementExistsOnServer(session, pst.getId())).isFalse();
+            // Drop and re-create the table to invalidate the prepared statement server side
+            executeDdl(session, String.format("DROP TABLE %s.bar", sessionRule.keyspace()));
+            executeDdl(
+                session,
+                String.format("CREATE TABLE %s.bar (k int primary key)", sessionRule.keyspace()));
+            assertThat(preparedStatementExistsOnServer(session, pst.getId())).isFalse();
 
-      // This will re-prepare on the fly
-      session.execute(pst.bind(0));
-      assertThat(preparedStatementExistsOnServer(session, pst.getId())).isTrue();
-    }
+            // This will re-prepare on the fly
+            session.execute(pst.bind(0));
+            assertThat(preparedStatementExistsOnServer(session, pst.getId())).isTrue();
+          }
+        });
   }
 
   private void executeDdl(CqlSession session, String query) {
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
index 92c6fd8a12e..05ac3bd0e92 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
@@ -30,6 +30,7 @@
 import com.datastax.oss.driver.api.core.session.ProgrammaticArguments;
 import com.datastax.oss.driver.api.core.session.SessionBuilder;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.IsolatedTests;
@@ -305,12 +306,19 @@ private void invalidationTestInner(
 
   @Test
   public void should_invalidate_cache_entry_on_basic_udt_change_result_set() {
-    invalidationResultSetTest(setupCacheEntryTestBasic, ImmutableSet.of("test_type_2"));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          invalidationResultSetTest(setupCacheEntryTestBasic, ImmutableSet.of("test_type_2"));
+        });
   }
 
   @Test
   public void should_invalidate_cache_entry_on_basic_udt_change_variable_defs() {
-    invalidationVariableDefsTest(setupCacheEntryTestBasic, false, ImmutableSet.of("test_type_2"));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          invalidationVariableDefsTest(
+              setupCacheEntryTestBasic, false, ImmutableSet.of("test_type_2"));
+        });
   }
 
   Consumer<CqlSession> setupCacheEntryTestCollection =
@@ -325,13 +333,19 @@ public void should_invalidate_cache_entry_on_basic_udt_change_variable_defs() {
 
   @Test
   public void should_invalidate_cache_entry_on_collection_udt_change_result_set() {
-    invalidationResultSetTest(setupCacheEntryTestCollection, ImmutableSet.of("test_type_2"));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          invalidationResultSetTest(setupCacheEntryTestCollection, ImmutableSet.of("test_type_2"));
+        });
   }
 
   @Test
   public void should_invalidate_cache_entry_on_collection_udt_change_variable_defs() {
-    invalidationVariableDefsTest(
-        setupCacheEntryTestCollection, true, ImmutableSet.of("test_type_2"));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          invalidationVariableDefsTest(
+              setupCacheEntryTestCollection, true, ImmutableSet.of("test_type_2"));
+        });
   }
 
   Consumer<CqlSession> setupCacheEntryTestTuple =
@@ -346,12 +360,19 @@ public void should_invalidate_cache_entry_on_collection_udt_change_variable_defs
 
   @Test
   public void should_invalidate_cache_entry_on_tuple_udt_change_result_set() {
-    invalidationResultSetTest(setupCacheEntryTestTuple, ImmutableSet.of("test_type_2"));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          invalidationResultSetTest(setupCacheEntryTestTuple, ImmutableSet.of("test_type_2"));
+        });
   }
 
   @Test
   public void should_invalidate_cache_entry_on_tuple_udt_change_variable_defs() {
-    invalidationVariableDefsTest(setupCacheEntryTestTuple, false, ImmutableSet.of("test_type_2"));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          invalidationVariableDefsTest(
+              setupCacheEntryTestTuple, false, ImmutableSet.of("test_type_2"));
+        });
   }
 
   Consumer<CqlSession> setupCacheEntryTestNested =
@@ -366,14 +387,20 @@ public void should_invalidate_cache_entry_on_tuple_udt_change_variable_defs() {
 
   @Test
   public void should_invalidate_cache_entry_on_nested_udt_change_result_set() {
-    invalidationResultSetTest(
-        setupCacheEntryTestNested, ImmutableSet.of("test_type_2", "test_type_4"));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          invalidationResultSetTest(
+              setupCacheEntryTestNested, ImmutableSet.of("test_type_2", "test_type_4"));
+        });
   }
 
   @Test
   public void should_invalidate_cache_entry_on_nested_udt_change_variable_defs() {
-    invalidationVariableDefsTest(
-        setupCacheEntryTestNested, false, ImmutableSet.of("test_type_2", "test_type_4"));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          invalidationVariableDefsTest(
+              setupCacheEntryTestNested, false, ImmutableSet.of("test_type_2", "test_type_4"));
+        });
   }
 
   /* ========================= Infrastructure copied from PreparedStatementIT ========================= */
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/reactive/DefaultReactiveResultSetIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/reactive/DefaultReactiveResultSetIT.java
index cfb6a56fac2..c00cf064e51 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/reactive/DefaultReactiveResultSetIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/reactive/DefaultReactiveResultSetIT.java
@@ -32,6 +32,7 @@
 import com.datastax.oss.driver.api.core.cql.PreparedStatement;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.categories.ParallelizableTests;
 import com.datastax.oss.driver.internal.core.cql.EmptyColumnDefinitions;
@@ -64,20 +65,23 @@ public class DefaultReactiveResultSetIT {
   @BeforeClass
   public static void initialize() {
     CqlSession session = sessionRule.session();
-    session.execute("DROP TABLE IF EXISTS test_reactive_read");
-    session.execute("DROP TABLE IF EXISTS test_reactive_write");
-    session.checkSchemaAgreement();
-    session.execute(
-        SimpleStatement.builder(
-                "CREATE TABLE test_reactive_read (pk int, cc int, v int, PRIMARY KEY ((pk), cc))")
-            .setExecutionProfile(sessionRule.slowProfile())
-            .build());
-    session.execute(
-        SimpleStatement.builder(
-                "CREATE TABLE test_reactive_write (pk int, cc int, v int, PRIMARY KEY ((pk), cc))")
-            .setExecutionProfile(sessionRule.slowProfile())
-            .build());
-    session.checkSchemaAgreement();
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          session.execute("DROP TABLE IF EXISTS test_reactive_read");
+          session.execute("DROP TABLE IF EXISTS test_reactive_write");
+          session.checkSchemaAgreement();
+          session.execute(
+              SimpleStatement.builder(
+                      "CREATE TABLE test_reactive_read (pk int, cc int, v int, PRIMARY KEY ((pk), cc))")
+                  .setExecutionProfile(sessionRule.slowProfile())
+                  .build());
+          session.execute(
+              SimpleStatement.builder(
+                      "CREATE TABLE test_reactive_write (pk int, cc int, v int, PRIMARY KEY ((pk), cc))")
+                  .setExecutionProfile(sessionRule.slowProfile())
+                  .build());
+          session.checkSchemaAgreement();
+        });
     for (int i = 0; i < 1000; i++) {
       session.execute(
           SimpleStatement.builder("INSERT INTO test_reactive_read (pk, cc, v) VALUES (0, ?, ?)")
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/DescribeIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/DescribeIT.java
index d8239f31872..9fbf5e355eb 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/DescribeIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/DescribeIT.java
@@ -28,6 +28,7 @@
 import com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata;
 import com.datastax.oss.driver.api.core.metadata.schema.TableMetadata;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.ParallelizableTests;
@@ -224,15 +225,17 @@ private static String getScriptContents() {
 
   private static void setupDatabase() {
     List<String> statements = STATEMENT_SPLITTER.splitToList(scriptContents);
-
-    // Skip the first statement (CREATE KEYSPACE), we already have a keyspace
-    for (int i = 1; i < statements.size(); i++) {
-      String statement = statements.get(i);
-      try {
-        SESSION_RULE.session().execute(statement);
-      } catch (Exception e) {
-        fail("Error executing statement %s (%s)", statement, e);
-      }
-    }
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          // Skip the first statement (CREATE KEYSPACE), we already have a keyspace
+          for (int i = 1; i < statements.size(); i++) {
+            String statement = statements.get(i);
+            try {
+              SESSION_RULE.session().execute(statement);
+            } catch (Exception e) {
+              fail("Error executing statement %s (%s)", statement, e);
+            }
+          }
+        });
   }
 }
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
index 6495b451df7..805b2d970cc 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
@@ -278,6 +278,20 @@ public void should_get_virtual_metadata() {
                   + "    total bigint,\n"
                   + "    unit text,\n"
                   + "    PRIMARY KEY (keyspace_name, table_name, task_id)\n"
+                  + "); */",
+              // Cassandra 5.0
+              "/* VIRTUAL TABLE system_views.sstable_tasks (\n"
+                  + "    keyspace_name text,\n"
+                  + "    table_name text,\n"
+                  + "    task_id timeuuid,\n"
+                  + "    completion_ratio double,\n"
+                  + "    kind text,\n"
+                  + "    progress bigint,\n"
+                  + "    sstables int,\n"
+                  + "    target_directory text,\n"
+                  + "    total bigint,\n"
+                  + "    unit text,\n"
+                  + "    PRIMARY KEY (keyspace_name, table_name, task_id)\n"
                   + "); */");
       // ColumnMetadata is as expected
       ColumnMetadata cm = tm.getColumn("progress").get();
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/type/codec/registry/CodecRegistryIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/type/codec/registry/CodecRegistryIT.java
index 2f9a0872b37..74472e8bab9 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/type/codec/registry/CodecRegistryIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/type/codec/registry/CodecRegistryIT.java
@@ -38,6 +38,7 @@
 import com.datastax.oss.driver.api.core.type.codec.registry.MutableCodecRegistry;
 import com.datastax.oss.driver.api.core.type.reflect.GenericType;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.ParallelizableTests;
@@ -78,35 +79,39 @@ public class CodecRegistryIT {
 
   @BeforeClass
   public static void createSchema() {
-    // table with simple primary key, single cell.
-    SESSION_RULE
-        .session()
-        .execute(
-            SimpleStatement.builder("CREATE TABLE IF NOT EXISTS test (k text primary key, v int)")
-                .setExecutionProfile(SESSION_RULE.slowProfile())
-                .build());
-    // table with map value
-    SESSION_RULE
-        .session()
-        .execute(
-            SimpleStatement.builder(
-                    "CREATE TABLE IF NOT EXISTS test2 (k0 text, k1 int, v map<int,text>, primary key (k0, k1))")
-                .setExecutionProfile(SESSION_RULE.slowProfile())
-                .build());
-    // table with UDT
-    SESSION_RULE
-        .session()
-        .execute(
-            SimpleStatement.builder("CREATE TYPE IF NOT EXISTS coordinates (x int, y int)")
-                .setExecutionProfile(SESSION_RULE.slowProfile())
-                .build());
-    SESSION_RULE
-        .session()
-        .execute(
-            SimpleStatement.builder(
-                    "CREATE TABLE IF NOT EXISTS test3 (k0 text, k1 int, v map<text,frozen<coordinates>>, primary key (k0, k1))")
-                .setExecutionProfile(SESSION_RULE.slowProfile())
-                .build());
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          // table with simple primary key, single cell.
+          SESSION_RULE
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS test (k text primary key, v int)")
+                      .setExecutionProfile(SESSION_RULE.slowProfile())
+                      .build());
+          // table with map value
+          SESSION_RULE
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS test2 (k0 text, k1 int, v map<int,text>, primary key (k0, k1))")
+                      .setExecutionProfile(SESSION_RULE.slowProfile())
+                      .build());
+          // table with UDT
+          SESSION_RULE
+              .session()
+              .execute(
+                  SimpleStatement.builder("CREATE TYPE IF NOT EXISTS coordinates (x int, y int)")
+                      .setExecutionProfile(SESSION_RULE.slowProfile())
+                      .build());
+          SESSION_RULE
+              .session()
+              .execute(
+                  SimpleStatement.builder(
+                          "CREATE TABLE IF NOT EXISTS test3 (k0 text, k1 int, v map<text,frozen<coordinates>>, primary key (k0, k1))")
+                      .setExecutionProfile(SESSION_RULE.slowProfile())
+                      .build());
+        });
   }
 
   // A simple codec that allows float values to be used for cassandra int column type.
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteIT.java
index 8918e6020ec..0acdbeae53a 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteIT.java
@@ -38,11 +38,10 @@
 import com.datastax.oss.driver.api.mapper.annotations.Mapper;
 import com.datastax.oss.driver.api.mapper.annotations.Select;
 import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
-import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
-import com.datastax.oss.driver.categories.ParallelizableTests;
 import com.datastax.oss.driver.internal.core.util.concurrent.CompletableFutures;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -51,18 +50,18 @@
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
 import org.junit.Test;
-import org.junit.experimental.categories.Category;
 import org.junit.rules.RuleChain;
 import org.junit.rules.TestRule;
 
-@Category(ParallelizableTests.class)
+// Do not run LWT tests in parallel because they may interfere. Tests operate on the same row.
 @BackendRequirement(
     type = BackendType.CASSANDRA,
     minInclusive = "3.0",
     description = ">= in WHERE clause not supported in legacy versions")
 public class DeleteIT extends InventoryITBase {
 
-  private static final CcmRule CCM_RULE = CcmRule.getInstance();
+  private static CustomCcmRule CCM_RULE =
+      CustomCcmRule.builder().withCassandraConfiguration("enable_sasi_indexes", "true").build();
 
   private static final SessionRule<CqlSession> SESSION_RULE = SessionRule.builder(CCM_RULE).build();
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteReactiveIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteReactiveIT.java
index 928fbd6fb8a..3a418c73653 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteReactiveIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteReactiveIT.java
@@ -24,6 +24,7 @@
 import com.datastax.dse.driver.api.mapper.reactive.MappedReactiveResultSet;
 import com.datastax.oss.driver.api.core.CqlIdentifier;
 import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.Version;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.mapper.annotations.Dao;
 import com.datastax.oss.driver.api.mapper.annotations.DaoFactory;
@@ -34,28 +35,35 @@
 import com.datastax.oss.driver.api.mapper.annotations.Mapper;
 import com.datastax.oss.driver.api.mapper.annotations.Select;
 import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
-import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.CcmBridge;
+import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
-import com.datastax.oss.driver.categories.ParallelizableTests;
 import io.reactivex.Flowable;
 import java.util.UUID;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
 import org.junit.Test;
-import org.junit.experimental.categories.Category;
 import org.junit.rules.RuleChain;
 import org.junit.rules.TestRule;
 
-@Category(ParallelizableTests.class)
+// Do not run LWT tests in parallel because they may interfere. Tests operate on the same row.
 public class DeleteReactiveIT extends InventoryITBase {
 
-  private static CcmRule ccmRule = CcmRule.getInstance();
+  private static CustomCcmRule ccmRule = configureCcm(CustomCcmRule.builder()).build();
 
   private static SessionRule<CqlSession> sessionRule = SessionRule.builder(ccmRule).build();
 
   @ClassRule public static TestRule chain = RuleChain.outerRule(ccmRule).around(sessionRule);
 
+  private static CustomCcmRule.Builder configureCcm(CustomCcmRule.Builder builder) {
+    if (!CcmBridge.DSE_ENABLEMENT
+        && CcmBridge.VERSION.nextStable().compareTo(Version.V4_0_0) >= 0) {
+      builder.withCassandraConfiguration("enable_sasi_indexes", true);
+    }
+    return builder;
+  }
+
   private static DseProductDao dao;
 
   @BeforeClass
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/EntityPolymorphismIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/EntityPolymorphismIT.java
index 08b806af684..3e532e97c00 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/EntityPolymorphismIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/EntityPolymorphismIT.java
@@ -47,6 +47,7 @@
 import com.datastax.oss.driver.api.mapper.annotations.Update;
 import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.categories.ParallelizableTests;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
@@ -83,22 +84,27 @@ public class EntityPolymorphismIT {
   @BeforeClass
   public static void setup() {
     CqlSession session = SESSION_RULE.session();
-    for (String query :
-        ImmutableList.of(
-            "CREATE TYPE point2d (\"X\" int, \"Y\" int)",
-            "CREATE TYPE point3d (\"X\" int, \"Y\" int, \"Z\" int)",
-            "CREATE TABLE circles (circle_id uuid PRIMARY KEY, center2d frozen<point2d>, radius "
-                + "double, tags set<text>)",
-            "CREATE TABLE rectangles (rect_id uuid PRIMARY KEY, bottom_left frozen<point2d>, top_right frozen<point2d>, tags set<text>)",
-            "CREATE TABLE squares (square_id uuid PRIMARY KEY, bottom_left frozen<point2d>, top_right frozen<point2d>, tags set<text>)",
-            "CREATE TABLE spheres (sphere_id uuid PRIMARY KEY, center3d frozen<point3d>, radius "
-                + "double, tags set<text>)",
-            "CREATE TABLE devices (device_id uuid PRIMARY KEY, name text)",
-            "CREATE TABLE tracked_devices (device_id uuid PRIMARY KEY, name text, location text)",
-            "CREATE TABLE simple_devices (id uuid PRIMARY KEY, in_use boolean)")) {
-      session.execute(
-          SimpleStatement.builder(query).setExecutionProfile(SESSION_RULE.slowProfile()).build());
-    }
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          for (String query :
+              ImmutableList.of(
+                  "CREATE TYPE point2d (\"X\" int, \"Y\" int)",
+                  "CREATE TYPE point3d (\"X\" int, \"Y\" int, \"Z\" int)",
+                  "CREATE TABLE circles (circle_id uuid PRIMARY KEY, center2d frozen<point2d>, radius "
+                      + "double, tags set<text>)",
+                  "CREATE TABLE rectangles (rect_id uuid PRIMARY KEY, bottom_left frozen<point2d>, top_right frozen<point2d>, tags set<text>)",
+                  "CREATE TABLE squares (square_id uuid PRIMARY KEY, bottom_left frozen<point2d>, top_right frozen<point2d>, tags set<text>)",
+                  "CREATE TABLE spheres (sphere_id uuid PRIMARY KEY, center3d frozen<point3d>, radius "
+                      + "double, tags set<text>)",
+                  "CREATE TABLE devices (device_id uuid PRIMARY KEY, name text)",
+                  "CREATE TABLE tracked_devices (device_id uuid PRIMARY KEY, name text, location text)",
+                  "CREATE TABLE simple_devices (id uuid PRIMARY KEY, in_use boolean)")) {
+            session.execute(
+                SimpleStatement.builder(query)
+                    .setExecutionProfile(SESSION_RULE.slowProfile())
+                    .build());
+          }
+        });
     mapper = new EntityPolymorphismIT_TestMapperBuilder(session).build();
   }
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/ImmutableEntityIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/ImmutableEntityIT.java
index 555b02c0283..bdfe92a23f9 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/ImmutableEntityIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/ImmutableEntityIT.java
@@ -42,6 +42,7 @@
 import com.datastax.oss.driver.api.mapper.annotations.Select;
 import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.categories.ParallelizableTests;
 import java.util.Objects;
@@ -70,10 +71,15 @@ public class ImmutableEntityIT extends InventoryITBase {
   public static void setup() {
     CqlSession session = SESSION_RULE.session();
 
-    for (String query : createStatements(CCM_RULE)) {
-      session.execute(
-          SimpleStatement.builder(query).setExecutionProfile(SESSION_RULE.slowProfile()).build());
-    }
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          for (String query : createStatements(CCM_RULE)) {
+            session.execute(
+                SimpleStatement.builder(query)
+                    .setExecutionProfile(SESSION_RULE.slowProfile())
+                    .build());
+          }
+        });
 
     UserDefinedType dimensions2d =
         session
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
index 75ceee1f2a5..2be025b3739 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
@@ -22,7 +22,7 @@
 import com.datastax.oss.driver.api.mapper.annotations.ClusteringColumn;
 import com.datastax.oss.driver.api.mapper.annotations.Entity;
 import com.datastax.oss.driver.api.mapper.annotations.PartitionKey;
-import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.BaseCcmRule;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
 import java.util.List;
 import java.util.Objects;
@@ -58,7 +58,7 @@ public abstract class InventoryITBase {
   protected static ProductSale MP3_DOWNLOAD_SALE_1 =
       new ProductSale(MP3_DOWNLOAD.getId(), DATE_3, 7, Uuids.startOf(915192000), 0.99, 12);
 
-  protected static List<String> createStatements(CcmRule ccmRule) {
+  protected static List<String> createStatements(BaseCcmRule ccmRule) {
     ImmutableList.Builder<String> builder =
         ImmutableList.<String>builder()
             .add(
@@ -92,13 +92,13 @@ protected static List<String> createStatements(CcmRule ccmRule) {
   private static final Version MINIMUM_SASI_VERSION = Version.parse("3.4.0");
   private static final Version BROKEN_SASI_VERSION = Version.parse("6.8.0");
 
-  protected static boolean isSasiBroken(CcmRule ccmRule) {
+  protected static boolean isSasiBroken(BaseCcmRule ccmRule) {
     Optional<Version> dseVersion = ccmRule.getDseVersion();
     // creating SASI indexes is broken in DSE 6.8.0
     return dseVersion.isPresent() && dseVersion.get().compareTo(BROKEN_SASI_VERSION) == 0;
   }
 
-  protected static boolean supportsSASI(CcmRule ccmRule) {
+  protected static boolean supportsSASI(BaseCcmRule ccmRule) {
     return ccmRule.getCassandraVersion().compareTo(MINIMUM_SASI_VERSION) >= 0;
   }
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/NestedUdtIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/NestedUdtIT.java
index 43d41a9c93b..d61b6f6e628 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/NestedUdtIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/NestedUdtIT.java
@@ -41,6 +41,7 @@
 import com.datastax.oss.driver.api.mapper.annotations.SetEntity;
 import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
@@ -119,27 +120,32 @@ public class NestedUdtIT {
   public static void setup() {
     CqlSession session = SESSION_RULE.session();
 
-    for (String query :
-        ImmutableList.of(
-            "CREATE TYPE type1(s1 text, s2 text)",
-            "CREATE TYPE type2(i1 int, i2 int)",
-            "CREATE TYPE type1_partial(s1 text)",
-            "CREATE TYPE type2_partial(i1 int)",
-            "CREATE TABLE container(id uuid PRIMARY KEY, "
-                + "list frozen<list<type1>>, "
-                + "map1 frozen<map<text, list<type1>>>, "
-                + "map2 frozen<map<type1, set<list<type2>>>>,"
-                + "map3 frozen<map<type1, map<text, set<type2>>>>"
-                + ")",
-            "CREATE TABLE container_partial(id uuid PRIMARY KEY, "
-                + "list frozen<list<type1_partial>>, "
-                + "map1 frozen<map<text, list<type1_partial>>>, "
-                + "map2 frozen<map<type1_partial, set<list<type2_partial>>>>,"
-                + "map3 frozen<map<type1_partial, map<text, set<type2_partial>>>>"
-                + ")")) {
-      session.execute(
-          SimpleStatement.builder(query).setExecutionProfile(SESSION_RULE.slowProfile()).build());
-    }
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          for (String query :
+              ImmutableList.of(
+                  "CREATE TYPE type1(s1 text, s2 text)",
+                  "CREATE TYPE type2(i1 int, i2 int)",
+                  "CREATE TYPE type1_partial(s1 text)",
+                  "CREATE TYPE type2_partial(i1 int)",
+                  "CREATE TABLE container(id uuid PRIMARY KEY, "
+                      + "list frozen<list<type1>>, "
+                      + "map1 frozen<map<text, list<type1>>>, "
+                      + "map2 frozen<map<type1, set<list<type2>>>>,"
+                      + "map3 frozen<map<type1, map<text, set<type2>>>>"
+                      + ")",
+                  "CREATE TABLE container_partial(id uuid PRIMARY KEY, "
+                      + "list frozen<list<type1_partial>>, "
+                      + "map1 frozen<map<text, list<type1_partial>>>, "
+                      + "map2 frozen<map<type1_partial, set<list<type2_partial>>>>,"
+                      + "map3 frozen<map<type1_partial, map<text, set<type2_partial>>>>"
+                      + ")")) {
+            session.execute(
+                SimpleStatement.builder(query)
+                    .setExecutionProfile(SESSION_RULE.slowProfile())
+                    .build());
+          }
+        });
 
     UserDefinedType type1Partial =
         session
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectCustomWhereClauseIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectCustomWhereClauseIT.java
index e2a0f1e9987..3df1ccd21a7 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectCustomWhereClauseIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectCustomWhereClauseIT.java
@@ -35,6 +35,7 @@
 import com.datastax.oss.driver.api.mapper.annotations.Mapper;
 import com.datastax.oss.driver.api.mapper.annotations.Select;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
@@ -72,10 +73,15 @@ public static void setup() {
 
     CqlSession session = SESSION_RULE.session();
 
-    for (String query : createStatements(CCM_RULE)) {
-      session.execute(
-          SimpleStatement.builder(query).setExecutionProfile(SESSION_RULE.slowProfile()).build());
-    }
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          for (String query : createStatements(CCM_RULE)) {
+            session.execute(
+                SimpleStatement.builder(query)
+                    .setExecutionProfile(SESSION_RULE.slowProfile())
+                    .build());
+          }
+        });
 
     InventoryMapper inventoryMapper =
         new SelectCustomWhereClauseIT_InventoryMapperBuilder(session).build();
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectReactiveIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectReactiveIT.java
index 0ea07e552f7..79e4d2b33ea 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectReactiveIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectReactiveIT.java
@@ -34,6 +34,7 @@
 import com.datastax.oss.driver.api.mapper.annotations.Select;
 import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.categories.ParallelizableTests;
 import io.reactivex.Flowable;
@@ -61,10 +62,15 @@ public class SelectReactiveIT extends InventoryITBase {
   public static void setup() {
     CqlSession session = sessionRule.session();
 
-    for (String query : createStatements(ccmRule)) {
-      session.execute(
-          SimpleStatement.builder(query).setExecutionProfile(sessionRule.slowProfile()).build());
-    }
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          for (String query : createStatements(ccmRule)) {
+            session.execute(
+                SimpleStatement.builder(query)
+                    .setExecutionProfile(sessionRule.slowProfile())
+                    .build());
+          }
+        });
 
     DseInventoryMapper inventoryMapper =
         new SelectReactiveIT_DseInventoryMapperBuilder(session).build();
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/UpdateIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/UpdateIT.java
index 27b4d6e9d90..3fac733c900 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/UpdateIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/UpdateIT.java
@@ -37,6 +37,7 @@
 import com.datastax.oss.driver.api.mapper.annotations.Update;
 import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.categories.ParallelizableTests;
 import com.datastax.oss.driver.internal.core.util.concurrent.CompletableFutures;
@@ -65,14 +66,18 @@ public class UpdateIT extends InventoryITBase {
   @BeforeClass
   public static void setup() {
     CqlSession session = SESSION_RULE.session();
-
-    for (String query : createStatements(CCM_RULE)) {
-      session.execute(
-          SimpleStatement.builder(query).setExecutionProfile(SESSION_RULE.slowProfile()).build());
-    }
-    session.execute(
-        SimpleStatement.newInstance("CREATE TABLE only_p_k(id uuid PRIMARY KEY)")
-            .setExecutionProfile(SESSION_RULE.slowProfile()));
+    SchemaChangeSynchronizer.withLock(
+        () -> {
+          for (String query : createStatements(CCM_RULE)) {
+            session.execute(
+                SimpleStatement.builder(query)
+                    .setExecutionProfile(SESSION_RULE.slowProfile())
+                    .build());
+          }
+          session.execute(
+              SimpleStatement.newInstance("CREATE TABLE only_p_k(id uuid PRIMARY KEY)")
+                  .setExecutionProfile(SESSION_RULE.slowProfile()));
+        });
 
     inventoryMapper = new UpdateIT_InventoryMapperBuilder(session).build();
     dao = inventoryMapper.productDao(SESSION_RULE.keyspace());
diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/CcmStagedReactor.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/CcmStagedReactor.java
index 8a520488e5c..8b140930870 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/CcmStagedReactor.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/CcmStagedReactor.java
@@ -81,7 +81,7 @@ public synchronized void afterSuite() {
     if (running) {
       LOGGER.info("Stopping CCM");
       CCM_BRIDGE.stop();
-      CCM_BRIDGE.remove();
+      CCM_BRIDGE.close();
       running = false;
       LOGGER.info("CCM stopped");
     }
diff --git a/pom.xml b/pom.xml
index 082daeb3566..94311719e5f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -991,6 +991,17 @@ limitations under the License.]]></inlineHeader>
         <jdk>[11,)</jdk>
       </activation>
     </profile>
+    <profile>
+      <!-- workarounds for running tests with JDK14 -->
+      <id>test-jdk-14</id>
+      <activation>
+        <jdk>[14,)</jdk>
+      </activation>
+      <properties>
+        <!-- for DriverBlockHoundIntegrationIT when using JDK 13+, see https://github.com/reactor/BlockHound/issues/33 -->
+        <blockhound.argline>-XX:+AllowRedefinitionToAddDeleteMethods</blockhound.argline>
+      </properties>
+    </profile>
     <profile>
       <!-- workarounds for running tests with JDK17 -->
       <id>test-jdk-17</id>
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/BaseCcmRule.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/BaseCcmRule.java
index b8b684ee5b2..65210acd2a2 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/BaseCcmRule.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/BaseCcmRule.java
@@ -38,7 +38,7 @@ public abstract class BaseCcmRule extends CassandraResourceRule {
             new Thread(
                 () -> {
                   try {
-                    ccmBridge.remove();
+                    ccmBridge.close();
                   } catch (Exception e) {
                     // silently remove as may have already been removed.
                   }
@@ -53,7 +53,7 @@ protected void before() {
 
   @Override
   protected void after() {
-    ccmBridge.remove();
+    ccmBridge.close();
   }
 
   @Override
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
index 98739e7715d..995513e3919 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
@@ -197,9 +197,10 @@ public Version getCassandraVersion() {
   }
 
   private String getCcmVersionString(Version version) {
-    // for 4.0 pre-releases, the CCM version string needs to be "4.0-alpha1" or "4.0-alpha2"
-    // Version.toString() always adds a patch value, even if it's not specified when parsing.
-    if (version.getMajor() == 4
+    // for 4.0 or 5.0 pre-releases, the CCM version string needs to be "4.0-alpha1", "4.0-alpha2" or
+    // "5.0-beta1" Version.toString() always adds a patch value, even if it's not specified when
+    // parsing.
+    if (version.getMajor() >= 4
         && version.getMinor() == 0
         && version.getPatch() == 0
         && version.getPreReleaseLabels() != null) {
@@ -292,8 +293,7 @@ public void reloadCore(int node, String keyspace, String table, boolean reindex)
   public void start() {
     if (started.compareAndSet(false, true)) {
       List<String> cmdAndArgs = Lists.newArrayList("start", jvmArgs, "--wait-for-binary-proto");
-      overrideJvmVersionForDseWorkloads()
-          .ifPresent(jvmVersion -> cmdAndArgs.add(String.format("--jvm_version=%d", jvmVersion)));
+      updateJvmVersion(cmdAndArgs);
       try {
         execute(cmdAndArgs.toArray(new String[0]));
       } catch (RuntimeException re) {
@@ -324,9 +324,13 @@ public void resume(int n) {
 
   public void start(int n) {
     List<String> cmdAndArgs = Lists.newArrayList("node" + n, "start");
+    updateJvmVersion(cmdAndArgs);
+    execute(cmdAndArgs.toArray(new String[0]));
+  }
+
+  private void updateJvmVersion(List<String> cmdAndArgs) {
     overrideJvmVersionForDseWorkloads()
         .ifPresent(jvmVersion -> cmdAndArgs.add(String.format("--jvm_version=%d", jvmVersion)));
-    execute(cmdAndArgs.toArray(new String[0]));
   }
 
   public void stop(int n) {
@@ -423,7 +427,9 @@ protected void processLine(String line, int logLevel) {
 
   @Override
   public void close() {
-    remove();
+    if (created.compareAndSet(true, false)) {
+      remove();
+    }
   }
 
   /**
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/SchemaChangeSynchronizer.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/SchemaChangeSynchronizer.java
new file mode 100644
index 00000000000..093d1d3f9f9
--- /dev/null
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/SchemaChangeSynchronizer.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.api.testinfra.ccm;
+
+import java.util.concurrent.Semaphore;
+
+/**
+ * Running multiple parallel integration tests may fail due to query timeout when trying to apply
+ * several schema changes at once. Limit concurrently executed DDLs to 5.
+ */
+public class SchemaChangeSynchronizer {
+  private static final Semaphore lock = new Semaphore(5);
+
+  public static void withLock(Runnable callback) {
+    try {
+      lock.acquire();
+      try {
+        callback.run();
+      } finally {
+        lock.release();
+      }
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new RuntimeException("Thread interrupted wile waiting to obtain DDL lock", e);
+    }
+  }
+}
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/session/SessionRule.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/session/SessionRule.java
index ce3903bcfcb..5396e5c6cc6 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/session/SessionRule.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/session/SessionRule.java
@@ -29,6 +29,7 @@
 import com.datastax.oss.driver.api.core.session.Session;
 import com.datastax.oss.driver.api.testinfra.CassandraResourceRule;
 import com.datastax.oss.driver.api.testinfra.ccm.BaseCcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.simulacron.SimulacronRule;
 import java.util.Objects;
 import java.util.Optional;
@@ -195,7 +196,10 @@ protected void after() {
               ScriptGraphStatement.SYNC);
     }
     if (keyspace != null) {
-      SessionUtils.dropKeyspace(session, keyspace, slowProfile);
+      SchemaChangeSynchronizer.withLock(
+          () -> {
+            SessionUtils.dropKeyspace(session, keyspace, slowProfile);
+          });
     }
     session.close();
   }

From 811acb2fe77464f679a09226a03c1995694c51b4 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Tue, 4 Jun 2024 10:45:28 +0200
Subject: [PATCH 025/126] CASSANDRA-19635: Configure Jenkins to run integration
 tests with C* 5.x

patch by Lukasz Antoniak; reviewed by Bret McGuire for CASSANDRA-19635
---
 Jenkinsfile | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index d38b7c63849..4f1ef95d101 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -261,7 +261,7 @@ pipeline {
                 '3.11',      // Previous Apache CassandraⓇ
                 '4.0',       // Previous Apache CassandraⓇ
                 '4.1',       // Current Apache CassandraⓇ
-                '5.0',       // Development Apache CassandraⓇ
+                '5.0-beta1',    // Development Apache CassandraⓇ
                 'dse-4.8.16',   // Previous EOSL DataStax Enterprise
                 'dse-5.0.15',   // Long Term Support DataStax Enterprise
                 'dse-5.1.35',   // Legacy DataStax Enterprise
@@ -411,14 +411,14 @@ pipeline {
   triggers {
     // schedules only run against release branches (i.e. 3.x, 4.x, 4.5.x, etc.)
     parameterizedCron(branchPatternCron().matcher(env.BRANCH_NAME).matches() ? """
-      # Every weeknight (Monday - Friday) around 2:00 AM
-      ### JDK8 tests against 2.1, 3.0, DSE 4.8, DSE 5.0, DSE 5.1, dse-6.0.18 and DSE 6.7
-      H 2 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=2.1 3.0 dse-4.8.16 dse-5.0.15 dse-5.1.35 dse-6.0.18 dse-6.7.17;CI_SCHEDULE_JABBA_VERSION=1.8
-      ### JDK11 tests against 3.11, 4.0 and DSE 6.8
-      H 2 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.0 dse-6.8.30;CI_SCHEDULE_JABBA_VERSION=openjdk@1.11
-      # Every weekend (Sunday) around 12:00 PM noon
-      ### JDK14 tests against 3.11, 4.0 and DSE 6.8
-      H 12 * * 0 %CI_SCHEDULE=WEEKENDS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.0 dse-6.8.30;CI_SCHEDULE_JABBA_VERSION=openjdk@1.14
+      # Every weekend (Saturday, Sunday) around 2:00 AM
+      ### JDK8 tests against 2.1, 3.0, 4.0, DSE 4.8, DSE 5.0, DSE 5.1, dse-6.0.18 and DSE 6.7
+      H 2 * * 0 %CI_SCHEDULE=WEEKENDS;CI_SCHEDULE_SERVER_VERSIONS=2.1 3.0 4.0 dse-4.8.16 dse-5.0.15 dse-5.1.35 dse-6.0.18 dse-6.7.17;CI_SCHEDULE_JABBA_VERSION=1.8
+      # Every weeknight (Monday - Friday) around 12:00 PM noon
+      ### JDK11 tests against 3.11, 4.1, 5.0-beta1 and DSE 6.8
+      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30;CI_SCHEDULE_JABBA_VERSION=openjdk@1.11
+      ### JDK17 tests against 3.11, 4.1, 5.0-beta1 and DSE 6.8
+      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30;CI_SCHEDULE_JABBA_VERSION=openjdk@1.17
     """ : "")
   }
 
@@ -452,8 +452,8 @@ pipeline {
         axes {
           axis {
             name 'SERVER_VERSION'
-            values '3.11',     // Latest stable Apache CassandraⓇ
-                   '4.1',      // Development Apache CassandraⓇ
+            values '3.11',      // Latest stable Apache CassandraⓇ
+                   '4.1',       // Development Apache CassandraⓇ
                    'dse-6.8.30' // Current DataStax Enterprise
           }
           axis {
@@ -565,7 +565,7 @@ pipeline {
                    '3.11',      // Previous Apache CassandraⓇ
                    '4.0',       // Previous Apache CassandraⓇ
                    '4.1',       // Current Apache CassandraⓇ
-                   '5.0',       // Development Apache CassandraⓇ
+                   '5.0-beta1',    // Development Apache CassandraⓇ
                    'dse-4.8.16',   // Previous EOSL DataStax Enterprise
                    'dse-5.0.15',   // Last EOSL DataStax Enterprise
                    'dse-5.1.35',   // Legacy DataStax Enterprise

From 85bb4065098b887d2dda26eb14423ce4fc687045 Mon Sep 17 00:00:00 2001
From: Brad Schoening <bschoeni@gmail.com>
Date: Tue, 4 Jun 2024 17:30:41 -0400
Subject: [PATCH 026/126] update badge URL to
 org.apache.cassandra/java-driver-core

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c53c8f2db29..2a30cb68c9a 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,8 @@
 
 :warning: The java-driver has recently been donated by Datastax to The Apache Software Foundation and the Apache Cassandra project.  Bear with us as we move assets and coordinates.
 
-[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.datastax.oss/java-driver-core/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.datastax.oss/java-driver-core)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.apache.cassandra/java-driver-core/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.apache.cassandra/java-driver-core)
 
 *If you're reading this on github.com, please note that this is the readme for the development 
 version and that some features described here might not yet have been released. You can find the

From d0a1e44a4415c7a0489f8c35ee9ce49e20d7bc61 Mon Sep 17 00:00:00 2001
From: Benoit Tellier <btellier@linagora.com>
Date: Sun, 22 Jan 2023 13:58:19 +0700
Subject: [PATCH 027/126] Limit calls to Conversions.resolveExecutionProfile

Those repeated calls account for a non-negligible portion of my application
CPU (0.6%) and can definitly be a final field so that it gets resolved only
once per CqlRequestHandler.

patch by Benoit Tellier; reviewed by Andy Tolbert, and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1623
---
 .../ContinuousRequestHandlerBase.java         | 15 +++---
 .../core/graph/GraphRequestHandler.java       | 15 +++---
 .../driver/internal/core/cql/Conversions.java | 38 +++++++++++--
 .../internal/core/cql/CqlPrepareHandler.java  | 11 ++--
 .../internal/core/cql/CqlRequestHandler.java  | 54 +++++++------------
 5 files changed, 75 insertions(+), 58 deletions(-)

diff --git a/core/src/main/java/com/datastax/dse/driver/internal/core/cql/continuous/ContinuousRequestHandlerBase.java b/core/src/main/java/com/datastax/dse/driver/internal/core/cql/continuous/ContinuousRequestHandlerBase.java
index 44df3b3a03d..9a7be344721 100644
--- a/core/src/main/java/com/datastax/dse/driver/internal/core/cql/continuous/ContinuousRequestHandlerBase.java
+++ b/core/src/main/java/com/datastax/dse/driver/internal/core/cql/continuous/ContinuousRequestHandlerBase.java
@@ -648,12 +648,13 @@ public void operationComplete(@NonNull Future<java.lang.Void> future) {
         }
       } else {
         LOG.trace("[{}] Request sent on {}", logPrefix, channel);
-        if (scheduleSpeculativeExecution && Conversions.resolveIdempotence(statement, context)) {
+        if (scheduleSpeculativeExecution
+            && Conversions.resolveIdempotence(statement, executionProfile)) {
           int nextExecution = executionIndex + 1;
           // Note that `node` is the first node of the execution, it might not be the "slow" one
           // if there were retries, but in practice retries are rare.
           long nextDelay =
-              Conversions.resolveSpeculativeExecutionPolicy(statement, context)
+              Conversions.resolveSpeculativeExecutionPolicy(context, executionProfile)
                   .nextExecution(node, keyspace, statement, nextExecution);
           if (nextDelay >= 0) {
             scheduleSpeculativeExecution(nextExecution, nextDelay);
@@ -787,12 +788,12 @@ public void onFailure(@NonNull Throwable error) {
       cancelTimeout(pageTimeout);
       LOG.trace(String.format("[%s] Request failure", logPrefix), error);
       RetryVerdict verdict;
-      if (!Conversions.resolveIdempotence(statement, context)
+      if (!Conversions.resolveIdempotence(statement, executionProfile)
           || error instanceof FrameTooLongException) {
         verdict = RetryVerdict.RETHROW;
       } else {
         try {
-          RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(statement, context);
+          RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(context, executionProfile);
           verdict = retryPolicy.onRequestAbortedVerdict(statement, error, retryCount);
         } catch (Throwable cause) {
           abort(
@@ -945,7 +946,7 @@ private void processRecoverableError(@NonNull CoordinatorException error) {
       assert lock.isHeldByCurrentThread();
       NodeMetricUpdater metricUpdater = ((DefaultNode) node).getMetricUpdater();
       RetryVerdict verdict;
-      RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(statement, context);
+      RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(context, executionProfile);
       if (error instanceof ReadTimeoutException) {
         ReadTimeoutException readTimeout = (ReadTimeoutException) error;
         verdict =
@@ -964,7 +965,7 @@ private void processRecoverableError(@NonNull CoordinatorException error) {
             DefaultNodeMetric.IGNORES_ON_READ_TIMEOUT);
       } else if (error instanceof WriteTimeoutException) {
         WriteTimeoutException writeTimeout = (WriteTimeoutException) error;
-        if (Conversions.resolveIdempotence(statement, context)) {
+        if (Conversions.resolveIdempotence(statement, executionProfile)) {
           verdict =
               retryPolicy.onWriteTimeoutVerdict(
                   statement,
@@ -999,7 +1000,7 @@ private void processRecoverableError(@NonNull CoordinatorException error) {
             DefaultNodeMetric.IGNORES_ON_UNAVAILABLE);
       } else {
         verdict =
-            Conversions.resolveIdempotence(statement, context)
+            Conversions.resolveIdempotence(statement, executionProfile)
                 ? retryPolicy.onErrorResponseVerdict(statement, error, retryCount)
                 : RetryVerdict.RETHROW;
         updateErrorMetrics(
diff --git a/core/src/main/java/com/datastax/dse/driver/internal/core/graph/GraphRequestHandler.java b/core/src/main/java/com/datastax/dse/driver/internal/core/graph/GraphRequestHandler.java
index c2298458805..702da69b855 100644
--- a/core/src/main/java/com/datastax/dse/driver/internal/core/graph/GraphRequestHandler.java
+++ b/core/src/main/java/com/datastax/dse/driver/internal/core/graph/GraphRequestHandler.java
@@ -557,12 +557,13 @@ public void operationComplete(Future<java.lang.Void> future) {
           cancel();
         } else {
           inFlightCallbacks.add(this);
-          if (scheduleNextExecution && Conversions.resolveIdempotence(statement, context)) {
+          if (scheduleNextExecution
+              && Conversions.resolveIdempotence(statement, executionProfile)) {
             int nextExecution = execution + 1;
             long nextDelay;
             try {
               nextDelay =
-                  Conversions.resolveSpeculativeExecutionPolicy(statement, context)
+                  Conversions.resolveSpeculativeExecutionPolicy(context, executionProfile)
                       .nextExecution(node, null, statement, nextExecution);
             } catch (Throwable cause) {
               // This is a bug in the policy, but not fatal since we have at least one other
@@ -678,7 +679,7 @@ private void processErrorResponse(Error errorMessage) {
         trackNodeError(node, error, NANOTIME_NOT_MEASURED_YET);
         setFinalError(statement, error, node, execution);
       } else {
-        RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(statement, context);
+        RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(context, executionProfile);
         RetryVerdict verdict;
         if (error instanceof ReadTimeoutException) {
           ReadTimeoutException readTimeout = (ReadTimeoutException) error;
@@ -699,7 +700,7 @@ private void processErrorResponse(Error errorMessage) {
         } else if (error instanceof WriteTimeoutException) {
           WriteTimeoutException writeTimeout = (WriteTimeoutException) error;
           verdict =
-              Conversions.resolveIdempotence(statement, context)
+              Conversions.resolveIdempotence(statement, executionProfile)
                   ? retryPolicy.onWriteTimeoutVerdict(
                       statement,
                       writeTimeout.getConsistencyLevel(),
@@ -731,7 +732,7 @@ private void processErrorResponse(Error errorMessage) {
               DefaultNodeMetric.IGNORES_ON_UNAVAILABLE);
         } else {
           verdict =
-              Conversions.resolveIdempotence(statement, context)
+              Conversions.resolveIdempotence(statement, executionProfile)
                   ? retryPolicy.onErrorResponseVerdict(statement, error, retryCount)
                   : RetryVerdict.RETHROW;
           updateErrorMetrics(
@@ -810,12 +811,12 @@ public void onFailure(Throwable error) {
       }
       LOG.trace("[{}] Request failure, processing: {}", logPrefix, error);
       RetryVerdict verdict;
-      if (!Conversions.resolveIdempotence(statement, context)
+      if (!Conversions.resolveIdempotence(statement, executionProfile)
           || error instanceof FrameTooLongException) {
         verdict = RetryVerdict.RETHROW;
       } else {
         try {
-          RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(statement, context);
+          RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(context, executionProfile);
           verdict = retryPolicy.onRequestAbortedVerdict(statement, error, retryCount);
         } catch (Throwable cause) {
           setFinalError(
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/Conversions.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/Conversions.java
index 529664c6666..ff9384b3e24 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/Conversions.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/Conversions.java
@@ -535,29 +535,59 @@ public static CoordinatorException toThrowable(
     }
   }
 
+  /** Use {@link #resolveIdempotence(Request, DriverExecutionProfile)} instead. */
+  @Deprecated
   public static boolean resolveIdempotence(Request request, InternalDriverContext context) {
+    return resolveIdempotence(request, resolveExecutionProfile(request, context));
+  }
+
+  public static boolean resolveIdempotence(
+      Request request, DriverExecutionProfile executionProfile) {
     Boolean requestIsIdempotent = request.isIdempotent();
-    DriverExecutionProfile executionProfile = resolveExecutionProfile(request, context);
     return (requestIsIdempotent == null)
         ? executionProfile.getBoolean(DefaultDriverOption.REQUEST_DEFAULT_IDEMPOTENCE)
         : requestIsIdempotent;
   }
 
+  /** Use {@link #resolveRequestTimeout(Request, DriverExecutionProfile)} instead. */
+  @Deprecated
   public static Duration resolveRequestTimeout(Request request, InternalDriverContext context) {
-    DriverExecutionProfile executionProfile = resolveExecutionProfile(request, context);
-    return request.getTimeout() != null
-        ? request.getTimeout()
+    return resolveRequestTimeout(request, resolveExecutionProfile(request, context));
+  }
+
+  public static Duration resolveRequestTimeout(
+      Request request, DriverExecutionProfile executionProfile) {
+    Duration timeout = request.getTimeout();
+    return timeout != null
+        ? timeout
         : executionProfile.getDuration(DefaultDriverOption.REQUEST_TIMEOUT);
   }
 
+  /** Use {@link #resolveRetryPolicy(InternalDriverContext, DriverExecutionProfile)} instead. */
+  @Deprecated
   public static RetryPolicy resolveRetryPolicy(Request request, InternalDriverContext context) {
     DriverExecutionProfile executionProfile = resolveExecutionProfile(request, context);
     return context.getRetryPolicy(executionProfile.getName());
   }
 
+  public static RetryPolicy resolveRetryPolicy(
+      InternalDriverContext context, DriverExecutionProfile executionProfile) {
+    return context.getRetryPolicy(executionProfile.getName());
+  }
+
+  /**
+   * Use {@link #resolveSpeculativeExecutionPolicy(InternalDriverContext, DriverExecutionProfile)}
+   * instead.
+   */
+  @Deprecated
   public static SpeculativeExecutionPolicy resolveSpeculativeExecutionPolicy(
       Request request, InternalDriverContext context) {
     DriverExecutionProfile executionProfile = resolveExecutionProfile(request, context);
     return context.getSpeculativeExecutionPolicy(executionProfile.getName());
   }
+
+  public static SpeculativeExecutionPolicy resolveSpeculativeExecutionPolicy(
+      InternalDriverContext context, DriverExecutionProfile executionProfile) {
+    return context.getSpeculativeExecutionPolicy(executionProfile.getName());
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareHandler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareHandler.java
index 6faa8eee59f..8fe1adb20b1 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareHandler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareHandler.java
@@ -92,6 +92,7 @@ public class CqlPrepareHandler implements Throttled {
   private final Timeout scheduledTimeout;
   private final RequestThrottler throttler;
   private final Boolean prepareOnAllNodes;
+  private final DriverExecutionProfile executionProfile;
   private volatile InitialPrepareCallback initialCallback;
 
   // The errors on the nodes that were already tried (lazily initialized on the first error).
@@ -111,7 +112,7 @@ protected CqlPrepareHandler(
     this.initialRequest = request;
     this.session = session;
     this.context = context;
-    DriverExecutionProfile executionProfile = Conversions.resolveExecutionProfile(request, context);
+    executionProfile = Conversions.resolveExecutionProfile(request, context);
     this.queryPlan =
         context
             .getLoadBalancingPolicyWrapper()
@@ -131,7 +132,7 @@ protected CqlPrepareHandler(
         });
     this.timer = context.getNettyOptions().getTimer();
 
-    Duration timeout = Conversions.resolveRequestTimeout(request, context);
+    Duration timeout = Conversions.resolveRequestTimeout(request, executionProfile);
     this.scheduledTimeout = scheduleTimeout(timeout);
     this.prepareOnAllNodes = executionProfile.getBoolean(DefaultDriverOption.PREPARE_ON_ALL_NODES);
 
@@ -292,7 +293,7 @@ private CompletionStage<Void> prepareOnOtherNode(PrepareRequest request, Node no
               false,
               toPrepareMessage(request),
               request.getCustomPayload(),
-              Conversions.resolveRequestTimeout(request, context),
+              Conversions.resolveRequestTimeout(request, executionProfile),
               throttler,
               session.getMetricUpdater(),
               logPrefix);
@@ -419,7 +420,7 @@ private void processErrorResponse(Error errorMessage) {
       } else {
         // Because prepare requests are known to always be idempotent, we call the retry policy
         // directly, without checking the flag.
-        RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(request, context);
+        RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(context, executionProfile);
         RetryVerdict verdict = retryPolicy.onErrorResponseVerdict(request, error, retryCount);
         processRetryVerdict(verdict, error);
       }
@@ -457,7 +458,7 @@ public void onFailure(Throwable error) {
       LOG.trace("[{}] Request failure, processing: {}", logPrefix, error.toString());
       RetryVerdict verdict;
       try {
-        RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(request, context);
+        RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(context, executionProfile);
         verdict = retryPolicy.onRequestAbortedVerdict(request, error, retryCount);
       } catch (Throwable cause) {
         setFinalError(
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
index e7e334d57d8..a1c6b0e5466 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
@@ -126,6 +126,7 @@ public class CqlRequestHandler implements Throttled {
   private final RequestThrottler throttler;
   private final RequestTracker requestTracker;
   private final SessionMetricUpdater sessionMetricUpdater;
+  private final DriverExecutionProfile executionProfile;
 
   // The errors on the nodes that were already tried (lazily initialized on the first error).
   // We don't use a map because nodes can appear multiple times.
@@ -167,7 +168,8 @@ protected CqlRequestHandler(
     this.sessionMetricUpdater = session.getMetricUpdater();
 
     this.timer = context.getNettyOptions().getTimer();
-    Duration timeout = Conversions.resolveRequestTimeout(statement, context);
+    this.executionProfile = Conversions.resolveExecutionProfile(initialStatement, context);
+    Duration timeout = Conversions.resolveRequestTimeout(statement, executionProfile);
     this.scheduledTimeout = scheduleTimeout(timeout);
 
     this.throttler = context.getRequestThrottler();
@@ -176,8 +178,6 @@ protected CqlRequestHandler(
 
   @Override
   public void onThrottleReady(boolean wasDelayed) {
-    DriverExecutionProfile executionProfile =
-        Conversions.resolveExecutionProfile(initialStatement, context);
     if (wasDelayed
         // avoid call to nanoTime() if metric is disabled:
         && sessionMetricUpdater.isEnabled(
@@ -276,8 +276,6 @@ private void sendRequest(
               retryCount,
               scheduleNextExecution,
               logPrefix);
-      DriverExecutionProfile executionProfile =
-          Conversions.resolveExecutionProfile(statement, context);
       Message message = Conversions.toMessage(statement, executionProfile, context);
       channel
           .write(message, statement.isTracing(), statement.getCustomPayload(), nodeResponseCallback)
@@ -336,37 +334,28 @@ private void setFinalResult(
           totalLatencyNanos = completionTimeNanos - startTimeNanos;
           long nodeLatencyNanos = completionTimeNanos - callback.nodeStartTimeNanos;
           requestTracker.onNodeSuccess(
-              callback.statement,
-              nodeLatencyNanos,
-              callback.executionProfile,
-              callback.node,
-              logPrefix);
+              callback.statement, nodeLatencyNanos, executionProfile, callback.node, logPrefix);
           requestTracker.onSuccess(
-              callback.statement,
-              totalLatencyNanos,
-              callback.executionProfile,
-              callback.node,
-              logPrefix);
+              callback.statement, totalLatencyNanos, executionProfile, callback.node, logPrefix);
         }
         if (sessionMetricUpdater.isEnabled(
-            DefaultSessionMetric.CQL_REQUESTS, callback.executionProfile.getName())) {
+            DefaultSessionMetric.CQL_REQUESTS, executionProfile.getName())) {
           if (completionTimeNanos == NANOTIME_NOT_MEASURED_YET) {
             completionTimeNanos = System.nanoTime();
             totalLatencyNanos = completionTimeNanos - startTimeNanos;
           }
           sessionMetricUpdater.updateTimer(
               DefaultSessionMetric.CQL_REQUESTS,
-              callback.executionProfile.getName(),
+              executionProfile.getName(),
               totalLatencyNanos,
               TimeUnit.NANOSECONDS);
         }
       }
       // log the warnings if they have NOT been disabled
       if (!executionInfo.getWarnings().isEmpty()
-          && callback.executionProfile.getBoolean(DefaultDriverOption.REQUEST_LOG_WARNINGS)
+          && executionProfile.getBoolean(DefaultDriverOption.REQUEST_LOG_WARNINGS)
           && LOG.isWarnEnabled()) {
-        logServerWarnings(
-            callback.statement, callback.executionProfile, executionInfo.getWarnings());
+        logServerWarnings(callback.statement, executionProfile, executionInfo.getWarnings());
       }
     } catch (Throwable error) {
       setFinalError(callback.statement, error, callback.node, -1);
@@ -418,21 +407,17 @@ private ExecutionInfo buildExecutionInfo(
         schemaInAgreement,
         session,
         context,
-        callback.executionProfile);
+        executionProfile);
   }
 
   @Override
   public void onThrottleFailure(@NonNull RequestThrottlingException error) {
-    DriverExecutionProfile executionProfile =
-        Conversions.resolveExecutionProfile(initialStatement, context);
     sessionMetricUpdater.incrementCounter(
         DefaultSessionMetric.THROTTLING_ERRORS, executionProfile.getName());
     setFinalError(initialStatement, error, null, -1);
   }
 
   private void setFinalError(Statement<?> statement, Throwable error, Node node, int execution) {
-    DriverExecutionProfile executionProfile =
-        Conversions.resolveExecutionProfile(statement, context);
     if (error instanceof DriverException) {
       ((DriverException) error)
           .setExecutionInfo(
@@ -475,7 +460,6 @@ private class NodeResponseCallback
 
     private final long nodeStartTimeNanos = System.nanoTime();
     private final Statement<?> statement;
-    private final DriverExecutionProfile executionProfile;
     private final Node node;
     private final Queue<Node> queryPlan;
     private final DriverChannel channel;
@@ -505,7 +489,6 @@ private NodeResponseCallback(
       this.retryCount = retryCount;
       this.scheduleNextExecution = scheduleNextExecution;
       this.logPrefix = logPrefix + "|" + execution;
-      this.executionProfile = Conversions.resolveExecutionProfile(statement, context);
     }
 
     // this gets invoked once the write completes.
@@ -544,12 +527,13 @@ public void operationComplete(Future<java.lang.Void> future) throws Exception {
           cancel();
         } else {
           inFlightCallbacks.add(this);
-          if (scheduleNextExecution && Conversions.resolveIdempotence(statement, context)) {
+          if (scheduleNextExecution
+              && Conversions.resolveIdempotence(statement, executionProfile)) {
             int nextExecution = execution + 1;
             long nextDelay;
             try {
               nextDelay =
-                  Conversions.resolveSpeculativeExecutionPolicy(statement, context)
+                  Conversions.resolveSpeculativeExecutionPolicy(context, executionProfile)
                       .nextExecution(node, keyspace, statement, nextExecution);
             } catch (Throwable cause) {
               // This is a bug in the policy, but not fatal since we have at least one other
@@ -697,7 +681,7 @@ private void processErrorResponse(Error errorMessage) {
                 true,
                 reprepareMessage,
                 repreparePayload.customPayload,
-                Conversions.resolveRequestTimeout(statement, context),
+                Conversions.resolveRequestTimeout(statement, executionProfile),
                 throttler,
                 sessionMetricUpdater,
                 logPrefix);
@@ -767,7 +751,7 @@ private void processErrorResponse(Error errorMessage) {
         trackNodeError(node, error, NANOTIME_NOT_MEASURED_YET);
         setFinalError(statement, error, node, execution);
       } else {
-        RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(statement, context);
+        RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(context, executionProfile);
         RetryVerdict verdict;
         if (error instanceof ReadTimeoutException) {
           ReadTimeoutException readTimeout = (ReadTimeoutException) error;
@@ -788,7 +772,7 @@ private void processErrorResponse(Error errorMessage) {
         } else if (error instanceof WriteTimeoutException) {
           WriteTimeoutException writeTimeout = (WriteTimeoutException) error;
           verdict =
-              Conversions.resolveIdempotence(statement, context)
+              Conversions.resolveIdempotence(statement, executionProfile)
                   ? retryPolicy.onWriteTimeoutVerdict(
                       statement,
                       writeTimeout.getConsistencyLevel(),
@@ -820,7 +804,7 @@ private void processErrorResponse(Error errorMessage) {
               DefaultNodeMetric.IGNORES_ON_UNAVAILABLE);
         } else {
           verdict =
-              Conversions.resolveIdempotence(statement, context)
+              Conversions.resolveIdempotence(statement, executionProfile)
                   ? retryPolicy.onErrorResponseVerdict(statement, error, retryCount)
                   : RetryVerdict.RETHROW;
           updateErrorMetrics(
@@ -899,12 +883,12 @@ public void onFailure(Throwable error) {
       }
       LOG.trace("[{}] Request failure, processing: {}", logPrefix, error);
       RetryVerdict verdict;
-      if (!Conversions.resolveIdempotence(statement, context)
+      if (!Conversions.resolveIdempotence(statement, executionProfile)
           || error instanceof FrameTooLongException) {
         verdict = RetryVerdict.RETHROW;
       } else {
         try {
-          RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(statement, context);
+          RetryPolicy retryPolicy = Conversions.resolveRetryPolicy(context, executionProfile);
           verdict = retryPolicy.onRequestAbortedVerdict(statement, error, retryCount);
         } catch (Throwable cause) {
           setFinalError(

From a17f7be614a09ab81bc2982b7f7ab3a123b4ab28 Mon Sep 17 00:00:00 2001
From: Stefan Miklosovic <smiklosovic@apache.org>
Date: Thu, 22 Aug 2024 14:28:46 +0200
Subject: [PATCH 028/126] autolink JIRA tickets in commit messages

patch by Stefan Miklosovic; reviewed by Michael Semb Wever for CASSANDRA-19854
---
 .asf.yaml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.asf.yaml b/.asf.yaml
index 5ebca4b6e33..ad58f536398 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -19,6 +19,7 @@ notifications:
   commits:      commits@cassandra.apache.org
   issues:       commits@cassandra.apache.org
   pullrequests: pr@cassandra.apache.org
+  jira_options: link worklog
 
 github:
   description: "Java Driver for Apache Cassandra®"
@@ -31,6 +32,5 @@ github:
     wiki: false
     issues: false
     projects: false
-
-notifications:
-  jira_options: link worklog
+  autolink_jira:
+    - CASSANDRA

From 0962794b2ec724d9939cd47380e68b979b46f693 Mon Sep 17 00:00:00 2001
From: Ammar Khaku <ammar.khaku@gmail.com>
Date: Sun, 20 Nov 2022 19:14:07 -0800
Subject: [PATCH 029/126] Don't return empty routing key when partition key is
 unbound

DefaultBoundStatement#getRoutingKey has logic to infer the
routing key when no one has explicitly called setRoutingKey
or otherwise set the routing key on the statement.
It however doesn't check for cases where nothing has been
bound yet on the statement.
This causes more problems if the user decides to get a
BoundStatementBuilder from the PreparedStatement, set some
fields on it, and then copy it by constructing new
BoundStatementBuilder objects with the BoundStatement as a
parameter, since the empty ByteBuffer gets copied to all
bound statements, resulting in all requests being targeted
to the same Cassandra node in a token-aware load balancing
policy.

patch by Ammar Khaku; reviewed by Andy Tolbert, and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1620
---
 .../core/cql/DefaultBoundStatement.java       |  3 ++-
 .../driver/core/cql/PreparedStatementIT.java  | 19 +++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/DefaultBoundStatement.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/DefaultBoundStatement.java
index fb6b8fd7b27..3cf99c1be6e 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/DefaultBoundStatement.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/DefaultBoundStatement.java
@@ -360,7 +360,8 @@ public ByteBuffer getRoutingKey() {
       if (indices.isEmpty()) {
         return null;
       } else if (indices.size() == 1) {
-        return getBytesUnsafe(indices.get(0));
+        int index = indices.get(0);
+        return isSet(index) ? getBytesUnsafe(index) : null;
       } else {
         ByteBuffer[] components = new ByteBuffer[indices.size()];
         for (int i = 0; i < components.length; i++) {
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementIT.java
index c0df01e3519..5671a7684e5 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementIT.java
@@ -527,6 +527,25 @@ private void should_infer_routing_information_when_partition_key_is_bound(String
     assertThat(tokenFactory.hash(boundStatement.getRoutingKey())).isEqualTo(expectedToken);
   }
 
+  @Test
+  public void should_return_null_routing_information_when_single_partition_key_is_unbound() {
+    should_return_null_routing_information_when_single_partition_key_is_unbound(
+        "SELECT a FROM prepared_statement_test WHERE a = ?");
+    should_return_null_routing_information_when_single_partition_key_is_unbound(
+        "INSERT INTO prepared_statement_test (a) VALUES (?)");
+    should_return_null_routing_information_when_single_partition_key_is_unbound(
+        "UPDATE prepared_statement_test SET b = 1 WHERE a = ?");
+    should_return_null_routing_information_when_single_partition_key_is_unbound(
+        "DELETE FROM prepared_statement_test WHERE a = ?");
+  }
+
+  private void should_return_null_routing_information_when_single_partition_key_is_unbound(
+      String queryString) {
+    CqlSession session = sessionRule.session();
+    BoundStatement boundStatement = session.prepare(queryString).bind();
+    assertThat(boundStatement.getRoutingKey()).isNull();
+  }
+
   private static Iterable<Row> firstPageOf(CompletionStage<AsyncResultSet> stage) {
     return CompletableFutures.getUninterruptibly(stage).currentPage();
   }

From e6ae1933667066bf16ac3ac5203a2a6fdadd1946 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Fri, 16 Aug 2024 11:06:09 +0200
Subject: [PATCH 030/126] JAVA-3167: CompletableFutures.allSuccessful() may
 return never completed future

patch by Lukasz Antoniak; reviewed by Andy Tolbert, and Bret McGuire for JAVA-3167
---
 .../util/concurrent/CompletableFutures.java   |  5 +++-
 .../concurrent/CompletableFuturesTest.java    | 29 +++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFuturesTest.java

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFutures.java b/core/src/main/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFutures.java
index 03265bd1d77..275b2ddfeef 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFutures.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFutures.java
@@ -100,7 +100,10 @@ public static <T> CompletionStage<Void> allSuccessful(List<CompletionStage<T>> i
                 } else {
                   Throwable finalError = errors.get(0);
                   for (int i = 1; i < errors.size(); i++) {
-                    finalError.addSuppressed(errors.get(i));
+                    Throwable suppressedError = errors.get(i);
+                    if (finalError != suppressedError) {
+                      finalError.addSuppressed(suppressedError);
+                    }
                   }
                   result.completeExceptionally(finalError);
                 }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFuturesTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFuturesTest.java
new file mode 100644
index 00000000000..8a710e02d50
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFuturesTest.java
@@ -0,0 +1,29 @@
+package com.datastax.oss.driver.internal.core.util.concurrent;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+
+public class CompletableFuturesTest {
+  @Test
+  public void should_not_suppress_identical_exceptions() throws Exception {
+    RuntimeException error = new RuntimeException();
+    CompletableFuture<Void> future1 = new CompletableFuture<>();
+    future1.completeExceptionally(error);
+    CompletableFuture<Void> future2 = new CompletableFuture<>();
+    future2.completeExceptionally(error);
+    try {
+      // if timeout exception is thrown, it indicates that CompletableFutures.allSuccessful()
+      // did not complete the returned future and potentially caller will wait infinitely
+      CompletableFutures.allSuccessful(Arrays.asList(future1, future2))
+          .toCompletableFuture()
+          .get(1, TimeUnit.SECONDS);
+    } catch (ExecutionException e) {
+      assertThat(e.getCause()).isEqualTo(error);
+    }
+  }
+}

From 5ee12acfff720047db7611a6f54450c1646031a3 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Tue, 3 Sep 2024 16:06:04 -0500
Subject: [PATCH 031/126] ninja-fix Various test fixes

---
 .../concurrent/CompletableFuturesTest.java    | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFuturesTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFuturesTest.java
index 8a710e02d50..04f96f185fd 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFuturesTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/util/concurrent/CompletableFuturesTest.java
@@ -1,6 +1,24 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.util.concurrent;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
 
 import java.util.Arrays;
 import java.util.concurrent.CompletableFuture;
@@ -22,6 +40,7 @@ public void should_not_suppress_identical_exceptions() throws Exception {
       CompletableFutures.allSuccessful(Arrays.asList(future1, future2))
           .toCompletableFuture()
           .get(1, TimeUnit.SECONDS);
+      fail();
     } catch (ExecutionException e) {
       assertThat(e.getCause()).isEqualTo(error);
     }

From 9cfb4f6712e392c1b6c87db268565fd3b27d0c5c Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Thu, 5 Sep 2024 13:04:52 +0200
Subject: [PATCH 032/126] Run integration tests with DSE 6.9.0

patch by Lukasz Antoniak; reviewed by Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1955
---
 Jenkinsfile                                   | 19 +++++++++++++------
 .../datastax/oss/driver/api/core/Version.java |  1 +
 .../driver/api/testinfra/ccm/CcmBridge.java   |  3 ++-
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 4f1ef95d101..4cc20d79604 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -268,6 +268,7 @@ pipeline {
                 'dse-6.0.18',   // Previous DataStax Enterprise
                 'dse-6.7.17',   // Previous DataStax Enterprise
                 'dse-6.8.30',   // Current DataStax Enterprise
+                'dse-6.9.0',    // Current DataStax Enterprise
                 'ALL'],
       description: '''Apache Cassandra&reg; and DataStax Enterprise server version to use for adhoc <b>BUILD-AND-EXECUTE-TESTS</b> builds
                       <table style="width:100%">
@@ -325,6 +326,10 @@ pipeline {
                           <td><strong>dse-6.8.30</strong></td>
                           <td>DataStax Enterprise v6.8.x</td>
                         </tr>
+                        <tr>
+                          <td><strong>dse-6.9.0</strong></td>
+                          <td>DataStax Enterprise v6.9.x</td>
+                        </tr>
                       </table>''')
     choice(
       name: 'ADHOC_BUILD_AND_EXECUTE_TESTS_JABBA_VERSION',
@@ -416,9 +421,9 @@ pipeline {
       H 2 * * 0 %CI_SCHEDULE=WEEKENDS;CI_SCHEDULE_SERVER_VERSIONS=2.1 3.0 4.0 dse-4.8.16 dse-5.0.15 dse-5.1.35 dse-6.0.18 dse-6.7.17;CI_SCHEDULE_JABBA_VERSION=1.8
       # Every weeknight (Monday - Friday) around 12:00 PM noon
       ### JDK11 tests against 3.11, 4.1, 5.0-beta1 and DSE 6.8
-      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30;CI_SCHEDULE_JABBA_VERSION=openjdk@1.11
+      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30 dse-6.9.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.11
       ### JDK17 tests against 3.11, 4.1, 5.0-beta1 and DSE 6.8
-      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30;CI_SCHEDULE_JABBA_VERSION=openjdk@1.17
+      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30 dse-6.9.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.17
     """ : "")
   }
 
@@ -452,9 +457,10 @@ pipeline {
         axes {
           axis {
             name 'SERVER_VERSION'
-            values '3.11',      // Latest stable Apache CassandraⓇ
-                   '4.1',       // Development Apache CassandraⓇ
-                   'dse-6.8.30' // Current DataStax Enterprise
+            values '3.11',       // Latest stable Apache CassandraⓇ
+                   '4.1',        // Development Apache CassandraⓇ
+                   'dse-6.8.30', // Current DataStax Enterprise
+                   'dse-6.9.0'   // Current DataStax Enterprise
           }
           axis {
             name 'JABBA_VERSION'
@@ -571,7 +577,8 @@ pipeline {
                    'dse-5.1.35',   // Legacy DataStax Enterprise
                    'dse-6.0.18',   // Previous DataStax Enterprise
                    'dse-6.7.17',   // Previous DataStax Enterprise
-                   'dse-6.8.30'    // Current DataStax Enterprise
+                   'dse-6.8.30',   // Current DataStax Enterprise
+                   'dse-6.9.0'     // Current DataStax Enterprise
           }
         }
         when {
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/Version.java b/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
index 3f12c54faf7..4de006da268 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
@@ -56,6 +56,7 @@ public class Version implements Comparable<Version>, Serializable {
   @NonNull public static final Version V5_0_0 = Objects.requireNonNull(parse("5.0.0"));
   @NonNull public static final Version V6_7_0 = Objects.requireNonNull(parse("6.7.0"));
   @NonNull public static final Version V6_8_0 = Objects.requireNonNull(parse("6.8.0"));
+  @NonNull public static final Version V6_9_0 = Objects.requireNonNull(parse("6.9.0"));
 
   private final int major;
   private final int minor;
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
index 995513e3919..5b0c114a5fe 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
@@ -479,7 +479,8 @@ private Optional<Integer> overrideJvmVersionForDseWorkloads() {
       return Optional.empty();
     }
 
-    if (getDseVersion().get().compareTo(Version.parse("6.8.19")) < 0) {
+    if (getDseVersion().get().compareTo(Version.V6_9_0) >= 0) {
+      // DSE 6.9.0 supports only JVM 11 onwards (also with graph workload)
       return Optional.empty();
     }
 

From c961012000efffd3d50476d4549487f7fc538c01 Mon Sep 17 00:00:00 2001
From: Henry Hughes <henry.hughes@datastax.com>
Date: Wed, 23 Aug 2023 15:35:42 -0700
Subject: [PATCH 033/126] JAVA-3117: Call CcmCustomRule#after if
 CcmCustomRule#before fails to allow subsequent tests to run

patch by Henry Hughes; reviewed by Alexandre Dutra and Andy Tolbert for JAVA-3117
---
 .../api/testinfra/ccm/CustomCcmRule.java       | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CustomCcmRule.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CustomCcmRule.java
index 58bafd438f8..cf150b12f55 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CustomCcmRule.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CustomCcmRule.java
@@ -18,6 +18,8 @@
 package com.datastax.oss.driver.api.testinfra.ccm;
 
 import java.util.concurrent.atomic.AtomicReference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * A rule that creates a ccm cluster that can be used in a test. This should be used if you plan on
@@ -30,6 +32,7 @@
  */
 public class CustomCcmRule extends BaseCcmRule {
 
+  private static final Logger LOG = LoggerFactory.getLogger(CustomCcmRule.class);
   private static final AtomicReference<CustomCcmRule> CURRENT = new AtomicReference<>();
 
   CustomCcmRule(CcmBridge ccmBridge) {
@@ -39,7 +42,20 @@ public class CustomCcmRule extends BaseCcmRule {
   @Override
   protected void before() {
     if (CURRENT.get() == null && CURRENT.compareAndSet(null, this)) {
-      super.before();
+      try {
+        super.before();
+      } catch (Exception e) {
+        // ExternalResource will not call after() when before() throws an exception
+        // Let's try and clean up and release the lock we have in CURRENT
+        LOG.warn(
+            "Error in CustomCcmRule before() method, attempting to clean up leftover state", e);
+        try {
+          after();
+        } catch (Exception e1) {
+          LOG.warn("Error cleaning up CustomCcmRule before() failure", e1);
+        }
+        throw e;
+      }
     } else if (CURRENT.get() != this) {
       throw new IllegalStateException(
           "Attempting to use a Ccm rule while another is in use.  This is disallowed");

From 77805f5103354cadb360384f4f41e0eca73d72f4 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Mon, 2 Sep 2024 06:44:53 +0200
Subject: [PATCH 034/126] JAVA-3149: Support request cancellation in request
 throttler patch by Lukasz Antoniak; reviewed by Andy Tolbert and Chris
 Lohfink for JAVA-3149

---
 .../ContinuousRequestHandlerBase.java         |  1 +
 .../core/graph/GraphRequestHandler.java       |  1 +
 .../session/throttling/RequestThrottler.java  |  8 +++++
 .../internal/core/cql/CqlPrepareHandler.java  |  1 +
 .../internal/core/cql/CqlRequestHandler.java  |  1 +
 .../ConcurrencyLimitingRequestThrottler.java  | 16 +++++++++
 .../PassThroughRequestThrottler.java          |  5 +++
 .../RateLimitingRequestThrottler.java         | 12 +++++++
 ...ncurrencyLimitingRequestThrottlerTest.java |  5 +++
 .../RateLimitingRequestThrottlerTest.java     | 13 ++++++-
 .../driver/core/throttling/ThrottlingIT.java  | 34 +++++++++++++++----
 11 files changed, 89 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/com/datastax/dse/driver/internal/core/cql/continuous/ContinuousRequestHandlerBase.java b/core/src/main/java/com/datastax/dse/driver/internal/core/cql/continuous/ContinuousRequestHandlerBase.java
index 9a7be344721..0453022cb6a 100644
--- a/core/src/main/java/com/datastax/dse/driver/internal/core/cql/continuous/ContinuousRequestHandlerBase.java
+++ b/core/src/main/java/com/datastax/dse/driver/internal/core/cql/continuous/ContinuousRequestHandlerBase.java
@@ -410,6 +410,7 @@ public void cancel() {
 
     cancelScheduledTasks(null);
     cancelGlobalTimeout();
+    throttler.signalCancel(this);
   }
 
   private void cancelGlobalTimeout() {
diff --git a/core/src/main/java/com/datastax/dse/driver/internal/core/graph/GraphRequestHandler.java b/core/src/main/java/com/datastax/dse/driver/internal/core/graph/GraphRequestHandler.java
index 702da69b855..5c9ceb00df2 100644
--- a/core/src/main/java/com/datastax/dse/driver/internal/core/graph/GraphRequestHandler.java
+++ b/core/src/main/java/com/datastax/dse/driver/internal/core/graph/GraphRequestHandler.java
@@ -153,6 +153,7 @@ public class GraphRequestHandler implements Throttled {
           try {
             if (t instanceof CancellationException) {
               cancelScheduledTasks();
+              context.getRequestThrottler().signalCancel(this);
             }
           } catch (Throwable t2) {
             Loggers.warnWithException(LOG, "[{}] Uncaught exception", logPrefix, t2);
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.java b/core/src/main/java/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.java
index cb55fac336c..7e2b41ebbdb 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.java
@@ -56,4 +56,12 @@ public interface RequestThrottler extends Closeable {
    * perform time-based eviction on pending requests.
    */
   void signalTimeout(@NonNull Throttled request);
+
+  /**
+   * Signals that a request has been cancelled. This indicates to the throttler that another request
+   * might be started.
+   */
+  default void signalCancel(@NonNull Throttled request) {
+    // no-op for backward compatibility purposes
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareHandler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareHandler.java
index 8fe1adb20b1..1ee1f303ab2 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareHandler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareHandler.java
@@ -124,6 +124,7 @@ protected CqlPrepareHandler(
           try {
             if (t instanceof CancellationException) {
               cancelTimeout();
+              context.getRequestThrottler().signalCancel(this);
             }
           } catch (Throwable t2) {
             Loggers.warnWithException(LOG, "[{}] Uncaught exception", logPrefix, t2);
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
index a1c6b0e5466..0808bdce63f 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
@@ -152,6 +152,7 @@ protected CqlRequestHandler(
           try {
             if (t instanceof CancellationException) {
               cancelScheduledTasks();
+              context.getRequestThrottler().signalCancel(this);
             }
           } catch (Throwable t2) {
             Loggers.warnWithException(LOG, "[{}] Uncaught exception", logPrefix, t2);
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
index e8f27467c6f..438bed0953b 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
@@ -145,6 +145,22 @@ public void signalTimeout(@NonNull Throttled request) {
     }
   }
 
+  @Override
+  public void signalCancel(@NonNull Throttled request) {
+    lock.lock();
+    try {
+      if (!closed) {
+        if (queue.remove(request)) { // The request has been cancelled before it was active
+          LOG.trace("[{}] Removing cancelled request from the queue", logPrefix);
+        } else {
+          onRequestDone();
+        }
+      }
+    } finally {
+      lock.unlock();
+    }
+  }
+
   @SuppressWarnings("GuardedBy") // this method is only called with the lock held
   private void onRequestDone() {
     assert lock.isHeldByCurrentThread();
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/PassThroughRequestThrottler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/PassThroughRequestThrottler.java
index 714c712a4e8..2210e4b26f1 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/PassThroughRequestThrottler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/PassThroughRequestThrottler.java
@@ -69,6 +69,11 @@ public void signalTimeout(@NonNull Throttled request) {
     // nothing to do
   }
 
+  @Override
+  public void signalCancel(@NonNull Throttled request) {
+    // nothing to do
+  }
+
   @Override
   public void close() throws IOException {
     // nothing to do
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottler.java
index 6536804ffee..03a693dc0fe 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottler.java
@@ -198,6 +198,18 @@ public void signalTimeout(@NonNull Throttled request) {
     }
   }
 
+  @Override
+  public void signalCancel(@NonNull Throttled request) {
+    lock.lock();
+    try {
+      if (!closed && queue.remove(request)) { // The request has been cancelled before it was active
+        LOG.trace("[{}] Removing cancelled request from the queue", logPrefix);
+      }
+    } finally {
+      lock.unlock();
+    }
+  }
+
   @Override
   public void close() {
     lock.lock();
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottlerTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottlerTest.java
index b587ac3daa2..c01b26c1e9f 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottlerTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottlerTest.java
@@ -88,6 +88,11 @@ public void should_allow_new_request_when_active_one_times_out() {
     should_allow_new_request_when_active_one_completes(throttler::signalTimeout);
   }
 
+  @Test
+  public void should_allow_new_request_when_active_one_canceled() {
+    should_allow_new_request_when_active_one_completes(throttler::signalCancel);
+  }
+
   private void should_allow_new_request_when_active_one_completes(
       Consumer<Throttled> completeCallback) {
     // Given
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottlerTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottlerTest.java
index 7336fb447b6..0e0fe7c1c65 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottlerTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottlerTest.java
@@ -25,6 +25,7 @@
 import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverConfig;
 import com.datastax.oss.driver.api.core.config.DriverExecutionProfile;
+import com.datastax.oss.driver.api.core.session.throttling.Throttled;
 import com.datastax.oss.driver.internal.core.context.InternalDriverContext;
 import com.datastax.oss.driver.internal.core.context.NettyOptions;
 import com.datastax.oss.driver.internal.core.util.concurrent.ScheduledTaskCapturingEventLoop;
@@ -33,6 +34,7 @@
 import java.time.Duration;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -164,6 +166,15 @@ public void should_reject_when_queue_is_full() {
 
   @Test
   public void should_remove_timed_out_request_from_queue() {
+    testRemoveInvalidEventFromQueue(throttler::signalTimeout);
+  }
+
+  @Test
+  public void should_remove_cancel_request_from_queue() {
+    testRemoveInvalidEventFromQueue(throttler::signalCancel);
+  }
+
+  private void testRemoveInvalidEventFromQueue(Consumer<Throttled> completeCallback) {
     // Given
     for (int i = 0; i < 5; i++) {
       throttler.register(new MockThrottled());
@@ -174,7 +185,7 @@ public void should_remove_timed_out_request_from_queue() {
     throttler.register(queued2);
 
     // When
-    throttler.signalTimeout(queued1);
+    completeCallback.accept(queued1);
 
     // Then
     assertThatStage(queued2.started).isNotDone();
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/throttling/ThrottlingIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/throttling/ThrottlingIT.java
index a6e7295eb09..6fa1a37355b 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/throttling/ThrottlingIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/throttling/ThrottlingIT.java
@@ -24,13 +24,16 @@
 import com.datastax.oss.driver.api.core.RequestThrottlingException;
 import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.api.testinfra.simulacron.SimulacronRule;
 import com.datastax.oss.driver.categories.ParallelizableTests;
 import com.datastax.oss.driver.internal.core.session.throttling.ConcurrencyLimitingRequestThrottler;
 import com.datastax.oss.simulacron.common.cluster.ClusterSpec;
 import com.datastax.oss.simulacron.common.stubbing.PrimeDsl;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.TimeUnit;
+import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
@@ -39,21 +42,20 @@
 public class ThrottlingIT {
 
   private static final String QUERY = "select * from foo";
+  private static final int maxConcurrentRequests = 10;
+  private static final int maxQueueSize = 10;
 
   @Rule public SimulacronRule simulacron = new SimulacronRule(ClusterSpec.builder().withNodes(1));
 
-  @Test
-  public void should_reject_request_when_throttling_by_concurrency() {
+  private DriverConfigLoader loader = null;
 
+  @Before
+  public void setUp() {
     // Add a delay so that requests don't complete during the test
     simulacron
         .cluster()
         .prime(PrimeDsl.when(QUERY).then(PrimeDsl.noRows()).delay(5, TimeUnit.SECONDS));
-
-    int maxConcurrentRequests = 10;
-    int maxQueueSize = 10;
-
-    DriverConfigLoader loader =
+    loader =
         SessionUtils.configLoaderBuilder()
             .withClass(
                 DefaultDriverOption.REQUEST_THROTTLER_CLASS,
@@ -63,7 +65,10 @@ public void should_reject_request_when_throttling_by_concurrency() {
                 maxConcurrentRequests)
             .withInt(DefaultDriverOption.REQUEST_THROTTLER_MAX_QUEUE_SIZE, maxQueueSize)
             .build();
+  }
 
+  @Test
+  public void should_reject_request_when_throttling_by_concurrency() {
     try (CqlSession session = SessionUtils.newSession(simulacron, loader)) {
 
       // Saturate the session and fill the queue
@@ -81,4 +86,19 @@ public void should_reject_request_when_throttling_by_concurrency() {
                   + "(concurrent requests: 10, queue size: 10)");
     }
   }
+
+  @Test
+  public void should_propagate_cancel_to_throttler() {
+    try (CqlSession session = SessionUtils.newSession(simulacron, loader)) {
+
+      // Try to saturate the session and fill the queue
+      for (int i = 0; i < maxConcurrentRequests + maxQueueSize; i++) {
+        CompletionStage<AsyncResultSet> future = session.executeAsync(QUERY);
+        future.toCompletableFuture().cancel(true);
+      }
+
+      // The next query should be successful, because the previous queries were cancelled
+      session.execute(QUERY);
+    }
+  }
 }

From 4fb51081a3a71b2017ddc3f43a7945e3a9d19e25 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Mon, 10 Jun 2024 12:42:29 +0200
Subject: [PATCH 035/126] Fix C* 3.0 tests failing on Jenkins patch by Lukasz
 Antoniak; reviewed by Bret McGuire reference: #1939

---
 .../test/java/com/datastax/oss/driver/mapper/DeleteIT.java  | 3 +--
 .../com/datastax/oss/driver/mapper/InventoryITBase.java     | 6 +++++-
 .../oss/driver/mapper/SelectCustomWhereClauseIT.java        | 2 +-
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteIT.java
index 0acdbeae53a..03e3597501c 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteIT.java
@@ -60,8 +60,7 @@
     description = ">= in WHERE clause not supported in legacy versions")
 public class DeleteIT extends InventoryITBase {
 
-  private static CustomCcmRule CCM_RULE =
-      CustomCcmRule.builder().withCassandraConfiguration("enable_sasi_indexes", "true").build();
+  private static CustomCcmRule CCM_RULE = CustomCcmRule.builder().build();
 
   private static final SessionRule<CqlSession> SESSION_RULE = SessionRule.builder(CCM_RULE).build();
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
index 2be025b3739..9495003ae49 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
@@ -59,6 +59,10 @@ public abstract class InventoryITBase {
       new ProductSale(MP3_DOWNLOAD.getId(), DATE_3, 7, Uuids.startOf(915192000), 0.99, 12);
 
   protected static List<String> createStatements(BaseCcmRule ccmRule) {
+    return createStatements(ccmRule, false);
+  }
+
+  protected static List<String> createStatements(BaseCcmRule ccmRule, boolean requiresSasiIndex) {
     ImmutableList.Builder<String> builder =
         ImmutableList.<String>builder()
             .add(
@@ -71,7 +75,7 @@ protected static List<String> createStatements(BaseCcmRule ccmRule) {
                 "CREATE TABLE product_sale(id uuid, day text, ts uuid, customer_id int, price "
                     + "double, count int, PRIMARY KEY ((id, day), customer_id, ts))");
 
-    if (supportsSASI(ccmRule) && !isSasiBroken(ccmRule)) {
+    if (requiresSasiIndex && supportsSASI(ccmRule) && !isSasiBroken(ccmRule)) {
       builder.add(
           "CREATE CUSTOM INDEX product_description ON product(description) "
               + "USING 'org.apache.cassandra.index.sasi.SASIIndex' "
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectCustomWhereClauseIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectCustomWhereClauseIT.java
index 3df1ccd21a7..1f1b92b8623 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectCustomWhereClauseIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/SelectCustomWhereClauseIT.java
@@ -75,7 +75,7 @@ public static void setup() {
 
     SchemaChangeSynchronizer.withLock(
         () -> {
-          for (String query : createStatements(CCM_RULE)) {
+          for (String query : createStatements(CCM_RULE, true)) {
             session.execute(
                 SimpleStatement.builder(query)
                     .setExecutionProfile(SESSION_RULE.slowProfile())

From 6d3ba47631ebde78460168a2d33c4facde0bd731 Mon Sep 17 00:00:00 2001
From: Jason Koch <jkoch@netflix.com>
Date: Mon, 12 Aug 2024 22:52:13 -0700
Subject: [PATCH 036/126] Reduce lock held duration in
 ConcurrencyLimitingRequestThrottler

It might take some (small) time for callback handling when the
throttler request proceeds to submission.

Before this change, the throttler proceed request will happen while
holding the lock, preventing other tasks from proceeding when there is
spare capacity and even preventing tasks from enqueuing until the
callback completes.

By tracking the expected outcome, we can perform the callback outside
of the lock. This means that request registration and submission can
proceed even when a long callback is being processed.

patch by Jason Koch; Reviewed by Andy Tolbert and Chris Lohfink for CASSANDRA-19922
---
 .../ConcurrencyLimitingRequestThrottler.java  |  39 ++++-
 ...ncurrencyLimitingRequestThrottlerTest.java | 143 ++++++++++++++++--
 .../session/throttling/MockThrottled.java     |  30 +++-
 .../RateLimitingRequestThrottlerTest.java     |  30 ++--
 4 files changed, 206 insertions(+), 36 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
index 438bed0953b..ffe0ffe9650 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
@@ -25,6 +25,7 @@
 import com.datastax.oss.driver.api.core.session.throttling.Throttled;
 import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
 import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.concurrent.locks.ReentrantLock;
@@ -87,6 +88,8 @@ public ConcurrencyLimitingRequestThrottler(DriverContext context) {
 
   @Override
   public void register(@NonNull Throttled request) {
+    boolean notifyReadyRequired = false;
+
     lock.lock();
     try {
       if (closed) {
@@ -96,7 +99,7 @@ public void register(@NonNull Throttled request) {
         // We have capacity for one more concurrent request
         LOG.trace("[{}] Starting newly registered request", logPrefix);
         concurrentRequests += 1;
-        request.onThrottleReady(false);
+        notifyReadyRequired = true;
       } else if (queue.size() < maxQueueSize) {
         LOG.trace("[{}] Enqueuing request", logPrefix);
         queue.add(request);
@@ -112,16 +115,26 @@ public void register(@NonNull Throttled request) {
     } finally {
       lock.unlock();
     }
+
+    // no need to hold the lock while allowing the task to progress
+    if (notifyReadyRequired) {
+      request.onThrottleReady(false);
+    }
   }
 
   @Override
   public void signalSuccess(@NonNull Throttled request) {
+    Throttled nextRequest = null;
     lock.lock();
     try {
-      onRequestDone();
+      nextRequest = onRequestDoneAndDequeNext();
     } finally {
       lock.unlock();
     }
+
+    if (nextRequest != null) {
+      nextRequest.onThrottleReady(true);
+    }
   }
 
   @Override
@@ -131,48 +144,62 @@ public void signalError(@NonNull Throttled request, @NonNull Throwable error) {
 
   @Override
   public void signalTimeout(@NonNull Throttled request) {
+    Throttled nextRequest = null;
     lock.lock();
     try {
       if (!closed) {
         if (queue.remove(request)) { // The request timed out before it was active
           LOG.trace("[{}] Removing timed out request from the queue", logPrefix);
         } else {
-          onRequestDone();
+          nextRequest = onRequestDoneAndDequeNext();
         }
       }
     } finally {
       lock.unlock();
     }
+
+    if (nextRequest != null) {
+      nextRequest.onThrottleReady(true);
+    }
   }
 
   @Override
   public void signalCancel(@NonNull Throttled request) {
+    Throttled nextRequest = null;
     lock.lock();
     try {
       if (!closed) {
         if (queue.remove(request)) { // The request has been cancelled before it was active
           LOG.trace("[{}] Removing cancelled request from the queue", logPrefix);
         } else {
-          onRequestDone();
+          nextRequest = onRequestDoneAndDequeNext();
         }
       }
     } finally {
       lock.unlock();
     }
+
+    if (nextRequest != null) {
+      nextRequest.onThrottleReady(true);
+    }
   }
 
   @SuppressWarnings("GuardedBy") // this method is only called with the lock held
-  private void onRequestDone() {
+  @Nullable
+  private Throttled onRequestDoneAndDequeNext() {
     assert lock.isHeldByCurrentThread();
     if (!closed) {
       if (queue.isEmpty()) {
         concurrentRequests -= 1;
       } else {
         LOG.trace("[{}] Starting dequeued request", logPrefix);
-        queue.poll().onThrottleReady(true);
         // don't touch concurrentRequests since we finished one but started another
+        return queue.poll();
       }
     }
+
+    // no next task was dequeued
+    return null;
   }
 
   @Override
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottlerTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottlerTest.java
index c01b26c1e9f..7eb682070cd 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottlerTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottlerTest.java
@@ -29,6 +29,7 @@
 import com.datastax.oss.driver.api.core.session.throttling.Throttled;
 import com.datastax.oss.driver.shaded.guava.common.collect.Lists;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
 import java.util.function.Consumer;
 import org.junit.Before;
 import org.junit.Test;
@@ -67,7 +68,7 @@ public void should_start_immediately_when_under_capacity() {
     throttler.register(request);
 
     // Then
-    assertThatStage(request.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
+    assertThatStage(request.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
     assertThat(throttler.getConcurrentRequests()).isEqualTo(1);
     assertThat(throttler.getQueue()).isEmpty();
   }
@@ -98,7 +99,7 @@ private void should_allow_new_request_when_active_one_completes(
     // Given
     MockThrottled first = new MockThrottled();
     throttler.register(first);
-    assertThatStage(first.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
+    assertThatStage(first.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
     for (int i = 0; i < 4; i++) { // fill to capacity
       throttler.register(new MockThrottled());
     }
@@ -113,7 +114,7 @@ private void should_allow_new_request_when_active_one_completes(
     throttler.register(incoming);
 
     // Then
-    assertThatStage(incoming.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
+    assertThatStage(incoming.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
     assertThat(throttler.getConcurrentRequests()).isEqualTo(5);
     assertThat(throttler.getQueue()).isEmpty();
   }
@@ -132,7 +133,7 @@ public void should_enqueue_when_over_capacity() {
     throttler.register(incoming);
 
     // Then
-    assertThatStage(incoming.started).isNotDone();
+    assertThatStage(incoming.ended).isNotDone();
     assertThat(throttler.getConcurrentRequests()).isEqualTo(5);
     assertThat(throttler.getQueue()).containsExactly(incoming);
   }
@@ -157,20 +158,20 @@ private void should_dequeue_when_active_completes(Consumer<Throttled> completeCa
     // Given
     MockThrottled first = new MockThrottled();
     throttler.register(first);
-    assertThatStage(first.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
+    assertThatStage(first.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
     for (int i = 0; i < 4; i++) {
       throttler.register(new MockThrottled());
     }
 
     MockThrottled incoming = new MockThrottled();
     throttler.register(incoming);
-    assertThatStage(incoming.started).isNotDone();
+    assertThatStage(incoming.ended).isNotDone();
 
     // When
     completeCallback.accept(first);
 
     // Then
-    assertThatStage(incoming.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isTrue());
+    assertThatStage(incoming.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isTrue());
     assertThat(throttler.getConcurrentRequests()).isEqualTo(5);
     assertThat(throttler.getQueue()).isEmpty();
   }
@@ -189,7 +190,7 @@ public void should_reject_when_queue_is_full() {
     throttler.register(incoming);
 
     // Then
-    assertThatStage(incoming.started)
+    assertThatStage(incoming.ended)
         .isFailed(error -> assertThat(error).isInstanceOf(RequestThrottlingException.class));
   }
 
@@ -208,7 +209,7 @@ public void should_remove_timed_out_request_from_queue() {
     throttler.signalTimeout(queued1);
 
     // Then
-    assertThatStage(queued2.started).isNotDone();
+    assertThatStage(queued2.ended).isNotDone();
     assertThat(throttler.getConcurrentRequests()).isEqualTo(5);
     assertThat(throttler.getQueue()).hasSize(1);
   }
@@ -223,7 +224,7 @@ public void should_reject_enqueued_when_closing() {
     for (int i = 0; i < 10; i++) {
       MockThrottled request = new MockThrottled();
       throttler.register(request);
-      assertThatStage(request.started).isNotDone();
+      assertThatStage(request.ended).isNotDone();
       enqueued.add(request);
     }
 
@@ -232,7 +233,7 @@ public void should_reject_enqueued_when_closing() {
 
     // Then
     for (MockThrottled request : enqueued) {
-      assertThatStage(request.started)
+      assertThatStage(request.ended)
           .isFailed(error -> assertThat(error).isInstanceOf(RequestThrottlingException.class));
     }
 
@@ -241,7 +242,125 @@ public void should_reject_enqueued_when_closing() {
     throttler.register(request);
 
     // Then
-    assertThatStage(request.started)
+    assertThatStage(request.ended)
         .isFailed(error -> assertThat(error).isInstanceOf(RequestThrottlingException.class));
   }
+
+  @Test
+  public void should_run_throttle_callbacks_concurrently() throws InterruptedException {
+    // Given
+
+    // a task is enqueued, which when in onThrottleReady, will stall latch countDown()ed
+    // register() should automatically start onThrottleReady on same thread
+
+    // start a parallel thread
+    CountDownLatch firstRelease = new CountDownLatch(1);
+    MockThrottled first = new MockThrottled(firstRelease);
+    Runnable r =
+        () -> {
+          throttler.register(first);
+          first.ended.toCompletableFuture().thenRun(() -> throttler.signalSuccess(first));
+        };
+    Thread t = new Thread(r);
+    t.start();
+
+    // wait for the registration threads to reach await state
+    assertThatStage(first.started).isSuccess();
+    assertThatStage(first.ended).isNotDone();
+
+    // When
+    // we concurrently submit a second shorter task
+    MockThrottled second = new MockThrottled();
+    // (on a second thread, so that we can join and force a timeout in case
+    // registration is delayed)
+    Thread t2 = new Thread(() -> throttler.register(second));
+    t2.start();
+    t2.join(1_000);
+
+    // Then
+    // registration will trigger callback, should complete ~immediately
+    assertThatStage(second.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
+    // first should still be unfinished
+    assertThatStage(first.started).isDone();
+    assertThatStage(first.ended).isNotDone();
+    // now finish, and verify
+    firstRelease.countDown();
+    assertThatStage(first.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
+
+    t.join(1_000);
+  }
+
+  @Test
+  public void should_enqueue_tasks_quickly_when_callbacks_blocked() throws InterruptedException {
+    // Given
+
+    // Multiple tasks are registered, up to the limit, and proceed into their
+    // callback
+
+    // start five parallel threads
+    final int THREADS = 5;
+    Thread[] threads = new Thread[THREADS];
+    CountDownLatch[] latches = new CountDownLatch[THREADS];
+    MockThrottled[] throttled = new MockThrottled[THREADS];
+    for (int i = 0; i < threads.length; i++) {
+      latches[i] = new CountDownLatch(1);
+      final MockThrottled itThrottled = new MockThrottled(latches[i]);
+      throttled[i] = itThrottled;
+      threads[i] =
+          new Thread(
+              () -> {
+                throttler.register(itThrottled);
+                itThrottled
+                    .ended
+                    .toCompletableFuture()
+                    .thenRun(() -> throttler.signalSuccess(itThrottled));
+              });
+      threads[i].start();
+    }
+
+    // wait for the registration threads to be launched
+    // they are all waiting now
+    for (int i = 0; i < throttled.length; i++) {
+      assertThatStage(throttled[i].started).isSuccess();
+      assertThatStage(throttled[i].ended).isNotDone();
+    }
+
+    // When
+    // we concurrently submit another task
+    MockThrottled last = new MockThrottled();
+    throttler.register(last);
+
+    // Then
+    // registration will enqueue the callback, and it should not
+    // take any time to proceed (ie: we should not be blocked)
+    // and there should be an element in the queue
+    assertThatStage(last.started).isNotDone();
+    assertThatStage(last.ended).isNotDone();
+    assertThat(throttler.getQueue()).containsExactly(last);
+
+    // we still have not released, so old throttled threads should be waiting
+    for (int i = 0; i < throttled.length; i++) {
+      assertThatStage(throttled[i].started).isDone();
+      assertThatStage(throttled[i].ended).isNotDone();
+    }
+
+    // now let us release ..
+    for (int i = 0; i < latches.length; i++) {
+      latches[i].countDown();
+    }
+
+    // .. and check everything finished up OK
+    for (int i = 0; i < latches.length; i++) {
+      assertThatStage(throttled[i].started).isSuccess();
+      assertThatStage(throttled[i].ended).isSuccess();
+    }
+
+    // for good measure, we will also wait for the enqueued to complete
+    assertThatStage(last.started).isSuccess();
+    assertThatStage(last.ended).isSuccess();
+
+    for (int i = 0; i < threads.length; i++) {
+      threads[i].join(1_000);
+    }
+  }
 }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/MockThrottled.java b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/MockThrottled.java
index b7cd0ee8a54..9e54e3d511f 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/MockThrottled.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/MockThrottled.java
@@ -19,21 +19,45 @@
 
 import com.datastax.oss.driver.api.core.RequestThrottlingException;
 import com.datastax.oss.driver.api.core.session.throttling.Throttled;
+import com.datastax.oss.driver.shaded.guava.common.util.concurrent.Uninterruptibles;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CountDownLatch;
 
 class MockThrottled implements Throttled {
+  final CompletionStage<Void> started = new CompletableFuture<>();
+  final CompletionStage<Boolean> ended = new CompletableFuture<>();
+  final CountDownLatch canRelease;
 
-  final CompletionStage<Boolean> started = new CompletableFuture<>();
+  public MockThrottled() {
+    this(new CountDownLatch(0));
+  }
+
+  /*
+   * The releaseLatch can be provided to add some delay before the
+   * task readiness/fail callbacks complete. This can be used, eg, to
+   * imitate a slow callback.
+   */
+  public MockThrottled(CountDownLatch releaseLatch) {
+    this.canRelease = releaseLatch;
+  }
 
   @Override
   public void onThrottleReady(boolean wasDelayed) {
-    started.toCompletableFuture().complete(wasDelayed);
+    started.toCompletableFuture().complete(null);
+    awaitRelease();
+    ended.toCompletableFuture().complete(wasDelayed);
   }
 
   @Override
   public void onThrottleFailure(@NonNull RequestThrottlingException error) {
-    started.toCompletableFuture().completeExceptionally(error);
+    started.toCompletableFuture().complete(null);
+    awaitRelease();
+    ended.toCompletableFuture().completeExceptionally(error);
+  }
+
+  private void awaitRelease() {
+    Uninterruptibles.awaitUninterruptibly(canRelease);
   }
 }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottlerTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottlerTest.java
index 0e0fe7c1c65..1e15610bf7b 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottlerTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/session/throttling/RateLimitingRequestThrottlerTest.java
@@ -98,7 +98,7 @@ public void should_start_immediately_when_under_capacity() {
     throttler.register(request);
 
     // Then
-    assertThatStage(request.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
+    assertThatStage(request.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
     assertThat(throttler.getStoredPermits()).isEqualTo(4);
     assertThat(throttler.getQueue()).isEmpty();
   }
@@ -117,7 +117,7 @@ public void should_allow_new_request_when_under_rate() {
     throttler.register(request);
 
     // Then
-    assertThatStage(request.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
+    assertThatStage(request.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isFalse());
     assertThat(throttler.getStoredPermits()).isEqualTo(0);
     assertThat(throttler.getQueue()).isEmpty();
   }
@@ -136,7 +136,7 @@ public void should_enqueue_when_over_rate() {
     throttler.register(request);
 
     // Then
-    assertThatStage(request.started).isNotDone();
+    assertThatStage(request.ended).isNotDone();
     assertThat(throttler.getStoredPermits()).isEqualTo(0);
     assertThat(throttler.getQueue()).containsExactly(request);
 
@@ -160,7 +160,7 @@ public void should_reject_when_queue_is_full() {
     throttler.register(request);
 
     // Then
-    assertThatStage(request.started)
+    assertThatStage(request.ended)
         .isFailed(error -> assertThat(error).isInstanceOf(RequestThrottlingException.class));
   }
 
@@ -188,7 +188,7 @@ private void testRemoveInvalidEventFromQueue(Consumer<Throttled> completeCallbac
     completeCallback.accept(queued1);
 
     // Then
-    assertThatStage(queued2.started).isNotDone();
+    assertThatStage(queued2.ended).isNotDone();
     assertThat(throttler.getStoredPermits()).isEqualTo(0);
     assertThat(throttler.getQueue()).containsExactly(queued2);
   }
@@ -202,10 +202,10 @@ public void should_dequeue_when_draining_task_runs() {
 
     MockThrottled queued1 = new MockThrottled();
     throttler.register(queued1);
-    assertThatStage(queued1.started).isNotDone();
+    assertThatStage(queued1.ended).isNotDone();
     MockThrottled queued2 = new MockThrottled();
     throttler.register(queued2);
-    assertThatStage(queued2.started).isNotDone();
+    assertThatStage(queued2.ended).isNotDone();
     assertThat(throttler.getStoredPermits()).isEqualTo(0);
     assertThat(throttler.getQueue()).hasSize(2);
 
@@ -230,8 +230,8 @@ public void should_dequeue_when_draining_task_runs() {
     task.run();
 
     // Then
-    assertThatStage(queued1.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isTrue());
-    assertThatStage(queued2.started).isNotDone();
+    assertThatStage(queued1.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isTrue());
+    assertThatStage(queued2.ended).isNotDone();
     assertThat(throttler.getStoredPermits()).isEqualTo(0);
     assertThat(throttler.getQueue()).containsExactly(queued2);
     // task reschedules itself since it did not empty the queue
@@ -244,7 +244,7 @@ public void should_dequeue_when_draining_task_runs() {
     task.run();
 
     // Then
-    assertThatStage(queued2.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isTrue());
+    assertThatStage(queued2.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isTrue());
     assertThat(throttler.getStoredPermits()).isEqualTo(0);
     assertThat(throttler.getQueue()).isEmpty();
     assertThat(adminExecutor.nextTask()).isNull();
@@ -286,14 +286,14 @@ public void should_keep_accumulating_time_if_no_permits_created() {
     // Then
     MockThrottled queued = new MockThrottled();
     throttler.register(queued);
-    assertThatStage(queued.started).isNotDone();
+    assertThatStage(queued.ended).isNotDone();
 
     // When
     clock.add(ONE_HUNDRED_MILLISECONDS);
     adminExecutor.nextTask().run();
 
     // Then
-    assertThatStage(queued.started).isSuccess(wasDelayed -> assertThat(wasDelayed).isTrue());
+    assertThatStage(queued.ended).isSuccess(wasDelayed -> assertThat(wasDelayed).isTrue());
   }
 
   @Test
@@ -306,7 +306,7 @@ public void should_reject_enqueued_when_closing() {
     for (int i = 0; i < 10; i++) {
       MockThrottled request = new MockThrottled();
       throttler.register(request);
-      assertThatStage(request.started).isNotDone();
+      assertThatStage(request.ended).isNotDone();
       enqueued.add(request);
     }
 
@@ -315,7 +315,7 @@ public void should_reject_enqueued_when_closing() {
 
     // Then
     for (MockThrottled request : enqueued) {
-      assertThatStage(request.started)
+      assertThatStage(request.ended)
           .isFailed(error -> assertThat(error).isInstanceOf(RequestThrottlingException.class));
     }
 
@@ -324,7 +324,7 @@ public void should_reject_enqueued_when_closing() {
     throttler.register(request);
 
     // Then
-    assertThatStage(request.started)
+    assertThatStage(request.ended)
         .isFailed(error -> assertThat(error).isInstanceOf(RequestThrottlingException.class));
   }
 }

From 306bf3744a3d24ad01700e4e1d3c14b9a696927f Mon Sep 17 00:00:00 2001
From: Ammar Khaku <ammar.khaku@gmail.com>
Date: Fri, 30 Sep 2022 15:36:36 -0700
Subject: [PATCH 037/126] Annotate BatchStatement, Statement, SimpleStatement
 methods with CheckReturnValue

Since the driver's default implementation is for
BatchStatement and SimpleStatement methods to be immutable,
we should annotate those methods with @CheckReturnValue.
Statement#setNowInSeconds implementations are immutable so
annotate that too.

patch by Ammar Khaku; reviewed by Andy Tolbert and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1607
---
 core/revapi.json                              | 133 ++++++++++++++++++
 .../driver/api/core/cql/BatchStatement.java   |   8 ++
 .../driver/api/core/cql/SimpleStatement.java  |   7 +
 .../oss/driver/api/core/cql/Statement.java    |   1 +
 4 files changed, 149 insertions(+)

diff --git a/core/revapi.json b/core/revapi.json
index 318e29709ec..1c875895d6c 100644
--- a/core/revapi.json
+++ b/core/revapi.json
@@ -6956,6 +6956,139 @@
         "old": "method java.lang.Throwable java.lang.Throwable::fillInStackTrace() @ com.fasterxml.jackson.databind.deser.UnresolvedForwardReference",
         "new": "method com.fasterxml.jackson.databind.deser.UnresolvedForwardReference com.fasterxml.jackson.databind.deser.UnresolvedForwardReference::fillInStackTrace()",
         "justification": "Upgrade jackson-databind to 2.13.4.1 to address CVEs, API change cause: https://github.com/FasterXML/jackson-databind/issues/3419"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
+        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>",
+        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>",
+        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
+        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
+        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int)",
+        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::add(com.datastax.oss.driver.api.core.cql.BatchableStatement<?>)",
+        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::add(com.datastax.oss.driver.api.core.cql.BatchableStatement<?>)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::addAll(com.datastax.oss.driver.api.core.cql.BatchableStatement<?>[])",
+        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::addAll(com.datastax.oss.driver.api.core.cql.BatchableStatement<?>[])",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::addAll(java.lang.Iterable<? extends com.datastax.oss.driver.api.core.cql.BatchableStatement<?>>)",
+        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::addAll(java.lang.Iterable<? extends com.datastax.oss.driver.api.core.cql.BatchableStatement<?>>)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::clear()",
+        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::clear()",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setBatchType(com.datastax.oss.driver.api.core.cql.BatchType)",
+        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setBatchType(com.datastax.oss.driver.api.core.cql.BatchType)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
+        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setKeyspace(java.lang.String)",
+        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setKeyspace(java.lang.String)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setQuery(java.lang.String)",
+        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setQuery(java.lang.String)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
+        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setKeyspace(java.lang.String)",
+        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setKeyspace(java.lang.String)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setPositionalValues(java.util.List<java.lang.Object>)",
+        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setPositionalValues(java.util.List<java.lang.Object>)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValuesWithIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Object>)",
+        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValuesWithIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Object>)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.annotation.added",
+        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValues(java.util.Map<java.lang.String, java.lang.Object>)",
+        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValues(java.util.Map<java.lang.String, java.lang.Object>)",
+        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
+        "justification": "Annotate mutating methods with @CheckReturnValue"
       }
     ]
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/cql/BatchStatement.java b/core/src/main/java/com/datastax/oss/driver/api/core/cql/BatchStatement.java
index 0f37ed71ce2..9deb33c6007 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/cql/BatchStatement.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/cql/BatchStatement.java
@@ -26,6 +26,7 @@
 import com.datastax.oss.driver.internal.core.util.Sizes;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
 import com.datastax.oss.protocol.internal.PrimitiveSizes;
+import edu.umd.cs.findbugs.annotations.CheckReturnValue;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.util.ArrayList;
@@ -164,6 +165,7 @@ static BatchStatementBuilder builder(@NonNull BatchStatement template) {
    * method. However custom implementations may choose to be mutable and return the same instance.
    */
   @NonNull
+  @CheckReturnValue
   BatchStatement setBatchType(@NonNull BatchType newBatchType);
 
   /**
@@ -180,6 +182,7 @@ static BatchStatementBuilder builder(@NonNull BatchStatement template) {
    * @see Request#getKeyspace()
    */
   @NonNull
+  @CheckReturnValue
   BatchStatement setKeyspace(@Nullable CqlIdentifier newKeyspace);
 
   /**
@@ -187,6 +190,7 @@ static BatchStatementBuilder builder(@NonNull BatchStatement template) {
    * setKeyspace(CqlIdentifier.fromCql(newKeyspaceName))}.
    */
   @NonNull
+  @CheckReturnValue
   default BatchStatement setKeyspace(@NonNull String newKeyspaceName) {
     return setKeyspace(CqlIdentifier.fromCql(newKeyspaceName));
   }
@@ -201,6 +205,7 @@ default BatchStatement setKeyspace(@NonNull String newKeyspaceName) {
    * method. However custom implementations may choose to be mutable and return the same instance.
    */
   @NonNull
+  @CheckReturnValue
   BatchStatement add(@NonNull BatchableStatement<?> statement);
 
   /**
@@ -213,10 +218,12 @@ default BatchStatement setKeyspace(@NonNull String newKeyspaceName) {
    * method. However custom implementations may choose to be mutable and return the same instance.
    */
   @NonNull
+  @CheckReturnValue
   BatchStatement addAll(@NonNull Iterable<? extends BatchableStatement<?>> statements);
 
   /** @see #addAll(Iterable) */
   @NonNull
+  @CheckReturnValue
   default BatchStatement addAll(@NonNull BatchableStatement<?>... statements) {
     return addAll(Arrays.asList(statements));
   }
@@ -231,6 +238,7 @@ default BatchStatement addAll(@NonNull BatchableStatement<?>... statements) {
    * method. However custom implementations may choose to be mutable and return the same instance.
    */
   @NonNull
+  @CheckReturnValue
   BatchStatement clear();
 
   @Override
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/cql/SimpleStatement.java b/core/src/main/java/com/datastax/oss/driver/api/core/cql/SimpleStatement.java
index fd5f456f11c..ef04cd14a5b 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/cql/SimpleStatement.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/cql/SimpleStatement.java
@@ -28,6 +28,7 @@
 import com.datastax.oss.protocol.internal.PrimitiveSizes;
 import com.datastax.oss.protocol.internal.util.collection.NullAllowingImmutableList;
 import com.datastax.oss.protocol.internal.util.collection.NullAllowingImmutableMap;
+import edu.umd.cs.findbugs.annotations.CheckReturnValue;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.util.List;
@@ -197,6 +198,7 @@ static SimpleStatementBuilder builder(@NonNull SimpleStatement template) {
    * @see #setNamedValuesWithIds(Map)
    */
   @NonNull
+  @CheckReturnValue
   SimpleStatement setQuery(@NonNull String newQuery);
 
   /**
@@ -209,6 +211,7 @@ static SimpleStatementBuilder builder(@NonNull SimpleStatement template) {
    * @see Request#getKeyspace()
    */
   @NonNull
+  @CheckReturnValue
   SimpleStatement setKeyspace(@Nullable CqlIdentifier newKeyspace);
 
   /**
@@ -216,6 +219,7 @@ static SimpleStatementBuilder builder(@NonNull SimpleStatement template) {
    * setKeyspace(CqlIdentifier.fromCql(newKeyspaceName))}.
    */
   @NonNull
+  @CheckReturnValue
   default SimpleStatement setKeyspace(@NonNull String newKeyspaceName) {
     return setKeyspace(CqlIdentifier.fromCql(newKeyspaceName));
   }
@@ -236,6 +240,7 @@ default SimpleStatement setKeyspace(@NonNull String newKeyspaceName) {
    * @see #setQuery(String)
    */
   @NonNull
+  @CheckReturnValue
   SimpleStatement setPositionalValues(@NonNull List<Object> newPositionalValues);
 
   @NonNull
@@ -256,6 +261,7 @@ default SimpleStatement setKeyspace(@NonNull String newKeyspaceName) {
    * @see #setQuery(String)
    */
   @NonNull
+  @CheckReturnValue
   SimpleStatement setNamedValuesWithIds(@NonNull Map<CqlIdentifier, Object> newNamedValues);
 
   /**
@@ -263,6 +269,7 @@ default SimpleStatement setKeyspace(@NonNull String newKeyspaceName) {
    * converted on the fly with {@link CqlIdentifier#fromCql(String)}.
    */
   @NonNull
+  @CheckReturnValue
   default SimpleStatement setNamedValues(@NonNull Map<String, Object> newNamedValues) {
     return setNamedValuesWithIds(DefaultSimpleStatement.wrapKeys(newNamedValues));
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/cql/Statement.java b/core/src/main/java/com/datastax/oss/driver/api/core/cql/Statement.java
index 594c627e324..d70c56686c5 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/cql/Statement.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/cql/Statement.java
@@ -513,6 +513,7 @@ default int getNowInSeconds() {
    * @see #NO_NOW_IN_SECONDS
    */
   @NonNull
+  @CheckReturnValue
   @SuppressWarnings("unchecked")
   default SelfT setNowInSeconds(int nowInSeconds) {
     return (SelfT) this;

From 8444c79ff843a072e5c1a1d8de5140a47051e2a0 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@datastax.com>
Date: Mon, 16 Sep 2024 16:30:43 -0500
Subject: [PATCH 038/126] Remove "beta" support for Java17 from docs

patch by Bret McGuire; reviewed by Andy Tolbert and Alexandre Dutra
reference: https://github.com/apache/cassandra-java-driver/pull/1962
---
 upgrade_guide/README.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/upgrade_guide/README.md b/upgrade_guide/README.md
index c6df74ffc2a..56d55aaab36 100644
--- a/upgrade_guide/README.md
+++ b/upgrade_guide/README.md
@@ -19,7 +19,7 @@ under the License.
 
 ## Upgrade guide
 
-### NEW VERSION PLACEHOLDER
+### 4.18.1
 
 #### Keystore reloading in DefaultSslEngineFactory
 
@@ -32,12 +32,9 @@ This feature is disabled by default for compatibility. To enable, see `keystore-
 
 ### 4.17.0
 
-#### Beta support for Java17
+#### Support for Java17
 
 With the completion of [JAVA-3042](https://datastax-oss.atlassian.net/browse/JAVA-3042) the driver now passes our automated test matrix for Java Driver releases.
-While all features function normally when run with Java 17 tests, we do not offer full support for this
-platform until we've received feedback from other users in the ecosystem.
-
 If you discover an issue with the Java Driver running on Java 17, please let us know. We will triage and address Java 17 issues.
 
 #### Updated API for vector search

From a40e7587b175cc198fb533eadabd31e94f837369 Mon Sep 17 00:00:00 2001
From: Christian Aistleitner <christian.aistleitner@outlook.com>
Date: Thu, 6 Jun 2024 09:14:16 +0200
Subject: [PATCH 039/126] Fix uncaught exception during graceful channel
 shutdown

after exceeding max orphan ids

patch by Christian Aistleitner; reviewed by Andy Tolbert, and Bret McGuire for #1938
---
 .../core/channel/InFlightHandler.java         |  4 +-
 .../core/channel/InFlightHandlerTest.java     | 63 ++++++++++++++++++-
 2 files changed, 64 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/channel/InFlightHandler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/channel/InFlightHandler.java
index 9060f80b7cd..90b02f358cd 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/channel/InFlightHandler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/channel/InFlightHandler.java
@@ -199,14 +199,14 @@ private void startGracefulShutdown(ChannelHandlerContext ctx) {
       LOG.debug("[{}] No pending queries, completing graceful shutdown now", logPrefix);
       ctx.channel().close();
     } else {
-      // remove heartbeat handler from pipeline if present.
+      // Remove heartbeat handler from pipeline if present.
       ChannelHandler heartbeatHandler = ctx.pipeline().get(ChannelFactory.HEARTBEAT_HANDLER_NAME);
       if (heartbeatHandler != null) {
         ctx.pipeline().remove(heartbeatHandler);
       }
       LOG.debug("[{}] There are pending queries, delaying graceful shutdown", logPrefix);
       closingGracefully = true;
-      closeStartedFuture.setSuccess();
+      closeStartedFuture.trySuccess();
     }
   }
 
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/channel/InFlightHandlerTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/channel/InFlightHandlerTest.java
index 79a575d9eb6..35049e99af1 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/channel/InFlightHandlerTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/channel/InFlightHandlerTest.java
@@ -39,7 +39,9 @@
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelPromise;
 import java.net.InetSocketAddress;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 import org.junit.Before;
 import org.junit.Test;
@@ -256,7 +258,7 @@ public void should_refuse_new_writes_during_graceful_close() {
   }
 
   @Test
-  public void should_close_gracefully_if_orphan_ids_above_max_and_pending_requests() {
+  public void should_close_gracefully_if_orphan_ids_above_max_and_pending_request() {
     // Given
     addToPipeline();
     // Generate n orphan ids by writing and cancelling the requests:
@@ -311,6 +313,65 @@ public void should_close_gracefully_if_orphan_ids_above_max_and_pending_requests
     assertThat(channel.closeFuture()).isSuccess();
   }
 
+  @Test
+  public void should_close_gracefully_if_orphan_ids_above_max_and_multiple_pending_requests() {
+    // Given
+    addToPipeline();
+    // Generate n orphan ids by writing and cancelling the requests.
+    for (int i = 0; i < MAX_ORPHAN_IDS; i++) {
+      when(streamIds.acquire()).thenReturn(i);
+      MockResponseCallback responseCallback = new MockResponseCallback();
+      channel
+          .writeAndFlush(
+              new DriverChannel.RequestMessage(QUERY, false, Frame.NO_PAYLOAD, responseCallback))
+          .awaitUninterruptibly();
+      channel.writeAndFlush(responseCallback).awaitUninterruptibly();
+    }
+    // Generate 3 additional requests that are pending and not cancelled.
+    List<MockResponseCallback> pendingResponseCallbacks = new ArrayList<>();
+    for (int i = 0; i < 3; i++) {
+      when(streamIds.acquire()).thenReturn(MAX_ORPHAN_IDS + i);
+      MockResponseCallback responseCallback = new MockResponseCallback();
+      channel
+          .writeAndFlush(
+              new DriverChannel.RequestMessage(QUERY, false, Frame.NO_PAYLOAD, responseCallback))
+          .awaitUninterruptibly();
+      pendingResponseCallbacks.add(responseCallback);
+    }
+
+    // When
+    // Generate the n+1th orphan id that makes us go above the threshold by canceling one if the
+    // pending requests.
+    channel.writeAndFlush(pendingResponseCallbacks.remove(0)).awaitUninterruptibly();
+
+    // Then
+    // Channel should be closing gracefully but there's no way to observe that from the outside
+    // besides writing another request and check that it's rejected.
+    assertThat(channel.closeFuture()).isNotDone();
+    ChannelFuture otherWriteFuture =
+        channel.writeAndFlush(
+            new DriverChannel.RequestMessage(
+                QUERY, false, Frame.NO_PAYLOAD, new MockResponseCallback()));
+    assertThat(otherWriteFuture).isFailed();
+    assertThat(otherWriteFuture.cause())
+        .isInstanceOf(IllegalStateException.class)
+        .hasMessage("Channel is closing");
+
+    // When
+    // Cancel the remaining pending requests causing the n+ith orphan ids above the threshold.
+    for (MockResponseCallback pendingResponseCallback : pendingResponseCallbacks) {
+      ChannelFuture future = channel.writeAndFlush(pendingResponseCallback).awaitUninterruptibly();
+
+      // Then
+      // The future should succeed even though the channel has started closing gracefully.
+      assertThat(future).isSuccess();
+    }
+
+    // Then
+    // The graceful shutdown completes.
+    assertThat(channel.closeFuture()).isSuccess();
+  }
+
   @Test
   public void should_close_immediately_if_orphan_ids_above_max_and_no_pending_requests() {
     // Given

From eb57fd7d46fb8b84655e66a3ca8e9ceef77b5164 Mon Sep 17 00:00:00 2001
From: janehe <jane.he@datastax.com>
Date: Wed, 18 Sep 2024 08:49:37 +0000
Subject: [PATCH 040/126] Build a public CI for Apache Cassandra Java Driver

 patch by Siyao (Jane) He; reviewed by Mick Semb Wever for CASSANDRA-19832
---
 Jenkinsfile-asf                     | 80 +++++++++++++++++++++++++++++
 Jenkinsfile => Jenkinsfile-datastax |  0
 ci/create-user.sh                   | 60 ++++++++++++++++++++++
 ci/run-tests.sh                     | 10 ++++
 4 files changed, 150 insertions(+)
 create mode 100644 Jenkinsfile-asf
 rename Jenkinsfile => Jenkinsfile-datastax (100%)
 create mode 100644 ci/create-user.sh
 create mode 100755 ci/run-tests.sh

diff --git a/Jenkinsfile-asf b/Jenkinsfile-asf
new file mode 100644
index 00000000000..a1be4bcd4f6
--- /dev/null
+++ b/Jenkinsfile-asf
@@ -0,0 +1,80 @@
+#!groovy
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+
+pipeline {
+    agent {
+        label 'cassandra-small'
+    }
+
+    triggers {
+        // schedules only run against release branches (i.e. 3.x, 4.x, 4.5.x, etc.)
+        cron(branchPatternCron().matcher(env.BRANCH_NAME).matches() ? '@weekly' : '')
+    }
+
+    stages {
+        stage('Matrix') {
+            matrix {
+                axes {
+                    axis {
+                        name 'TEST_JAVA_VERSION'
+                        values  'openjdk@1.8.0-292', 'openjdk@1.11.0-9', 'openjdk@17'
+                    }
+                    axis {
+                        name 'SERVER_VERSION'
+                        values  '3.11.17',
+                                '4.0.13',
+                                '5.0-beta1'
+                    }
+                }
+                stages {
+                    stage('Tests') {
+                        agent {
+                            label 'cassandra-medium'
+                        }
+                        steps {
+                            script {
+                                executeTests()
+                                junit testResults: '**/target/surefire-reports/TEST-*.xml', allowEmptyResults: true
+                                junit testResults: '**/target/failsafe-reports/TEST-*.xml', allowEmptyResults: true
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+def executeTests() {
+    def testJavaMajorVersion = (TEST_JAVA_VERSION =~ /@(?:1\.)?(\d+)/)[0][1]
+    sh """
+        container_id=\$(docker run -td -e TEST_JAVA_VERSION=${TEST_JAVA_VERSION} -e SERVER_VERSION=${SERVER_VERSION} -e TEST_JAVA_MAJOR_VERSION=${testJavaMajorVersion} -v \$(pwd):/home/docker/cassandra-java-driver apache.jfrog.io/cassan-docker/apache/cassandra-java-driver-testing-ubuntu2204 'sleep 2h')
+        docker exec --user root \$container_id bash -c \"sudo bash /home/docker/cassandra-java-driver/ci/create-user.sh docker \$(id -u) \$(id -g) /home/docker/cassandra-java-driver\"
+        docker exec --user docker \$container_id './cassandra-java-driver/ci/run-tests.sh'
+        ( nohup docker stop \$container_id >/dev/null 2>/dev/null & )
+    """
+}
+
+// branch pattern for cron
+// should match 3.x, 4.x, 4.5.x, etc
+def branchPatternCron() {
+    ~'((\\d+(\\.[\\dx]+)+))'
+}
diff --git a/Jenkinsfile b/Jenkinsfile-datastax
similarity index 100%
rename from Jenkinsfile
rename to Jenkinsfile-datastax
diff --git a/ci/create-user.sh b/ci/create-user.sh
new file mode 100644
index 00000000000..fb193df9a00
--- /dev/null
+++ b/ci/create-user.sh
@@ -0,0 +1,60 @@
+#!/bin/bash
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+################################
+#
+# Prep
+#
+################################
+
+if [ "$1" == "-h" ]; then
+   echo "$0 [-h] <username> <uid> <gid>"
+   echo " this script is used internally by other scripts in the same directory to create a user with the running host user's same uid and gid"
+   exit 1
+fi
+
+# arguments
+username=$1
+uid=$2
+gid=$3
+BUILD_HOME=$4
+
+################################
+#
+# Main
+#
+################################
+
+# disable git directory ownership checks
+su ${username} -c "git config --global safe.directory '*'"
+
+if grep "^ID=" /etc/os-release | grep -q 'debian\|ubuntu' ; then
+   deluser docker
+   adduser --quiet --disabled-login --no-create-home --uid $uid --gecos ${username} ${username}
+   groupmod --non-unique -g $gid $username
+   gpasswd -a ${username} sudo >/dev/null
+else
+   adduser --no-create-home --uid $uid ${username}
+fi
+
+# sudo priviledges
+echo "${username} ALL=(root) NOPASSWD:ALL" > /etc/sudoers.d/${username}
+chmod 0440 /etc/sudoers.d/${username}
+
+# proper permissions
+chown -R ${username}:${username} /home/docker
+chmod og+wx ${BUILD_HOME}
\ No newline at end of file
diff --git a/ci/run-tests.sh b/ci/run-tests.sh
new file mode 100755
index 00000000000..02a8070e7a9
--- /dev/null
+++ b/ci/run-tests.sh
@@ -0,0 +1,10 @@
+#!/bin/bash -x
+
+. ~/.jabba/jabba.sh
+. ~/env.txt
+cd $(dirname "$(readlink -f "$0")")/..
+printenv | sort
+mvn -B -V install -DskipTests -Dmaven.javadoc.skip=true
+jabba use ${TEST_JAVA_VERSION}
+printenv | sort
+mvn -B -V verify -T 1 -Ptest-jdk-${TEST_JAVA_MAJOR_VERSION} -DtestJavaHome=$(jabba which ${TEST_JAVA_VERSION}) -Dccm.version=${SERVER_VERSION} -Dccm.dse=false -Dmaven.test.failure.ignore=true -Dmaven.javadoc.skip=true

From 72c729b1ba95695fed467ca3734de7a39a2b3201 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Thu, 3 Oct 2024 09:32:17 +0200
Subject: [PATCH 041/126] CASSANDRA-19932: Allow to define extensions while
 creating table patch by Lukasz Antoniak; reviewed by Bret McGuire and Chris
 Lohfink

---
 .../schema/CreateTableWithOptions.java        | 11 +++++
 .../schema/RawOptionsWrapper.java             | 45 +++++++++++++++++++
 .../querybuilder/schema/CreateTableTest.java  |  9 +++-
 3 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/schema/RawOptionsWrapper.java

diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableWithOptions.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableWithOptions.java
index 4dd3193da15..c7bddf575fb 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableWithOptions.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableWithOptions.java
@@ -18,7 +18,11 @@
 package com.datastax.oss.driver.api.querybuilder.schema;
 
 import com.datastax.oss.driver.api.querybuilder.BuildableQuery;
+import com.datastax.oss.driver.internal.querybuilder.schema.RawOptionsWrapper;
+import com.datastax.oss.driver.shaded.guava.common.collect.Maps;
+import edu.umd.cs.findbugs.annotations.CheckReturnValue;
 import edu.umd.cs.findbugs.annotations.NonNull;
+import java.util.Map;
 
 public interface CreateTableWithOptions
     extends BuildableQuery, RelationStructure<CreateTableWithOptions> {
@@ -26,4 +30,11 @@ public interface CreateTableWithOptions
   /** Enables COMPACT STORAGE in the CREATE TABLE statement. */
   @NonNull
   CreateTableWithOptions withCompactStorage();
+
+  /** Attaches custom metadata to CQL table definition. */
+  @NonNull
+  @CheckReturnValue
+  default CreateTableWithOptions withExtensions(@NonNull Map<String, byte[]> extensions) {
+    return withOption("extensions", Maps.transformValues(extensions, RawOptionsWrapper::of));
+  }
 }
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/schema/RawOptionsWrapper.java b/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/schema/RawOptionsWrapper.java
new file mode 100644
index 00000000000..64cdb50f887
--- /dev/null
+++ b/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/schema/RawOptionsWrapper.java
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.querybuilder.schema;
+
+import com.datastax.oss.driver.api.core.data.ByteUtils;
+
+/**
+ * Wrapper class to indicate that the contained String value should be understood to represent a CQL
+ * literal that can be included directly in a CQL statement (i.e. without escaping).
+ */
+public class RawOptionsWrapper {
+  private final String val;
+
+  private RawOptionsWrapper(String val) {
+    this.val = val;
+  }
+
+  public static RawOptionsWrapper of(String val) {
+    return new RawOptionsWrapper(val);
+  }
+
+  public static RawOptionsWrapper of(byte[] val) {
+    return new RawOptionsWrapper(ByteUtils.toHexString(val));
+  }
+
+  @Override
+  public String toString() {
+    return this.val;
+  }
+}
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
index d32c66f629b..7a5542c51f0 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
@@ -28,6 +28,7 @@
 import com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy.CompactionWindowUnit;
 import com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy.TimestampResolution;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
+import java.nio.charset.StandardCharsets;
 import org.junit.Test;
 
 public class CreateTableTest {
@@ -169,6 +170,12 @@ public void should_generate_create_table_with_options() {
                 .withComment("Hello world")
                 .withDcLocalReadRepairChance(0.54)
                 .withDefaultTimeToLiveSeconds(86400)
+                .withExtensions(
+                    ImmutableMap.of(
+                        "key1",
+                        "apache".getBytes(StandardCharsets.UTF_8),
+                        "key2",
+                        "cassandra".getBytes(StandardCharsets.UTF_8)))
                 .withGcGraceSeconds(864000)
                 .withMemtableFlushPeriodInMs(10000)
                 .withMinIndexInterval(1024)
@@ -176,7 +183,7 @@ public void should_generate_create_table_with_options() {
                 .withReadRepairChance(0.55)
                 .withSpeculativeRetry("99percentile"))
         .hasCql(
-            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH bloom_filter_fp_chance=0.42 AND cdc=false AND comment='Hello world' AND dclocal_read_repair_chance=0.54 AND default_time_to_live=86400 AND gc_grace_seconds=864000 AND memtable_flush_period_in_ms=10000 AND min_index_interval=1024 AND max_index_interval=4096 AND read_repair_chance=0.55 AND speculative_retry='99percentile'");
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH bloom_filter_fp_chance=0.42 AND cdc=false AND comment='Hello world' AND dclocal_read_repair_chance=0.54 AND default_time_to_live=86400 AND extensions={'key1':0x617061636865,'key2':0x63617373616e647261} AND gc_grace_seconds=864000 AND memtable_flush_period_in_ms=10000 AND min_index_interval=1024 AND max_index_interval=4096 AND read_repair_chance=0.55 AND speculative_retry='99percentile'");
   }
 
   @Test

From 8ebcd9f85afb548f38e953fb1190d9ff04d8df5a Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <abe@aber.io>
Date: Tue, 15 Oct 2024 19:24:00 -0400
Subject: [PATCH 042/126] Fix DefaultSslEngineFactory missing null check on
 close

patch by Abe Ratnofsky; reviewed by Andy Tolbert and Chris Lohfink for CASSANDRA-20001
---
 .../oss/driver/internal/core/ssl/DefaultSslEngineFactory.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
index bb95dc738c7..475ec38d578 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
@@ -164,6 +164,6 @@ private ReloadingKeyManagerFactory buildReloadingKeyManagerFactory(DriverExecuti
 
   @Override
   public void close() throws Exception {
-    kmf.close();
+    if (kmf != null) kmf.close();
   }
 }

From f98e3433b91b49e0facfbce8e94e01e304714968 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Wed, 2 Oct 2024 18:04:19 -0500
Subject: [PATCH 043/126] Query builder support for NOT CQL syntax

patch by Bret McGuire; reviewed by Bret McGuire and Andy Tolbert for CASSANDRA-19930
---
 .../relation/ColumnRelationBuilder.java       | 24 +++++++
 .../relation/InRelationBuilder.java           | 32 +++++++++
 .../querybuilder/relation/RelationTest.java   | 69 ++++++++++++++++++-
 3 files changed, 124 insertions(+), 1 deletion(-)

diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/ColumnRelationBuilder.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/ColumnRelationBuilder.java
index 613e72291b7..247d61eaed5 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/ColumnRelationBuilder.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/ColumnRelationBuilder.java
@@ -46,4 +46,28 @@ default ResultT contains(@NonNull Term term) {
   default ResultT containsKey(@NonNull Term term) {
     return build(" CONTAINS KEY ", term);
   }
+
+  /**
+   * Builds a NOT CONTAINS relation for the column.
+   *
+   * <p>Note that NOT CONTAINS support is only available in Cassandra 5.1 or later. See <a
+   * href="https://issues.apache.org/jira/browse/CASSANDRA-18584">CASSANDRA-18584</a> for more
+   * information.
+   */
+  @NonNull
+  default ResultT notContains(@NonNull Term term) {
+    return build(" NOT CONTAINS ", term);
+  }
+
+  /**
+   * Builds a NOT CONTAINS KEY relation for the column.
+   *
+   * <p>Note that NOT CONTAINS KEY support is only available in Cassandra 5.1 or later. See <a
+   * href="https://issues.apache.org/jira/browse/CASSANDRA-18584">CASSANDRA-18584</a> for more
+   * information.
+   */
+  @NonNull
+  default ResultT notContainsKey(@NonNull Term term) {
+    return build(" NOT CONTAINS KEY ", term);
+  }
 }
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/InRelationBuilder.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/InRelationBuilder.java
index d3fc8dce91d..afaa19ff724 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/InRelationBuilder.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/relation/InRelationBuilder.java
@@ -50,6 +50,38 @@ default ResultT in(@NonNull Term... alternatives) {
     return in(Arrays.asList(alternatives));
   }
 
+  /**
+   * Builds a NOT IN relation where the whole set of possible values is a bound variable, as in
+   * {@code NOT IN ?}.
+   *
+   * <p>Note that NOT IN support is only available in Cassandra 5.1 or later. See <a
+   * href="https://issues.apache.org/jira/browse/CASSANDRA-18584">CASSANDRA-18584</a> for more
+   * information.
+   */
+  @NonNull
+  default ResultT notIn(@NonNull BindMarker bindMarker) {
+    return build(" NOT IN ", bindMarker);
+  }
+
+  /**
+   * Builds an IN relation where the arguments are the possible values, as in {@code IN (term1,
+   * term2...)}.
+   *
+   * <p>Note that NOT IN support is only available in Cassandra 5.1 or later. See <a
+   * href="https://issues.apache.org/jira/browse/CASSANDRA-18584">CASSANDRA-18584</a> for more
+   * information.
+   */
+  @NonNull
+  default ResultT notIn(@NonNull Iterable<Term> alternatives) {
+    return build(" NOT IN ", QueryBuilder.tuple(alternatives));
+  }
+
+  /** Var-arg equivalent of {@link #notIn(Iterable)} . */
+  @NonNull
+  default ResultT notIn(@NonNull Term... alternatives) {
+    return notIn(Arrays.asList(alternatives));
+  }
+
   @NonNull
   ResultT build(@NonNull String operator, @Nullable Term rightOperand);
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/relation/RelationTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/relation/RelationTest.java
index 515a336f5f4..ec121eaa050 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/relation/RelationTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/relation/RelationTest.java
@@ -19,10 +19,12 @@
 
 import static com.datastax.oss.driver.api.querybuilder.Assertions.assertThat;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.bindMarker;
+import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.raw;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.selectFrom;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.tuple;
 
+import org.assertj.core.util.Lists;
 import org.junit.Test;
 
 public class RelationTest {
@@ -42,13 +44,78 @@ public void should_generate_is_not_null_relation() {
   }
 
   @Test
-  public void should_generate_in_relation() {
+  public void should_generate_contains_relation() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").contains(literal(1))))
+        .hasCql("SELECT * FROM foo WHERE k CONTAINS 1");
+  }
+
+  @Test
+  public void should_generate_contains_key_relation() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").containsKey(literal(1))))
+        .hasCql("SELECT * FROM foo WHERE k CONTAINS KEY 1");
+  }
+
+  @Test
+  public void should_generate_not_contains_relation() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").notContains(literal(1))))
+        .hasCql("SELECT * FROM foo WHERE k NOT CONTAINS 1");
+  }
+
+  @Test
+  public void should_generate_not_contains_key_relation() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").notContainsKey(literal(1))))
+        .hasCql("SELECT * FROM foo WHERE k NOT CONTAINS KEY 1");
+  }
+
+  @Test
+  public void should_generate_in_relation_bind_markers() {
     assertThat(selectFrom("foo").all().where(Relation.column("k").in(bindMarker())))
         .hasCql("SELECT * FROM foo WHERE k IN ?");
     assertThat(selectFrom("foo").all().where(Relation.column("k").in(bindMarker(), bindMarker())))
         .hasCql("SELECT * FROM foo WHERE k IN (?,?)");
   }
 
+  @Test
+  public void should_generate_in_relation_terms() {
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(
+                    Relation.column("k")
+                        .in(Lists.newArrayList(literal(1), literal(2), literal(3)))))
+        .hasCql("SELECT * FROM foo WHERE k IN (1,2,3)");
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(Relation.column("k").in(literal(1), literal(2), literal(3))))
+        .hasCql("SELECT * FROM foo WHERE k IN (1,2,3)");
+  }
+
+  @Test
+  public void should_generate_not_in_relation_bind_markers() {
+    assertThat(selectFrom("foo").all().where(Relation.column("k").notIn(bindMarker())))
+        .hasCql("SELECT * FROM foo WHERE k NOT IN ?");
+    assertThat(
+            selectFrom("foo").all().where(Relation.column("k").notIn(bindMarker(), bindMarker())))
+        .hasCql("SELECT * FROM foo WHERE k NOT IN (?,?)");
+  }
+
+  @Test
+  public void should_generate_not_in_relation_terms() {
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(
+                    Relation.column("k")
+                        .notIn(Lists.newArrayList(literal(1), literal(2), literal(3)))))
+        .hasCql("SELECT * FROM foo WHERE k NOT IN (1,2,3)");
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(Relation.column("k").notIn(literal(1), literal(2), literal(3))))
+        .hasCql("SELECT * FROM foo WHERE k NOT IN (1,2,3)");
+  }
+
   @Test
   public void should_generate_token_relation() {
     assertThat(selectFrom("foo").all().where(Relation.token("k1", "k2").isEqualTo(bindMarker("t"))))

From dfe11a8b671d76be6c4e90981a736325b0e4719b Mon Sep 17 00:00:00 2001
From: Dmitry Kropachev <dmitry.kropachev@gmail.com>
Date: Sat, 14 Sep 2024 06:43:15 -0400
Subject: [PATCH 044/126] Fix CustomCcmRule to drop `CURRENT` flag no matter
 what

If super.after() throws an Exception `CURRENT` flag is never dropped
which leads next tests to fail with IllegalStateException("Attempting to use a Ccm rule while another is in use.  This is disallowed")

Patch by Dmitry Kropachev; reviewed by Andy Tolbert and Bret McGuire for JAVA-3117
---
 .../oss/driver/api/testinfra/ccm/CustomCcmRule.java       | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CustomCcmRule.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CustomCcmRule.java
index cf150b12f55..5ea1bf7ed3c 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CustomCcmRule.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CustomCcmRule.java
@@ -53,6 +53,7 @@ protected void before() {
           after();
         } catch (Exception e1) {
           LOG.warn("Error cleaning up CustomCcmRule before() failure", e1);
+          e.addSuppressed(e1);
         }
         throw e;
       }
@@ -64,8 +65,11 @@ protected void before() {
 
   @Override
   protected void after() {
-    super.after();
-    CURRENT.compareAndSet(this, null);
+    try {
+      super.after();
+    } finally {
+      CURRENT.compareAndSet(this, null);
+    }
   }
 
   public CcmBridge getCcmBridge() {

From 787783770b0a624f4e58d35aeff16eff8bcddc02 Mon Sep 17 00:00:00 2001
From: janehe <siyaoh4@uci.edu>
Date: Wed, 30 Oct 2024 11:34:11 -0700
Subject: [PATCH 045/126] JAVA-3051: Memory leak

patch by Jane He; reviewed by Alexandre Dutra and Bret McGuire for JAVA-3051
---
 .../core/control/ControlConnection.java       | 21 ++--
 .../DefaultLoadBalancingPolicy.java           | 96 ++++++++++++-------
 .../metadata/LoadBalancingPolicyWrapper.java  | 12 ++-
 .../core/metrics/AbstractMetricUpdater.java   |  5 +-
 .../internal/core/session/DefaultSession.java | 14 ++-
 .../util/concurrent/ReplayingEventFilter.java |  1 +
 ...faultLoadBalancingPolicyQueryPlanTest.java |  9 +-
 ...LoadBalancingPolicyRequestTrackerTest.java | 52 +++++-----
 8 files changed, 126 insertions(+), 84 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/control/ControlConnection.java b/core/src/main/java/com/datastax/oss/driver/internal/core/control/ControlConnection.java
index 5ee9c6e7810..5c29a9b704b 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/control/ControlConnection.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/control/ControlConnection.java
@@ -253,8 +253,8 @@ private class SingleThreaded {
     private final Reconnection reconnection;
     private DriverChannelOptions channelOptions;
     // The last events received for each node
-    private final Map<Node, DistanceEvent> lastDistanceEvents = new WeakHashMap<>();
-    private final Map<Node, NodeStateEvent> lastStateEvents = new WeakHashMap<>();
+    private final Map<Node, NodeDistance> lastNodeDistance = new WeakHashMap<>();
+    private final Map<Node, NodeState> lastNodeState = new WeakHashMap<>();
 
     private SingleThreaded(InternalDriverContext context) {
       this.context = context;
@@ -366,8 +366,8 @@ private void connect(
             .whenCompleteAsync(
                 (channel, error) -> {
                   try {
-                    DistanceEvent lastDistanceEvent = lastDistanceEvents.get(node);
-                    NodeStateEvent lastStateEvent = lastStateEvents.get(node);
+                    NodeDistance lastDistance = lastNodeDistance.get(node);
+                    NodeState lastState = lastNodeState.get(node);
                     if (error != null) {
                       if (closeWasCalled || initFuture.isCancelled()) {
                         onSuccess.run(); // abort, we don't really care about the result
@@ -406,8 +406,7 @@ private void connect(
                           channel);
                       channel.forceClose();
                       onSuccess.run();
-                    } else if (lastDistanceEvent != null
-                        && lastDistanceEvent.distance == NodeDistance.IGNORED) {
+                    } else if (lastDistance == NodeDistance.IGNORED) {
                       LOG.debug(
                           "[{}] New channel opened ({}) but node became ignored, "
                               + "closing and trying next node",
@@ -415,9 +414,9 @@ private void connect(
                           channel);
                       channel.forceClose();
                       connect(nodes, errors, onSuccess, onFailure);
-                    } else if (lastStateEvent != null
-                        && (lastStateEvent.newState == null /*(removed)*/
-                            || lastStateEvent.newState == NodeState.FORCED_DOWN)) {
+                    } else if (lastNodeState.containsKey(node)
+                        && (lastState == null /*(removed)*/
+                            || lastState == NodeState.FORCED_DOWN)) {
                       LOG.debug(
                           "[{}] New channel opened ({}) but node was removed or forced down, "
                               + "closing and trying next node",
@@ -534,7 +533,7 @@ private void reconnectNow() {
 
     private void onDistanceEvent(DistanceEvent event) {
       assert adminExecutor.inEventLoop();
-      this.lastDistanceEvents.put(event.node, event);
+      this.lastNodeDistance.put(event.node, event.distance);
       if (event.distance == NodeDistance.IGNORED
           && channel != null
           && !channel.closeFuture().isDone()
@@ -549,7 +548,7 @@ private void onDistanceEvent(DistanceEvent event) {
 
     private void onStateEvent(NodeStateEvent event) {
       assert adminExecutor.inEventLoop();
-      this.lastStateEvents.put(event.node, event);
+      this.lastNodeState.put(event.node, event.newState);
       if ((event.newState == null /*(removed)*/ || event.newState == NodeState.FORCED_DOWN)
           && channel != null
           && !channel.closeFuture().isDone()
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
index 47edcdfe53e..0f03cbb3643 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
@@ -33,15 +33,19 @@
 import com.datastax.oss.driver.internal.core.util.ArrayUtils;
 import com.datastax.oss.driver.internal.core.util.collection.QueryPlan;
 import com.datastax.oss.driver.internal.core.util.collection.SimpleQueryPlan;
+import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
+import com.datastax.oss.driver.shaded.guava.common.collect.MapMaker;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.util.BitSet;
 import java.util.Map;
 import java.util.Optional;
+import java.util.OptionalLong;
 import java.util.Queue;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.atomic.AtomicLongArray;
 import net.jcip.annotations.ThreadSafe;
@@ -96,7 +100,7 @@ public class DefaultLoadBalancingPolicy extends BasicLoadBalancingPolicy impleme
   private static final int MAX_IN_FLIGHT_THRESHOLD = 10;
   private static final long RESPONSE_COUNT_RESET_INTERVAL_NANOS = MILLISECONDS.toNanos(200);
 
-  protected final Map<Node, AtomicLongArray> responseTimes = new ConcurrentHashMap<>();
+  protected final ConcurrentMap<Node, NodeResponseRateSample> responseTimes;
   protected final Map<Node, Long> upTimes = new ConcurrentHashMap<>();
   private final boolean avoidSlowReplicas;
 
@@ -104,6 +108,7 @@ public DefaultLoadBalancingPolicy(@NonNull DriverContext context, @NonNull Strin
     super(context, profileName);
     this.avoidSlowReplicas =
         profile.getBoolean(DefaultDriverOption.LOAD_BALANCING_POLICY_SLOW_AVOIDANCE, true);
+    this.responseTimes = new MapMaker().weakKeys().makeMap();
   }
 
   @NonNull
@@ -274,40 +279,19 @@ protected boolean isBusy(@NonNull Node node, @NonNull Session session) {
   }
 
   protected boolean isResponseRateInsufficient(@NonNull Node node, long now) {
-    // response rate is considered insufficient when less than 2 responses were obtained in
-    // the past interval delimited by RESPONSE_COUNT_RESET_INTERVAL_NANOS.
-    if (responseTimes.containsKey(node)) {
-      AtomicLongArray array = responseTimes.get(node);
-      if (array.length() == 2) {
-        long threshold = now - RESPONSE_COUNT_RESET_INTERVAL_NANOS;
-        long leastRecent = array.get(0);
-        return leastRecent - threshold < 0;
-      }
-    }
-    return true;
+    NodeResponseRateSample sample = responseTimes.get(node);
+    return !(sample == null || sample.hasSufficientResponses(now));
   }
 
+  /**
+   * Synchronously updates the response times for the given node. It is synchronous because the
+   * {@link #DefaultLoadBalancingPolicy(com.datastax.oss.driver.api.core.context.DriverContext,
+   * java.lang.String) CacheLoader.load} assigned is synchronous.
+   *
+   * @param node The node to update.
+   */
   protected void updateResponseTimes(@NonNull Node node) {
-    responseTimes.compute(
-        node,
-        (n, array) -> {
-          // The array stores at most two timestamps, since we don't need more;
-          // the first one is always the least recent one, and hence the one to inspect.
-          long now = nanoTime();
-          if (array == null) {
-            array = new AtomicLongArray(1);
-            array.set(0, now);
-          } else if (array.length() == 1) {
-            long previous = array.get(0);
-            array = new AtomicLongArray(2);
-            array.set(0, previous);
-            array.set(1, now);
-          } else {
-            array.set(0, array.get(1));
-            array.set(1, now);
-          }
-          return array;
-        });
+    this.responseTimes.compute(node, (k, v) -> v == null ? new NodeResponseRateSample() : v.next());
   }
 
   protected int getInFlight(@NonNull Node node, @NonNull Session session) {
@@ -318,4 +302,52 @@ protected int getInFlight(@NonNull Node node, @NonNull Session session) {
     // processing them).
     return (pool == null) ? 0 : pool.getInFlight();
   }
+
+  protected class NodeResponseRateSample {
+
+    @VisibleForTesting protected final long oldest;
+    @VisibleForTesting protected final OptionalLong newest;
+
+    private NodeResponseRateSample() {
+      long now = nanoTime();
+      this.oldest = now;
+      this.newest = OptionalLong.empty();
+    }
+
+    private NodeResponseRateSample(long oldestSample) {
+      this(oldestSample, nanoTime());
+    }
+
+    private NodeResponseRateSample(long oldestSample, long newestSample) {
+      this.oldest = oldestSample;
+      this.newest = OptionalLong.of(newestSample);
+    }
+
+    @VisibleForTesting
+    protected NodeResponseRateSample(AtomicLongArray times) {
+      assert times.length() >= 1;
+      this.oldest = times.get(0);
+      this.newest = (times.length() > 1) ? OptionalLong.of(times.get(1)) : OptionalLong.empty();
+    }
+
+    // Our newest sample becomes the oldest in the next generation
+    private NodeResponseRateSample next() {
+      return new NodeResponseRateSample(this.getNewestValidSample(), nanoTime());
+    }
+
+    // If we have a pair of values return the newest, otherwise we have just one value... so just
+    // return it
+    private long getNewestValidSample() {
+      return this.newest.orElse(this.oldest);
+    }
+
+    // response rate is considered insufficient when less than 2 responses were obtained in
+    // the past interval delimited by RESPONSE_COUNT_RESET_INTERVAL_NANOS.
+    private boolean hasSufficientResponses(long now) {
+      // If we only have one sample it's an automatic failure
+      if (!this.newest.isPresent()) return true;
+      long threshold = now - RESPONSE_COUNT_RESET_INTERVAL_NANOS;
+      return this.oldest - threshold >= 0;
+    }
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/LoadBalancingPolicyWrapper.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/LoadBalancingPolicyWrapper.java
index 20d045d4e72..5c8473a3b67 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/LoadBalancingPolicyWrapper.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/LoadBalancingPolicyWrapper.java
@@ -38,6 +38,7 @@
 import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
+import java.util.WeakHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.Lock;
@@ -105,7 +106,7 @@ public LoadBalancingPolicyWrapper(
     // Just an alias to make the rest of the code more readable
     this.policies = reporters.keySet();
 
-    this.distances = new HashMap<>();
+    this.distances = new WeakHashMap<>();
 
     this.logPrefix = context.getSessionName();
     context.getEventBus().register(NodeStateEvent.class, this::onNodeStateEvent);
@@ -172,6 +173,7 @@ private void onNodeStateEvent(NodeStateEvent event) {
 
   // once it has gone through the filter
   private void processNodeStateEvent(NodeStateEvent event) {
+    DefaultNode node = event.node;
     switch (stateRef.get()) {
       case BEFORE_INIT:
       case DURING_INIT:
@@ -181,13 +183,13 @@ private void processNodeStateEvent(NodeStateEvent event) {
       case RUNNING:
         for (LoadBalancingPolicy policy : policies) {
           if (event.newState == NodeState.UP) {
-            policy.onUp(event.node);
+            policy.onUp(node);
           } else if (event.newState == NodeState.DOWN || event.newState == NodeState.FORCED_DOWN) {
-            policy.onDown(event.node);
+            policy.onDown(node);
           } else if (event.newState == NodeState.UNKNOWN) {
-            policy.onAdd(event.node);
+            policy.onAdd(node);
           } else if (event.newState == null) {
-            policy.onRemove(event.node);
+            policy.onRemove(node);
           } else {
             LOG.warn("[{}] Unsupported event: {}", logPrefix, event);
           }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/AbstractMetricUpdater.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/AbstractMetricUpdater.java
index 5e2392a2e7f..3d7dc50a7c0 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/AbstractMetricUpdater.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metrics/AbstractMetricUpdater.java
@@ -173,9 +173,8 @@ protected Timeout newTimeout() {
         .getTimer()
         .newTimeout(
             t -> {
-              if (t.isExpired()) {
-                clearMetrics();
-              }
+              clearMetrics();
+              cancelMetricsExpirationTimeout();
             },
             expireAfter.toNanos(),
             TimeUnit.NANOSECONDS);
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java b/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
index 6f063ae9a50..b795c30fce7 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/session/DefaultSession.java
@@ -527,14 +527,18 @@ private void notifyListeners() {
 
     private void onNodeStateChanged(NodeStateEvent event) {
       assert adminExecutor.inEventLoop();
-      if (event.newState == null) {
-        context.getNodeStateListener().onRemove(event.node);
+      DefaultNode node = event.node;
+      if (node == null) {
+        LOG.debug(
+            "[{}] Node for this event was removed, ignoring state change: {}", logPrefix, event);
+      } else if (event.newState == null) {
+        context.getNodeStateListener().onRemove(node);
       } else if (event.oldState == null && event.newState == NodeState.UNKNOWN) {
-        context.getNodeStateListener().onAdd(event.node);
+        context.getNodeStateListener().onAdd(node);
       } else if (event.newState == NodeState.UP) {
-        context.getNodeStateListener().onUp(event.node);
+        context.getNodeStateListener().onUp(node);
       } else if (event.newState == NodeState.DOWN || event.newState == NodeState.FORCED_DOWN) {
-        context.getNodeStateListener().onDown(event.node);
+        context.getNodeStateListener().onDown(node);
       }
     }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/util/concurrent/ReplayingEventFilter.java b/core/src/main/java/com/datastax/oss/driver/internal/core/util/concurrent/ReplayingEventFilter.java
index 12679db7ff0..27ca1b6ff42 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/util/concurrent/ReplayingEventFilter.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/util/concurrent/ReplayingEventFilter.java
@@ -82,6 +82,7 @@ public void markReady() {
         consumer.accept(event);
       }
     } finally {
+      recordedEvents.clear();
       stateLock.writeLock().unlock();
     }
   }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicyQueryPlanTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicyQueryPlanTest.java
index 6098653bc2e..fff86a1b750 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicyQueryPlanTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicyQueryPlanTest.java
@@ -203,7 +203,10 @@ public void should_prioritize_and_shuffle_3_or_more_replicas_when_first_unhealth
     given(pool3.getInFlight()).willReturn(0);
     given(pool5.getInFlight()).willReturn(0);
 
-    dsePolicy.responseTimes.put(node1, new AtomicLongArray(new long[] {T0, T0})); // unhealthy
+    dsePolicy.responseTimes.put(
+        node1,
+        dsePolicy
+        .new NodeResponseRateSample(new AtomicLongArray(new long[] {T0, T0}))); // unhealthy
 
     // When
     Queue<Node> plan1 = dsePolicy.newQueryPlan(request, session);
@@ -232,7 +235,9 @@ public void should_prioritize_and_shuffle_3_or_more_replicas_when_first_unhealth
     given(pool3.getInFlight()).willReturn(0);
     given(pool5.getInFlight()).willReturn(0);
 
-    dsePolicy.responseTimes.put(node1, new AtomicLongArray(new long[] {T1, T1})); // healthy
+    dsePolicy.responseTimes.put(
+        node1,
+        dsePolicy.new NodeResponseRateSample(new AtomicLongArray(new long[] {T1, T1}))); // healthy
 
     // When
     Queue<Node> plan1 = dsePolicy.newQueryPlan(request, session);
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicyRequestTrackerTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicyRequestTrackerTest.java
index bcc6439a2a5..757af43ef67 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicyRequestTrackerTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicyRequestTrackerTest.java
@@ -69,11 +69,11 @@ public void should_record_first_response_time_on_node_success() {
 
     // Then
     assertThat(policy.responseTimes)
-        .hasEntrySatisfying(node1, value -> assertThat(value.get(0)).isEqualTo(123L))
+        .hasEntrySatisfying(node1, value -> assertThat(value.oldest).isEqualTo(123L))
         .doesNotContainKeys(node2, node3);
-    assertThat(policy.isResponseRateInsufficient(node1, nextNanoTime)).isTrue();
-    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isTrue();
-    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isTrue();
+    assertThat(policy.isResponseRateInsufficient(node1, nextNanoTime)).isFalse();
+    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isFalse();
+    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isFalse();
   }
 
   @Test
@@ -91,13 +91,13 @@ public void should_record_second_response_time_on_node_success() {
             node1,
             value -> {
               // oldest value first
-              assertThat(value.get(0)).isEqualTo(123);
-              assertThat(value.get(1)).isEqualTo(456);
+              assertThat(value.oldest).isEqualTo(123);
+              assertThat(value.newest.getAsLong()).isEqualTo(456);
             })
         .doesNotContainKeys(node2, node3);
     assertThat(policy.isResponseRateInsufficient(node1, nextNanoTime)).isFalse();
-    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isTrue();
-    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isTrue();
+    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isFalse();
+    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isFalse();
   }
 
   @Test
@@ -116,14 +116,14 @@ public void should_record_further_response_times_on_node_success() {
             node1,
             value -> {
               // values should rotate left (bubble up)
-              assertThat(value.get(0)).isEqualTo(456);
-              assertThat(value.get(1)).isEqualTo(789);
+              assertThat(value.oldest).isEqualTo(456);
+              assertThat(value.newest.getAsLong()).isEqualTo(789);
             })
-        .hasEntrySatisfying(node2, value -> assertThat(value.get(0)).isEqualTo(789))
+        .hasEntrySatisfying(node2, value -> assertThat(value.oldest).isEqualTo(789))
         .doesNotContainKey(node3);
     assertThat(policy.isResponseRateInsufficient(node1, nextNanoTime)).isFalse();
-    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isTrue();
-    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isTrue();
+    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isFalse();
+    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isFalse();
   }
 
   @Test
@@ -137,11 +137,11 @@ public void should_record_first_response_time_on_node_error() {
 
     // Then
     assertThat(policy.responseTimes)
-        .hasEntrySatisfying(node1, value -> assertThat(value.get(0)).isEqualTo(123L))
+        .hasEntrySatisfying(node1, value -> assertThat(value.oldest).isEqualTo(123L))
         .doesNotContainKeys(node2, node3);
-    assertThat(policy.isResponseRateInsufficient(node1, nextNanoTime)).isTrue();
-    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isTrue();
-    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isTrue();
+    assertThat(policy.isResponseRateInsufficient(node1, nextNanoTime)).isFalse();
+    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isFalse();
+    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isFalse();
   }
 
   @Test
@@ -160,13 +160,13 @@ public void should_record_second_response_time_on_node_error() {
             node1,
             value -> {
               // oldest value first
-              assertThat(value.get(0)).isEqualTo(123);
-              assertThat(value.get(1)).isEqualTo(456);
+              assertThat(value.oldest).isEqualTo(123);
+              assertThat(value.newest.getAsLong()).isEqualTo(456);
             })
         .doesNotContainKeys(node2, node3);
     assertThat(policy.isResponseRateInsufficient(node1, nextNanoTime)).isFalse();
-    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isTrue();
-    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isTrue();
+    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isFalse();
+    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isFalse();
   }
 
   @Test
@@ -186,13 +186,13 @@ public void should_record_further_response_times_on_node_error() {
             node1,
             value -> {
               // values should rotate left (bubble up)
-              assertThat(value.get(0)).isEqualTo(456);
-              assertThat(value.get(1)).isEqualTo(789);
+              assertThat(value.oldest).isEqualTo(456);
+              assertThat(value.newest.getAsLong()).isEqualTo(789);
             })
-        .hasEntrySatisfying(node2, value -> assertThat(value.get(0)).isEqualTo(789))
+        .hasEntrySatisfying(node2, value -> assertThat(value.oldest).isEqualTo(789))
         .doesNotContainKey(node3);
     assertThat(policy.isResponseRateInsufficient(node1, nextNanoTime)).isFalse();
-    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isTrue();
-    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isTrue();
+    assertThat(policy.isResponseRateInsufficient(node2, nextNanoTime)).isFalse();
+    assertThat(policy.isResponseRateInsufficient(node3, nextNanoTime)).isFalse();
   }
 }

From a4175f33e43344fd1b092aae332ed5979a1bd831 Mon Sep 17 00:00:00 2001
From: "Siyao (Jane) He" <jane.he@datastax.com>
Date: Mon, 28 Oct 2024 14:44:22 -0700
Subject: [PATCH 046/126] Automate latest Cassandra versions when running CI

 patch by Siyao (Jane) He; reviewed by Mick Semb Wever for CASSJAVA-25
---
 Jenkinsfile-asf | 7 ++++---
 ci/run-tests.sh | 4 +++-
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/Jenkinsfile-asf b/Jenkinsfile-asf
index a1be4bcd4f6..0217d0455d6 100644
--- a/Jenkinsfile-asf
+++ b/Jenkinsfile-asf
@@ -39,9 +39,10 @@ pipeline {
                     }
                     axis {
                         name 'SERVER_VERSION'
-                        values  '3.11.17',
-                                '4.0.13',
-                                '5.0-beta1'
+                        values  '3.11',
+                                '4.0',
+                                '4.1',
+                                '5.0'
                     }
                 }
                 stages {
diff --git a/ci/run-tests.sh b/ci/run-tests.sh
index 02a8070e7a9..5268bdd7113 100755
--- a/ci/run-tests.sh
+++ b/ci/run-tests.sh
@@ -6,5 +6,7 @@ cd $(dirname "$(readlink -f "$0")")/..
 printenv | sort
 mvn -B -V install -DskipTests -Dmaven.javadoc.skip=true
 jabba use ${TEST_JAVA_VERSION}
+# Find out the latest patch version of Cassandra
+PATCH_SERVER_VERSION=$(curl -s https://downloads.apache.org/cassandra/ | grep -oP '(?<=href=\")[0-9]+\.[0-9]+\.[0-9]+(?=)' | sort -rV | uniq -w 3 | grep $SERVER_VERSION)
 printenv | sort
-mvn -B -V verify -T 1 -Ptest-jdk-${TEST_JAVA_MAJOR_VERSION} -DtestJavaHome=$(jabba which ${TEST_JAVA_VERSION}) -Dccm.version=${SERVER_VERSION} -Dccm.dse=false -Dmaven.test.failure.ignore=true -Dmaven.javadoc.skip=true
+mvn -B -V verify -T 1 -Ptest-jdk-${TEST_JAVA_MAJOR_VERSION} -DtestJavaHome=$(jabba which ${TEST_JAVA_VERSION}) -Dccm.version=${PATCH_SERVER_VERSION} -Dccm.dse=false -Dmaven.test.failure.ignore=true -Dmaven.javadoc.skip=true

From 01c6151cd4a3c1dbbd4d1251fb453305385668e1 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Sun, 8 Sep 2024 15:06:53 +0200
Subject: [PATCH 047/126] Refactor integration tests to support multiple C*
 distributions. Test with DataStax HCD 1.0.0

patch by Lukasz Antoniak; reviewed by Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1958
---
 Jenkinsfile-datastax                          |  34 +++-
 .../datastax/oss/driver/api/core/Version.java |   1 +
 .../cql/continuous/ContinuousPagingIT.java    |   8 +-
 .../remote/GraphTraversalRemoteITBase.java    |   5 +-
 .../graph/statement/GraphTraversalITBase.java |   5 +-
 .../schema/DseAggregateMetadataIT.java        |   6 +-
 .../schema/DseFunctionMetadataIT.java         |   6 +-
 .../core/compression/DirectCompressionIT.java |   6 +-
 .../core/compression/HeapCompressionIT.java   |   3 +-
 .../oss/driver/core/cql/QueryTraceIT.java     |   3 +-
 .../oss/driver/core/metadata/DescribeIT.java  |  28 +--
 .../driver/core/metadata/NodeMetadataIT.java  |   7 +-
 .../driver/core/metadata/SchemaChangesIT.java |   5 +-
 .../oss/driver/core/metadata/SchemaIT.java    |   8 +-
 .../oss/driver/mapper/DeleteReactiveIT.java   |   5 +-
 .../oss/driver/mapper/InventoryITBase.java    |  11 +-
 .../src/test/resources/DescribeIT/hcd/1.0.cql | 186 ++++++++++++++++++
 osgi-tests/README.md                          |   4 +-
 .../osgi/support/CcmStagedReactor.java        |   8 +-
 test-infra/revapi.json                        |  21 ++
 .../driver/api/testinfra/ccm/BaseCcmRule.java |  24 ++-
 .../driver/api/testinfra/ccm/CcmBridge.java   |  83 ++++----
 .../DefaultCcmBridgeBuilderCustomizer.java    |   8 +-
 .../ccm/DistributionCassandraVersions.java    |  57 ++++++
 .../requirement/BackendRequirementRule.java   |   2 +-
 .../testinfra/requirement/BackendType.java    |  13 +-
 .../api/testinfra/session/SessionRule.java    |  13 +-
 27 files changed, 439 insertions(+), 121 deletions(-)
 create mode 100644 integration-tests/src/test/resources/DescribeIT/hcd/1.0.cql
 create mode 100644 test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/DistributionCassandraVersions.java

diff --git a/Jenkinsfile-datastax b/Jenkinsfile-datastax
index 4cc20d79604..af3faafee20 100644
--- a/Jenkinsfile-datastax
+++ b/Jenkinsfile-datastax
@@ -61,7 +61,7 @@ def initializeEnvironment() {
     . ${JABBA_SHELL}
     jabba which 1.8''', returnStdout: true).trim()
 
-  sh label: 'Download Apache CassandraⓇ or DataStax Enterprise',script: '''#!/bin/bash -le
+  sh label: 'Download Apache CassandraⓇ, DataStax Enterprise or DataStax HCD ',script: '''#!/bin/bash -le
     . ${JABBA_SHELL}
     jabba use 1.8
     . ${CCM_ENVIRONMENT_SHELL} ${SERVER_VERSION}
@@ -75,13 +75,26 @@ CCM_CASSANDRA_VERSION=${DSE_FIXED_VERSION} # maintain for backwards compatibilit
 CCM_VERSION=${DSE_FIXED_VERSION}
 CCM_SERVER_TYPE=dse
 DSE_VERSION=${DSE_FIXED_VERSION}
-CCM_IS_DSE=true
 CCM_BRANCH=${DSE_FIXED_VERSION}
 DSE_BRANCH=${DSE_FIXED_VERSION}
 ENVIRONMENT_EOF
       '''
   }
 
+  if (env.SERVER_VERSION.split('-')[0] == 'hcd') {
+    env.HCD_FIXED_VERSION = env.SERVER_VERSION.split('-')[1]
+    sh label: 'Update environment for DataStax HCD', script: '''#!/bin/bash -le
+        cat >> ${HOME}/environment.txt << ENVIRONMENT_EOF
+CCM_CASSANDRA_VERSION=${HCD_FIXED_VERSION} # maintain for backwards compatibility
+CCM_VERSION=${HCD_FIXED_VERSION}
+CCM_SERVER_TYPE=hcd
+HCD_VERSION=${HCD_FIXED_VERSION}
+CCM_BRANCH=${HCD_FIXED_VERSION}
+HCD_BRANCH=${HCD_FIXED_VERSION}
+ENVIRONMENT_EOF
+      '''
+  }
+
   sh label: 'Display Java and environment information',script: '''#!/bin/bash -le
     # Load CCM environment variables
     set -o allexport
@@ -144,7 +157,7 @@ def executeTests() {
       -Dmaven.test.failure.ignore=true \
       -Dmaven.javadoc.skip=${SKIP_JAVADOCS} \
       -Dccm.version=${CCM_CASSANDRA_VERSION} \
-      -Dccm.dse=${CCM_IS_DSE} \
+      -Dccm.distribution=${CCM_SERVER_TYPE:cassandra} \
       -Dproxy.path=${HOME}/proxy \
       ${SERIAL_ITS_ARGUMENT} \
       ${ISOLATED_ITS_ARGUMENT} \
@@ -269,6 +282,7 @@ pipeline {
                 'dse-6.7.17',   // Previous DataStax Enterprise
                 'dse-6.8.30',   // Current DataStax Enterprise
                 'dse-6.9.0',    // Current DataStax Enterprise
+                'hcd-1.0.0',    // Current DataStax HCD
                 'ALL'],
       description: '''Apache Cassandra&reg; and DataStax Enterprise server version to use for adhoc <b>BUILD-AND-EXECUTE-TESTS</b> builds
                       <table style="width:100%">
@@ -330,6 +344,10 @@ pipeline {
                           <td><strong>dse-6.9.0</strong></td>
                           <td>DataStax Enterprise v6.9.x</td>
                         </tr>
+                        <tr>
+                          <td><strong>hcd-1.0.0</strong></td>
+                          <td>DataStax HCD v1.0.x</td>
+                        </tr>
                       </table>''')
     choice(
       name: 'ADHOC_BUILD_AND_EXECUTE_TESTS_JABBA_VERSION',
@@ -421,9 +439,9 @@ pipeline {
       H 2 * * 0 %CI_SCHEDULE=WEEKENDS;CI_SCHEDULE_SERVER_VERSIONS=2.1 3.0 4.0 dse-4.8.16 dse-5.0.15 dse-5.1.35 dse-6.0.18 dse-6.7.17;CI_SCHEDULE_JABBA_VERSION=1.8
       # Every weeknight (Monday - Friday) around 12:00 PM noon
       ### JDK11 tests against 3.11, 4.1, 5.0-beta1 and DSE 6.8
-      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30 dse-6.9.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.11
+      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30 dse-6.9.0 hcd-1.0.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.11
       ### JDK17 tests against 3.11, 4.1, 5.0-beta1 and DSE 6.8
-      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30 dse-6.9.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.17
+      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30 dse-6.9.0 hcd-1.0.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.17
     """ : "")
   }
 
@@ -460,7 +478,8 @@ pipeline {
             values '3.11',       // Latest stable Apache CassandraⓇ
                    '4.1',        // Development Apache CassandraⓇ
                    'dse-6.8.30', // Current DataStax Enterprise
-                   'dse-6.9.0'   // Current DataStax Enterprise
+                   'dse-6.9.0',  // Current DataStax Enterprise
+                   'hcd-1.0.0'   // Current DataStax HCD
           }
           axis {
             name 'JABBA_VERSION'
@@ -578,7 +597,8 @@ pipeline {
                    'dse-6.0.18',   // Previous DataStax Enterprise
                    'dse-6.7.17',   // Previous DataStax Enterprise
                    'dse-6.8.30',   // Current DataStax Enterprise
-                   'dse-6.9.0'     // Current DataStax Enterprise
+                   'dse-6.9.0',    // Current DataStax Enterprise
+                   'hcd-1.0.0'     // Current DataStax HCD
           }
         }
         when {
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/Version.java b/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
index 4de006da268..52751e02984 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/Version.java
@@ -48,6 +48,7 @@ public class Version implements Comparable<Version>, Serializable {
 
   private static final Pattern pattern = Pattern.compile(VERSION_REGEXP);
 
+  @NonNull public static final Version V1_0_0 = Objects.requireNonNull(parse("1.0.0"));
   @NonNull public static final Version V2_1_0 = Objects.requireNonNull(parse("2.1.0"));
   @NonNull public static final Version V2_2_0 = Objects.requireNonNull(parse("2.2.0"));
   @NonNull public static final Version V3_0_0 = Objects.requireNonNull(parse("3.0.0"));
diff --git a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/cql/continuous/ContinuousPagingIT.java b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/cql/continuous/ContinuousPagingIT.java
index 24ee5c0373d..45cc84f0719 100644
--- a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/cql/continuous/ContinuousPagingIT.java
+++ b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/cql/continuous/ContinuousPagingIT.java
@@ -46,7 +46,6 @@
 import java.time.Duration;
 import java.util.Collections;
 import java.util.Iterator;
-import java.util.Objects;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -281,11 +280,8 @@ public void prepared_statement_paging_should_be_resilient_to_schema_change() {
       // dropped.
       Row row = it.next();
       assertThat(row.getString("k")).isNotNull();
-      if (ccmRule
-              .getDseVersion()
-              .orElseThrow(IllegalStateException::new)
-              .compareTo(Objects.requireNonNull(Version.parse("6.0.0")))
-          >= 0) {
+      if (ccmRule.isDistributionOf(
+          BackendType.DSE, (dist, cass) -> dist.compareTo(Version.parse("6.0.0")) >= 0)) {
         // DSE 6 only, v should be null here since dropped.
         // Not reliable for 5.1 since we may have gotten page queued before schema changed.
         assertThat(row.isNull("v")).isTrue();
diff --git a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/graph/remote/GraphTraversalRemoteITBase.java b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/graph/remote/GraphTraversalRemoteITBase.java
index 69949951378..3db8a7d1a12 100644
--- a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/graph/remote/GraphTraversalRemoteITBase.java
+++ b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/graph/remote/GraphTraversalRemoteITBase.java
@@ -30,6 +30,7 @@
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.Version;
 import com.datastax.oss.driver.api.core.servererrors.InvalidQueryException;
+import com.datastax.oss.driver.api.testinfra.ccm.CcmBridge;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
@@ -643,9 +644,9 @@ public void should_allow_use_of_dsl_graph_binary() {
    */
   @Test
   public void should_return_correct_results_when_bulked() {
-    Optional<Version> dseVersion = ccmRule().getCcmBridge().getDseVersion();
     Assumptions.assumeThat(
-            dseVersion.isPresent() && dseVersion.get().compareTo(Version.parse("5.1.2")) > 0)
+            CcmBridge.isDistributionOf(
+                BackendType.DSE, (dist, cass) -> dist.compareTo(Version.parse("5.1.2")) > 0))
         .isTrue();
 
     List<String> results = graphTraversalSource().E().label().barrier().toList();
diff --git a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/graph/statement/GraphTraversalITBase.java b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/graph/statement/GraphTraversalITBase.java
index 98d9ccf1b80..5bcb01bc165 100644
--- a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/graph/statement/GraphTraversalITBase.java
+++ b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/graph/statement/GraphTraversalITBase.java
@@ -36,7 +36,9 @@
 import com.datastax.oss.driver.api.core.Version;
 import com.datastax.oss.driver.api.core.servererrors.InvalidQueryException;
 import com.datastax.oss.driver.api.core.type.reflect.GenericType;
+import com.datastax.oss.driver.api.testinfra.ccm.CcmBridge;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
 import com.datastax.oss.driver.shaded.guava.common.collect.Lists;
 import java.util.List;
@@ -598,7 +600,8 @@ public void should_allow_use_of_dsl_graph_binary() throws Exception {
   @Test
   public void should_return_correct_results_when_bulked() {
     Assumptions.assumeThat(
-            ccmRule().getCcmBridge().getDseVersion().get().compareTo(Version.parse("5.1.2")) > 0)
+            CcmBridge.isDistributionOf(
+                BackendType.DSE, (dist, cass) -> dist.compareTo(Version.parse("5.1.2")) > 0))
         .isTrue();
 
     GraphResultSet rs =
diff --git a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/metadata/schema/DseAggregateMetadataIT.java b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/metadata/schema/DseAggregateMetadataIT.java
index b0e989e86a3..4c899fa5e63 100644
--- a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/metadata/schema/DseAggregateMetadataIT.java
+++ b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/metadata/schema/DseAggregateMetadataIT.java
@@ -106,9 +106,9 @@ public void should_parse_aggregate_with_deterministic() {
   }
 
   private static boolean isDse6OrHigher() {
-    assumeThat(CCM_RULE.getDseVersion())
+    assumeThat(CCM_RULE.isDistributionOf(BackendType.DSE))
         .describedAs("DSE required for DseFunctionMetadata tests")
-        .isPresent();
-    return CCM_RULE.getDseVersion().get().compareTo(DSE_6_0_0) >= 0;
+        .isTrue();
+    return CCM_RULE.getDistributionVersion().compareTo(DSE_6_0_0) >= 0;
   }
 }
diff --git a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/metadata/schema/DseFunctionMetadataIT.java b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/metadata/schema/DseFunctionMetadataIT.java
index 53e2d1be8f8..53559a66b1b 100644
--- a/integration-tests/src/test/java/com/datastax/dse/driver/api/core/metadata/schema/DseFunctionMetadataIT.java
+++ b/integration-tests/src/test/java/com/datastax/dse/driver/api/core/metadata/schema/DseFunctionMetadataIT.java
@@ -233,9 +233,9 @@ public void should_parse_function_with_deterministic_and_monotonic_on() {
   }
 
   private static boolean isDse6OrHigher() {
-    assumeThat(CCM_RULE.getDseVersion())
+    assumeThat(CCM_RULE.isDistributionOf(BackendType.DSE))
         .describedAs("DSE required for DseFunctionMetadata tests")
-        .isPresent();
-    return CCM_RULE.getDseVersion().get().compareTo(DSE_6_0_0) >= 0;
+        .isTrue();
+    return CCM_RULE.getDistributionVersion().compareTo(DSE_6_0_0) >= 0;
   }
 }
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/compression/DirectCompressionIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/compression/DirectCompressionIT.java
index 51f71f85b5c..3dad08f4de6 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/compression/DirectCompressionIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/compression/DirectCompressionIT.java
@@ -29,6 +29,7 @@
 import com.datastax.oss.driver.api.core.cql.Row;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.ParallelizableTests;
@@ -75,8 +76,9 @@ public static void setup() {
   public void should_execute_queries_with_snappy_compression() throws Exception {
     Assume.assumeTrue(
         "Snappy is not supported in OSS C* 4.0+ with protocol v5",
-        CCM_RULE.getDseVersion().isPresent()
-            || CCM_RULE.getCassandraVersion().nextStable().compareTo(Version.V4_0_0) < 0);
+        !CCM_RULE.isDistributionOf(BackendType.HCD)
+            && (CCM_RULE.isDistributionOf(BackendType.DSE)
+                || CCM_RULE.getCassandraVersion().nextStable().compareTo(Version.V4_0_0) < 0));
     createAndCheckCluster("snappy");
   }
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/compression/HeapCompressionIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/compression/HeapCompressionIT.java
index 466a9d87ac3..a14c3b29b21 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/compression/HeapCompressionIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/compression/HeapCompressionIT.java
@@ -29,6 +29,7 @@
 import com.datastax.oss.driver.api.core.cql.Row;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.IsolatedTests;
@@ -79,7 +80,7 @@ public static void setup() {
   public void should_execute_queries_with_snappy_compression() throws Exception {
     Assume.assumeTrue(
         "Snappy is not supported in OSS C* 4.0+ with protocol v5",
-        CCM_RULE.getDseVersion().isPresent()
+        CCM_RULE.isDistributionOf(BackendType.DSE)
             || CCM_RULE.getCassandraVersion().nextStable().compareTo(Version.V4_0_0) < 0);
     createAndCheckCluster("snappy");
   }
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/QueryTraceIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/QueryTraceIT.java
index f4ac85d6629..37a600efbc4 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/QueryTraceIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/QueryTraceIT.java
@@ -28,6 +28,7 @@
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.metadata.EndPoint;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.categories.ParallelizableTests;
 import java.net.InetAddress;
@@ -82,7 +83,7 @@ public void should_fetch_trace_when_tracing_enabled() {
     InetAddress nodeAddress = ((InetSocketAddress) contactPoint.resolve()).getAddress();
     boolean expectPorts =
         CCM_RULE.getCassandraVersion().nextStable().compareTo(Version.V4_0_0) >= 0
-            && !CCM_RULE.getDseVersion().isPresent();
+            && !CCM_RULE.isDistributionOf(BackendType.DSE);
 
     QueryTrace queryTrace = executionInfo.getQueryTrace();
     assertThat(queryTrace.getTracingId()).isEqualTo(executionInfo.getTracingId());
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/DescribeIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/DescribeIT.java
index 9fbf5e355eb..4d6c2a7a3b1 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/DescribeIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/DescribeIT.java
@@ -29,6 +29,7 @@
 import com.datastax.oss.driver.api.core.metadata.schema.TableMetadata;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
 import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.ParallelizableTests;
@@ -37,12 +38,14 @@
 import com.datastax.oss.driver.internal.core.metadata.schema.DefaultTableMetadata;
 import com.datastax.oss.driver.shaded.guava.common.base.Charsets;
 import com.datastax.oss.driver.shaded.guava.common.base.Splitter;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import com.google.common.io.Files;
 import java.io.File;
 import java.io.IOException;
 import java.net.URL;
 import java.time.Duration;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.regex.Pattern;
 import org.junit.BeforeClass;
@@ -79,17 +82,23 @@ public class DescribeIT {
       Splitter.on(Pattern.compile(";\n")).omitEmptyStrings();
 
   private static Version serverVersion;
-  private static boolean isDse;
+
+  private static final Map<BackendType, String> scriptFileForBackend =
+      ImmutableMap.<BackendType, String>builder()
+          .put(BackendType.CASSANDRA, "DescribeIT/oss")
+          .put(BackendType.DSE, "DescribeIT/dse")
+          .put(BackendType.HCD, "DescribeIT/hcd")
+          .build();
 
   private static File scriptFile;
   private static String scriptContents;
 
   @BeforeClass
   public static void setup() {
-    Optional<Version> dseVersion = CCM_RULE.getDseVersion();
-    isDse = dseVersion.isPresent();
     serverVersion =
-        isDse ? dseVersion.get().nextStable() : CCM_RULE.getCassandraVersion().nextStable();
+        CCM_RULE.isDistributionOf(BackendType.CASSANDRA)
+            ? CCM_RULE.getCassandraVersion().nextStable()
+            : CCM_RULE.getDistributionVersion().nextStable();
 
     scriptFile = getScriptFile();
     assertThat(scriptFile).exists();
@@ -114,12 +123,12 @@ public void describe_output_should_match_creation_script() throws Exception {
             "Describe output doesn't match create statements, "
                 + "maybe you need to add a new script in integration-tests/src/test/resources. "
                 + "Server version = %s %s, used script = %s",
-            isDse ? "DSE" : "Cassandra", serverVersion, scriptFile)
+            CCM_RULE.getDistribution(), serverVersion, scriptFile)
         .isEqualTo(scriptContents);
   }
 
   private boolean atLeastVersion(Version dseVersion, Version ossVersion) {
-    Version comparison = isDse ? dseVersion : ossVersion;
+    Version comparison = CCM_RULE.isDistributionOf(BackendType.DSE) ? dseVersion : ossVersion;
     return serverVersion.compareTo(comparison) >= 0;
   }
 
@@ -138,11 +147,9 @@ public void keyspace_metadata_should_be_serializable() throws Exception {
     assertThat(ks.getUserDefinedTypes()).isNotEmpty();
     assertThat(ks.getTables()).isNotEmpty();
     if (atLeastVersion(Version.V5_0_0, Version.V3_0_0)) {
-
       assertThat(ks.getViews()).isNotEmpty();
     }
     if (atLeastVersion(Version.V5_0_0, Version.V2_2_0)) {
-
       assertThat(ks.getFunctions()).isNotEmpty();
       assertThat(ks.getAggregates()).isNotEmpty();
     }
@@ -177,7 +184,7 @@ private static File getScriptFile() {
           logbackTestUrl);
     }
     File resourcesDir = new File(logbackTestUrl.getFile()).getParentFile();
-    File scriptsDir = new File(resourcesDir, isDse ? "DescribeIT/dse" : "DescribeIT/oss");
+    File scriptsDir = new File(resourcesDir, scriptFileForBackend.get(CCM_RULE.getDistribution()));
     LOG.debug("Looking for a matching script in directory {}", scriptsDir);
 
     File[] candidates = scriptsDir.listFiles();
@@ -204,8 +211,7 @@ private static File getScriptFile() {
         .as("Could not find create script with version <= %s in %s", serverVersion, scriptsDir)
         .isNotNull();
 
-    LOG.info(
-        "Using {} to test against {} {}", bestFile, isDse ? "DSE" : "Cassandra", serverVersion);
+    LOG.info("Using {} to test against {} {}", bestFile, CCM_RULE.getDistribution(), serverVersion);
     return bestFile;
   }
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/NodeMetadataIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/NodeMetadataIT.java
index c7b51c040b5..8f5680ff41a 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/NodeMetadataIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/NodeMetadataIT.java
@@ -62,8 +62,9 @@ public void should_expose_node_metadata() {
       assertThat(node.getListenAddress().get().getAddress()).isEqualTo(connectAddress.getAddress());
       assertThat(node.getDatacenter()).isEqualTo("dc1");
       assertThat(node.getRack()).isEqualTo("r1");
-      if (!CcmBridge.DSE_ENABLEMENT) {
-        // CcmBridge does not report accurate C* versions for DSE, only approximated values
+      if (CcmBridge.isDistributionOf(BackendType.CASSANDRA)) {
+        // CcmBridge does not report accurate C* versions for other distributions (e.g. DSE), only
+        // approximated values
         assertThat(node.getCassandraVersion()).isEqualTo(ccmRule.getCassandraVersion());
       }
       assertThat(node.getState()).isSameAs(NodeState.UP);
@@ -106,7 +107,7 @@ public void should_expose_dse_node_properties() {
               DseNodeProperties.DSE_WORKLOADS,
               DseNodeProperties.SERVER_ID);
       assertThat(node.getExtras().get(DseNodeProperties.DSE_VERSION))
-          .isEqualTo(ccmRule.getDseVersion().get());
+          .isEqualTo(ccmRule.getDistributionVersion());
       assertThat(node.getExtras().get(DseNodeProperties.SERVER_ID)).isInstanceOf(String.class);
       assertThat(node.getExtras().get(DseNodeProperties.DSE_WORKLOADS)).isInstanceOf(Set.class);
     }
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaChangesIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaChangesIT.java
index 6f1dcb791c6..85fcfc02cdb 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaChangesIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaChangesIT.java
@@ -33,6 +33,7 @@
 import com.datastax.oss.driver.api.core.type.DataTypes;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmBridge;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.google.common.collect.ImmutableList;
@@ -54,8 +55,8 @@ public class SchemaChangesIT {
 
   static {
     CustomCcmRule.Builder builder = CustomCcmRule.builder();
-    if (!CcmBridge.DSE_ENABLEMENT
-        && CcmBridge.VERSION.nextStable().compareTo(Version.V4_0_0) >= 0) {
+    if (!CcmBridge.isDistributionOf(
+        BackendType.DSE, (dist, cass) -> cass.nextStable().compareTo(Version.V4_0_0) >= 0)) {
       builder.withCassandraConfiguration("enable_materialized_views", true);
     }
     CCM_RULE = builder.build();
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
index 805b2d970cc..df5571974c1 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
@@ -335,11 +335,9 @@ public void should_exclude_virtual_keyspaces_from_token_map() {
 
   private void skipIfDse60() {
     // Special case: DSE 6.0 reports C* 4.0 but does not support virtual tables
-    if (ccmRule.getDseVersion().isPresent()) {
-      Version dseVersion = ccmRule.getDseVersion().get();
-      if (dseVersion.compareTo(DSE_MIN_VIRTUAL_TABLES) < 0) {
-        throw new AssumptionViolatedException("DSE 6.0 does not support virtual tables");
-      }
+    if (!ccmRule.isDistributionOf(
+        BackendType.DSE, (dist, cass) -> dist.compareTo(DSE_MIN_VIRTUAL_TABLES) >= 0)) {
+      throw new AssumptionViolatedException("DSE 6.0 does not support virtual tables");
     }
   }
 }
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteReactiveIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteReactiveIT.java
index 3a418c73653..2eb898021ba 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteReactiveIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/DeleteReactiveIT.java
@@ -37,6 +37,7 @@
 import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmBridge;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import io.reactivex.Flowable;
 import java.util.UUID;
@@ -57,8 +58,8 @@ public class DeleteReactiveIT extends InventoryITBase {
   @ClassRule public static TestRule chain = RuleChain.outerRule(ccmRule).around(sessionRule);
 
   private static CustomCcmRule.Builder configureCcm(CustomCcmRule.Builder builder) {
-    if (!CcmBridge.DSE_ENABLEMENT
-        && CcmBridge.VERSION.nextStable().compareTo(Version.V4_0_0) >= 0) {
+    if (!CcmBridge.isDistributionOf(
+        BackendType.DSE, (dist, cass) -> cass.nextStable().compareTo(Version.V4_0_0) >= 0)) {
       builder.withCassandraConfiguration("enable_sasi_indexes", true);
     }
     return builder;
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
index 9495003ae49..1bd899e4541 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/mapper/InventoryITBase.java
@@ -23,10 +23,10 @@
 import com.datastax.oss.driver.api.mapper.annotations.Entity;
 import com.datastax.oss.driver.api.mapper.annotations.PartitionKey;
 import com.datastax.oss.driver.api.testinfra.ccm.BaseCcmRule;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
 import java.util.List;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.UUID;
 
 /** Factors common code for mapper tests that rely on a simple inventory model. */
@@ -93,13 +93,14 @@ protected static List<String> createStatements(BaseCcmRule ccmRule, boolean requ
     return builder.build();
   }
 
-  private static final Version MINIMUM_SASI_VERSION = Version.parse("3.4.0");
-  private static final Version BROKEN_SASI_VERSION = Version.parse("6.8.0");
+  private static final Version MINIMUM_SASI_VERSION =
+      Objects.requireNonNull(Version.parse("3.4.0"));
+  private static final Version BROKEN_SASI_VERSION = Objects.requireNonNull(Version.parse("6.8.0"));
 
   protected static boolean isSasiBroken(BaseCcmRule ccmRule) {
-    Optional<Version> dseVersion = ccmRule.getDseVersion();
     // creating SASI indexes is broken in DSE 6.8.0
-    return dseVersion.isPresent() && dseVersion.get().compareTo(BROKEN_SASI_VERSION) == 0;
+    return ccmRule.isDistributionOf(
+        BackendType.DSE, (dist, cass) -> dist.compareTo(BROKEN_SASI_VERSION) == 0);
   }
 
   protected static boolean supportsSASI(BaseCcmRule ccmRule) {
diff --git a/integration-tests/src/test/resources/DescribeIT/hcd/1.0.cql b/integration-tests/src/test/resources/DescribeIT/hcd/1.0.cql
new file mode 100644
index 00000000000..abc70728206
--- /dev/null
+++ b/integration-tests/src/test/resources/DescribeIT/hcd/1.0.cql
@@ -0,0 +1,186 @@
+
+CREATE KEYSPACE ks_0 WITH replication = { 'class' : 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '1' } AND durable_writes = true;
+
+CREATE TYPE ks_0.btype (
+    a text
+);
+
+CREATE TYPE ks_0.xtype (
+    d text
+);
+
+CREATE TYPE ks_0.ztype (
+    c text,
+    a int
+);
+
+CREATE TYPE ks_0.ctype (
+    z frozen<ks_0.ztype>,
+    x frozen<ks_0.xtype>
+);
+
+CREATE TYPE ks_0.atype (
+    c frozen<ks_0.ctype>
+);
+
+CREATE TABLE ks_0.cyclist_mv (
+    cid uuid,
+    age int,
+    birthday date,
+    country text,
+    name text,
+    PRIMARY KEY (cid)
+) WITH additional_write_policy = '99p'
+    AND bloom_filter_fp_chance = 0.01
+    AND caching = {'keys':'ALL','rows_per_partition':'NONE'}
+    AND comment = ''
+    AND compaction = {'class':'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy','max_threshold':'32','min_threshold':'4'}
+    AND compression = {'chunk_length_in_kb':'64','class':'org.apache.cassandra.io.compress.LZ4Compressor'}
+    AND crc_check_chance = 1.0
+    AND default_time_to_live = 0
+    AND extensions = {}
+    AND gc_grace_seconds = 864000
+    AND max_index_interval = 2048
+    AND memtable_flush_period_in_ms = 0
+    AND min_index_interval = 128
+    AND read_repair = 'BLOCKING'
+    AND speculative_retry = '99p';
+
+CREATE INDEX cyclist_by_country ON ks_0.cyclist_mv (country);
+
+CREATE TABLE ks_0.rank_by_year_and_name (
+    race_year int,
+    race_name text,
+    rank int,
+    cyclist_name text,
+    PRIMARY KEY ((race_year, race_name), rank)
+) WITH CLUSTERING ORDER BY (rank DESC)
+    AND additional_write_policy = '99p'
+    AND bloom_filter_fp_chance = 0.01
+    AND caching = {'keys':'ALL','rows_per_partition':'NONE'}
+    AND comment = ''
+    AND compaction = {'class':'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy','max_threshold':'32','min_threshold':'4'}
+    AND compression = {'chunk_length_in_kb':'64','class':'org.apache.cassandra.io.compress.LZ4Compressor'}
+    AND crc_check_chance = 1.0
+    AND default_time_to_live = 0
+    AND extensions = {}
+    AND gc_grace_seconds = 864000
+    AND max_index_interval = 2048
+    AND memtable_flush_period_in_ms = 0
+    AND min_index_interval = 128
+    AND read_repair = 'BLOCKING'
+    AND speculative_retry = '99p';
+
+CREATE INDEX rrank ON ks_0.rank_by_year_and_name (rank);
+
+CREATE INDEX ryear ON ks_0.rank_by_year_and_name (race_year);
+
+CREATE TABLE ks_0.ztable (
+    zkey text,
+    a frozen<ks_0.atype>,
+    PRIMARY KEY (zkey)
+) WITH additional_write_policy = '99p'
+    AND bloom_filter_fp_chance = 0.1
+    AND caching = {'keys':'ALL','rows_per_partition':'NONE'}
+    AND comment = ''
+    AND compaction = {'class':'org.apache.cassandra.db.compaction.LeveledCompactionStrategy','max_threshold':'32','min_threshold':'4','sstable_size_in_mb':'95'}
+    AND compression = {'chunk_length_in_kb':'64','class':'org.apache.cassandra.io.compress.LZ4Compressor'}
+    AND crc_check_chance = 1.0
+    AND default_time_to_live = 0
+    AND extensions = {}
+    AND gc_grace_seconds = 864000
+    AND max_index_interval = 2048
+    AND memtable_flush_period_in_ms = 0
+    AND min_index_interval = 128
+    AND read_repair = 'BLOCKING'
+    AND speculative_retry = '99p';
+
+CREATE MATERIALIZED VIEW ks_0.cyclist_by_a_age AS
+SELECT * FROM ks_0.cyclist_mv
+WHERE age IS NOT NULL AND cid IS NOT NULL
+PRIMARY KEY (age, cid) WITH additional_write_policy = '99p'
+    AND bloom_filter_fp_chance = 0.01
+    AND caching = {'keys':'ALL','rows_per_partition':'NONE'}
+    AND comment = ''
+    AND compaction = {'class':'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy','max_threshold':'32','min_threshold':'4'}
+    AND compression = {'chunk_length_in_kb':'64','class':'org.apache.cassandra.io.compress.LZ4Compressor'}
+    AND crc_check_chance = 1.0
+    AND extensions = {}
+    AND gc_grace_seconds = 864000
+    AND max_index_interval = 2048
+    AND memtable_flush_period_in_ms = 0
+    AND min_index_interval = 128
+    AND read_repair = 'BLOCKING'
+    AND speculative_retry = '99p';
+
+CREATE MATERIALIZED VIEW ks_0.cyclist_by_age AS
+SELECT
+    age,
+    cid,
+    birthday,
+    country,
+    name
+FROM ks_0.cyclist_mv
+WHERE age IS NOT NULL AND cid IS NOT NULL
+PRIMARY KEY (age, cid) WITH additional_write_policy = '99p'
+    AND bloom_filter_fp_chance = 0.01
+    AND caching = {'keys':'ALL','rows_per_partition':'NONE'}
+    AND comment = 'simple view'
+    AND compaction = {'class':'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy','max_threshold':'32','min_threshold':'4'}
+    AND compression = {'chunk_length_in_kb':'64','class':'org.apache.cassandra.io.compress.LZ4Compressor'}
+    AND crc_check_chance = 1.0
+    AND extensions = {}
+    AND gc_grace_seconds = 864000
+    AND max_index_interval = 2048
+    AND memtable_flush_period_in_ms = 0
+    AND min_index_interval = 128
+    AND read_repair = 'BLOCKING'
+    AND speculative_retry = '99p';
+
+CREATE MATERIALIZED VIEW ks_0.cyclist_by_r_age AS
+SELECT
+    age,
+    cid,
+    birthday,
+    country,
+    name
+FROM ks_0.cyclist_mv
+WHERE age IS NOT NULL AND cid IS NOT NULL
+PRIMARY KEY (age, cid) WITH additional_write_policy = '99p'
+    AND bloom_filter_fp_chance = 0.01
+    AND caching = {'keys':'ALL','rows_per_partition':'NONE'}
+    AND comment = ''
+    AND compaction = {'class':'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy','max_threshold':'32','min_threshold':'4'}
+    AND compression = {'chunk_length_in_kb':'64','class':'org.apache.cassandra.io.compress.LZ4Compressor'}
+    AND crc_check_chance = 1.0
+    AND extensions = {}
+    AND gc_grace_seconds = 864000
+    AND max_index_interval = 2048
+    AND memtable_flush_period_in_ms = 0
+    AND min_index_interval = 128
+    AND read_repair = 'BLOCKING'
+    AND speculative_retry = '99p';
+
+CREATE FUNCTION ks_0.avgfinal(state tuple<int, bigint>)
+    CALLED ON NULL INPUT
+    RETURNS double
+    LANGUAGE java
+    AS 'double r = 0; if (state.getInt(0) == 0) return null; r = state.getLong(1); r /= state.getInt(0); return Double.valueOf(r);';
+
+CREATE FUNCTION ks_0.avgstate(state tuple<int, bigint>,val int)
+    CALLED ON NULL INPUT
+    RETURNS tuple<int, bigint>
+    LANGUAGE java
+    AS 'if (val !=null) { state.setInt(0, state.getInt(0)+1); state.setLong(1, state.getLong(1)+val.intValue()); } return state;';
+
+CREATE AGGREGATE ks_0.average(int)
+    SFUNC avgstate
+    STYPE tuple<int, bigint>
+    FINALFUNC avgfinal
+    INITCOND (0,0);
+
+CREATE AGGREGATE ks_0.mean(int)
+    SFUNC avgstate
+    STYPE tuple<int, bigint>
+    FINALFUNC avgfinal
+    INITCOND (0,0);
diff --git a/osgi-tests/README.md b/osgi-tests/README.md
index 89ad0ba27c8..1ca6211d427 100644
--- a/osgi-tests/README.md
+++ b/osgi-tests/README.md
@@ -53,8 +53,8 @@ OSGi ones, you can do so as follows:
 You can pass the following system properties to your tests:
 
 1. `ccm.version`: the CCM version to use
-2. `ccm.dse`: whether to use DSE
-3. `osgi.debug`: whether to enable remote debugging of the OSGi container (see 
+2. `ccm.distribution`: choose target backend type (e.g. DSE, HCD)
+3. `osgi.debug`: whether to enable remote debugging of the OSGi container (see
    below).
    
 ## Debugging OSGi tests
diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/CcmStagedReactor.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/CcmStagedReactor.java
index 8b140930870..ce4d9095361 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/CcmStagedReactor.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/CcmStagedReactor.java
@@ -19,6 +19,7 @@
 
 import com.datastax.oss.driver.api.core.Version;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmBridge;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import java.util.List;
 import java.util.Objects;
 import net.jcip.annotations.GuardedBy;
@@ -38,7 +39,7 @@ public class CcmStagedReactor extends AllConfinedStagedReactor {
 
   static {
     CcmBridge.Builder builder = CcmBridge.builder().withNodes(1);
-    if (CcmBridge.DSE_ENABLEMENT && CcmBridge.VERSION.compareTo(DSE_5_0) >= 0) {
+    if (CcmBridge.isDistributionOf(BackendType.DSE, (dist, cass) -> dist.compareTo(DSE_5_0) >= 0)) {
       builder.withDseWorkloads("graph");
     }
     CCM_BRIDGE = builder.build();
@@ -54,11 +55,10 @@ public CcmStagedReactor(List<TestContainer> containers, List<TestProbeBuilder> m
   @Override
   public synchronized void beforeSuite() {
     if (!running) {
-      boolean dse = CCM_BRIDGE.getDseVersion().isPresent();
       LOGGER.info(
           "Starting CCM, running {} version {}",
-          dse ? "DSE" : "Cassandra",
-          dse ? CCM_BRIDGE.getDseVersion().get() : CCM_BRIDGE.getCassandraVersion());
+          CcmBridge.DISTRIBUTION,
+          CcmBridge.getDistributionVersion());
       CCM_BRIDGE.create();
       CCM_BRIDGE.start();
       LOGGER.info("CCM started");
diff --git a/test-infra/revapi.json b/test-infra/revapi.json
index 3cfbc8b5337..c75a98cb4af 100644
--- a/test-infra/revapi.json
+++ b/test-infra/revapi.json
@@ -171,6 +171,27 @@
         "code": "java.method.removed",
         "old": "method void com.datastax.oss.driver.api.testinfra.ccm.CcmRule::reloadCore(int, java.lang.String, java.lang.String, boolean)",
         "justification": "Modifying the state of a globally shared CCM instance is dangerous"
+      },
+      {
+        "code": "java.method.removed",
+        "old": "method java.util.Optional<com.datastax.oss.driver.api.core.Version> com.datastax.oss.driver.api.testinfra.ccm.BaseCcmRule::getDseVersion()",
+        "justification": "Method has been replaced with more generic isDistributionOf(BackendType) and getDistributionVersion()"
+      },
+      {
+        "code": "java.field.removed",
+        "old": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DSE_ENABLEMENT",
+        "justification": "Method has been replaced with more generic isDistributionOf(BackendType) and getDistributionVersion()"
+      },
+      {
+        "code": "java.method.nowStatic",
+        "old": "method com.datastax.oss.driver.api.core.Version com.datastax.oss.driver.api.testinfra.ccm.CcmBridge::getCassandraVersion()",
+        "new": "method com.datastax.oss.driver.api.core.Version com.datastax.oss.driver.api.testinfra.ccm.CcmBridge::getCassandraVersion()",
+        "justification": "Previous and current implemntation do not relay on non-static fields"
+      },
+      {
+        "code": "java.method.removed",
+        "old": "method java.util.Optional<com.datastax.oss.driver.api.core.Version> com.datastax.oss.driver.api.testinfra.ccm.CcmBridge::getDseVersion()",
+        "justification": "Method has been replaced with more generic isDistributionOf(BackendType) and getDistributionVersion()"
       }
     ]
   }
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/BaseCcmRule.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/BaseCcmRule.java
index 65210acd2a2..882cd55b948 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/BaseCcmRule.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/BaseCcmRule.java
@@ -22,7 +22,7 @@
 import com.datastax.oss.driver.api.core.Version;
 import com.datastax.oss.driver.api.testinfra.CassandraResourceRule;
 import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirementRule;
-import java.util.Optional;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import org.junit.AssumptionViolatedException;
 import org.junit.runner.Description;
 import org.junit.runners.model.Statement;
@@ -72,17 +72,29 @@ public void evaluate() {
     }
   }
 
-  public Version getCassandraVersion() {
-    return ccmBridge.getCassandraVersion();
+  public BackendType getDistribution() {
+    return CcmBridge.DISTRIBUTION;
+  }
+
+  public boolean isDistributionOf(BackendType type) {
+    return CcmBridge.isDistributionOf(type);
+  }
+
+  public boolean isDistributionOf(BackendType type, CcmBridge.VersionComparator comparator) {
+    return CcmBridge.isDistributionOf(type, comparator);
+  }
+
+  public Version getDistributionVersion() {
+    return CcmBridge.getDistributionVersion();
   }
 
-  public Optional<Version> getDseVersion() {
-    return ccmBridge.getDseVersion();
+  public Version getCassandraVersion() {
+    return CcmBridge.getCassandraVersion();
   }
 
   @Override
   public ProtocolVersion getHighestProtocolVersion() {
-    if (ccmBridge.getCassandraVersion().compareTo(Version.V2_2_0) >= 0) {
+    if (CcmBridge.getCassandraVersion().compareTo(Version.V2_2_0) >= 0) {
       return DefaultProtocolVersion.V4;
     } else {
       return DefaultProtocolVersion.V3;
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
index 5b0c114a5fe..f0ce6bc5b0e 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/CcmBridge.java
@@ -18,6 +18,7 @@
 package com.datastax.oss.driver.api.testinfra.ccm;
 
 import com.datastax.oss.driver.api.core.Version;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.shaded.guava.common.base.Joiner;
 import com.datastax.oss.driver.shaded.guava.common.io.Resources;
 import java.io.File;
@@ -54,6 +55,9 @@ public class CcmBridge implements AutoCloseable {
 
   private static final Logger LOG = LoggerFactory.getLogger(CcmBridge.class);
 
+  public static BackendType DISTRIBUTION =
+      BackendType.valueOf(
+          System.getProperty("ccm.distribution", BackendType.CASSANDRA.name()).toUpperCase());
   public static final Version VERSION =
       Objects.requireNonNull(Version.parse(System.getProperty("ccm.version", "4.0.0")));
 
@@ -61,8 +65,6 @@ public class CcmBridge implements AutoCloseable {
 
   public static final String BRANCH = System.getProperty("ccm.branch");
 
-  public static final Boolean DSE_ENABLEMENT = Boolean.getBoolean("ccm.dse");
-
   public static final String CLUSTER_NAME = "ccm_1";
 
   public static final String DEFAULT_CLIENT_TRUSTSTORE_PASSWORD = "fakePasswordForTests";
@@ -101,22 +103,21 @@ public class CcmBridge implements AutoCloseable {
       createTempStore(DEFAULT_SERVER_LOCALHOST_KEYSTORE_PATH);
 
   // major DSE versions
-  private static final Version V6_0_0 = Version.parse("6.0.0");
-  private static final Version V5_1_0 = Version.parse("5.1.0");
-  private static final Version V5_0_0 = Version.parse("5.0.0");
+  public static final Version V6_0_0 = Version.parse("6.0.0");
+  public static final Version V5_1_0 = Version.parse("5.1.0");
+  public static final Version V5_0_0 = Version.parse("5.0.0");
 
   // mapped C* versions from DSE versions
-  private static final Version V4_0_0 = Version.parse("4.0.0");
-  private static final Version V3_10 = Version.parse("3.10");
-  private static final Version V3_0_15 = Version.parse("3.0.15");
-  private static final Version V2_1_19 = Version.parse("2.1.19");
+  public static final Version V4_0_0 = Version.parse("4.0.0");
+  public static final Version V3_10 = Version.parse("3.10");
+  public static final Version V3_0_15 = Version.parse("3.0.15");
+  public static final Version V2_1_19 = Version.parse("2.1.19");
+
+  // mapped C* versions from HCD versions
+  public static final Version V4_0_11 = Version.parse("4.0.11");
 
   static {
-    if (DSE_ENABLEMENT) {
-      LOG.info("CCM Bridge configured with DSE version {}", VERSION);
-    } else {
-      LOG.info("CCM Bridge configured with Apache Cassandra version {}", VERSION);
-    }
+    LOG.info("CCM Bridge configured with {} version {}", DISTRIBUTION.getFriendlyName(), VERSION);
   }
 
   private final int[] nodes;
@@ -175,25 +176,24 @@ private static boolean isWindows() {
     return System.getProperty("os.name", "").toLowerCase(Locale.US).contains("win");
   }
 
-  public Optional<Version> getDseVersion() {
-    return DSE_ENABLEMENT ? Optional.of(VERSION) : Optional.empty();
+  public static boolean isDistributionOf(BackendType type) {
+    return DISTRIBUTION == type;
+  }
+
+  public static boolean isDistributionOf(BackendType type, VersionComparator comparator) {
+    return isDistributionOf(type)
+        && comparator.accept(getDistributionVersion(), getCassandraVersion());
+  }
+
+  public static Version getDistributionVersion() {
+    return VERSION;
   }
 
-  public Version getCassandraVersion() {
-    if (!DSE_ENABLEMENT) {
+  public static Version getCassandraVersion() {
+    if (isDistributionOf(BackendType.CASSANDRA)) {
       return VERSION;
-    } else {
-      Version stableVersion = VERSION.nextStable();
-      if (stableVersion.compareTo(V6_0_0) >= 0) {
-        return V4_0_0;
-      } else if (stableVersion.compareTo(V5_1_0) >= 0) {
-        return V3_10;
-      } else if (stableVersion.compareTo(V5_0_0) >= 0) {
-        return V3_0_15;
-      } else {
-        return V2_1_19;
-      }
     }
+    return DistributionCassandraVersions.getCassandraVersion(DISTRIBUTION, VERSION);
   }
 
   private String getCcmVersionString(Version version) {
@@ -225,9 +225,7 @@ public void create() {
       } else {
         createOptions.add("-v " + getCcmVersionString(VERSION));
       }
-      if (DSE_ENABLEMENT) {
-        createOptions.add("--dse");
-      }
+      createOptions.addAll(Arrays.asList(DISTRIBUTION.getCcmOptions()));
       execute(
           "create",
           CLUSTER_NAME,
@@ -252,7 +250,7 @@ public void create() {
       // If we're dealing with anything more recent than 2.2 explicitly enable UDF... but run it
       // through our conversion process to make
       // sure more recent versions don't have a problem.
-      if (cassandraVersion.compareTo(Version.V2_2_0) >= 0) {
+      if (cassandraVersion.compareTo(Version.V2_2_0) >= 0 || isDistributionOf(BackendType.HCD)) {
         String originalKey = "enable_user_defined_functions";
         Object originalValue = "true";
         execute(
@@ -264,7 +262,7 @@ public void create() {
       }
 
       // Note that we aren't performing any substitution on DSE key/value props (at least for now)
-      if (DSE_ENABLEMENT) {
+      if (isDistributionOf(BackendType.DSE)) {
         for (Map.Entry<String, Object> conf : dseConfiguration.entrySet()) {
           execute("updatedseconf", String.format("%s:%s", conf.getKey(), conf.getValue()));
         }
@@ -338,11 +336,10 @@ public void stop(int n) {
   }
 
   public void add(int n, String dc) {
-    if (getDseVersion().isPresent()) {
-      execute("add", "-i", ipPrefix + n, "-d", dc, "node" + n, "--dse");
-    } else {
-      execute("add", "-i", ipPrefix + n, "-d", dc, "node" + n);
-    }
+    List<String> addOptions = new ArrayList<>();
+    addOptions.addAll(Arrays.asList("add", "-i", ipPrefix + n, "-d", dc, "node" + n));
+    addOptions.addAll(Arrays.asList(DISTRIBUTION.getCcmOptions()));
+    execute(addOptions.toArray(new String[0]));
     start(n);
   }
 
@@ -475,11 +472,11 @@ private Optional<Integer> overrideJvmVersionForDseWorkloads() {
       return Optional.empty();
     }
 
-    if (!DSE_ENABLEMENT || !getDseVersion().isPresent()) {
+    if (!isDistributionOf(BackendType.DSE)) {
       return Optional.empty();
     }
 
-    if (getDseVersion().get().compareTo(Version.V6_9_0) >= 0) {
+    if (getDistributionVersion().compareTo(Version.V6_9_0) >= 0) {
       // DSE 6.9.0 supports only JVM 11 onwards (also with graph workload)
       return Optional.empty();
     }
@@ -641,4 +638,8 @@ public CcmBridge build() {
           dseWorkloads);
     }
   }
+
+  public interface VersionComparator {
+    boolean accept(Version distribution, Version cassandra);
+  }
 }
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/DefaultCcmBridgeBuilderCustomizer.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/DefaultCcmBridgeBuilderCustomizer.java
index ac2507cec53..0819f785446 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/DefaultCcmBridgeBuilderCustomizer.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/DefaultCcmBridgeBuilderCustomizer.java
@@ -18,18 +18,20 @@
 package com.datastax.oss.driver.api.testinfra.ccm;
 
 import com.datastax.oss.driver.api.core.Version;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 
 /** @see CcmRule */
 @SuppressWarnings("unused")
 public class DefaultCcmBridgeBuilderCustomizer {
 
   public static CcmBridge.Builder configureBuilder(CcmBridge.Builder builder) {
-    if (!CcmBridge.DSE_ENABLEMENT
-        && CcmBridge.VERSION.nextStable().compareTo(Version.V4_0_0) >= 0) {
+    if (!CcmBridge.isDistributionOf(
+            BackendType.DSE, (dist, cass) -> dist.nextStable().compareTo(Version.V4_0_0) >= 0)
+        || CcmBridge.isDistributionOf(BackendType.HCD)) {
       builder.withCassandraConfiguration("enable_materialized_views", true);
       builder.withCassandraConfiguration("enable_sasi_indexes", true);
     }
-    if (CcmBridge.VERSION.nextStable().compareTo(Version.V3_0_0) >= 0) {
+    if (CcmBridge.getDistributionVersion().nextStable().compareTo(Version.V3_0_0) >= 0) {
       builder.withJvmArgs("-Dcassandra.superuser_setup_delay_ms=0");
       builder.withJvmArgs("-Dcassandra.skip_wait_for_gossip_to_settle=0");
       builder.withCassandraConfiguration("num_tokens", "1");
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/DistributionCassandraVersions.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/DistributionCassandraVersions.java
new file mode 100644
index 00000000000..9f7634d1b37
--- /dev/null
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/ccm/DistributionCassandraVersions.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.api.testinfra.ccm;
+
+import com.datastax.oss.driver.api.core.Version;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableSortedMap;
+import java.util.HashMap;
+import java.util.Map;
+
+/** Defines mapping of various distributions to shipped Apache Cassandra version. */
+public abstract class DistributionCassandraVersions {
+  private static final Map<BackendType, ImmutableSortedMap<Version, Version>> mappings =
+      new HashMap<>();
+
+  static {
+    {
+      // DSE
+      ImmutableSortedMap<Version, Version> dse =
+          ImmutableSortedMap.of(
+              Version.V1_0_0, CcmBridge.V2_1_19,
+              Version.V5_0_0, CcmBridge.V3_0_15,
+              CcmBridge.V5_1_0, CcmBridge.V3_10,
+              CcmBridge.V6_0_0, CcmBridge.V4_0_0);
+      mappings.put(BackendType.DSE, dse);
+    }
+    {
+      // HCD
+      ImmutableSortedMap<Version, Version> hcd =
+          ImmutableSortedMap.of(Version.V1_0_0, CcmBridge.V4_0_11);
+      mappings.put(BackendType.HCD, hcd);
+    }
+  }
+
+  public static Version getCassandraVersion(BackendType type, Version version) {
+    ImmutableSortedMap<Version, Version> mapping = mappings.get(type);
+    if (mapping == null) {
+      return null;
+    }
+    return mapping.floorEntry(version).getValue();
+  }
+}
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/requirement/BackendRequirementRule.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/requirement/BackendRequirementRule.java
index 6c59e216602..343861571e0 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/requirement/BackendRequirementRule.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/requirement/BackendRequirementRule.java
@@ -41,7 +41,7 @@ public void evaluate() {
   }
 
   protected static BackendType getBackendType() {
-    return CcmBridge.DSE_ENABLEMENT ? BackendType.DSE : BackendType.CASSANDRA;
+    return CcmBridge.DISTRIBUTION;
   }
 
   protected static Version getVersion() {
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/requirement/BackendType.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/requirement/BackendType.java
index 1683dd86136..e0058ca324a 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/requirement/BackendType.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/requirement/BackendType.java
@@ -18,9 +18,9 @@
 package com.datastax.oss.driver.api.testinfra.requirement;
 
 public enum BackendType {
-  CASSANDRA("C*"),
-  DSE("Dse"),
-  ;
+  CASSANDRA("Apache Cassandra"),
+  DSE("DSE"),
+  HCD("HCD");
 
   final String friendlyName;
 
@@ -31,4 +31,11 @@ public enum BackendType {
   public String getFriendlyName() {
     return friendlyName;
   }
+
+  public String[] getCcmOptions() {
+    if (this == CASSANDRA) {
+      return new String[0];
+    }
+    return new String[] {"--" + name().toLowerCase()};
+  }
 }
diff --git a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/session/SessionRule.java b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/session/SessionRule.java
index 5396e5c6cc6..3b792374769 100644
--- a/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/session/SessionRule.java
+++ b/test-infra/src/main/java/com/datastax/oss/driver/api/testinfra/session/SessionRule.java
@@ -29,10 +29,11 @@
 import com.datastax.oss.driver.api.core.session.Session;
 import com.datastax.oss.driver.api.testinfra.CassandraResourceRule;
 import com.datastax.oss.driver.api.testinfra.ccm.BaseCcmRule;
+import com.datastax.oss.driver.api.testinfra.ccm.CcmBridge;
 import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
 import com.datastax.oss.driver.api.testinfra.simulacron.SimulacronRule;
 import java.util.Objects;
-import java.util.Optional;
 import org.junit.rules.ExternalResource;
 
 /**
@@ -154,14 +155,12 @@ protected void before() {
           Statement.SYNC);
     }
     if (graphName != null) {
-      Optional<Version> dseVersion =
-          (cassandraResource instanceof BaseCcmRule)
-              ? ((BaseCcmRule) cassandraResource).getDseVersion()
-              : Optional.empty();
-      if (!dseVersion.isPresent()) {
+      BaseCcmRule rule =
+          (cassandraResource instanceof BaseCcmRule) ? ((BaseCcmRule) cassandraResource) : null;
+      if (rule == null || !CcmBridge.isDistributionOf(BackendType.DSE)) {
         throw new IllegalArgumentException("DseSessionRule should work with DSE.");
       }
-      if (dseVersion.get().compareTo(V6_8_0) >= 0) {
+      if (rule.getDistributionVersion().compareTo(V6_8_0) >= 0) {
         session()
             .execute(
                 ScriptGraphStatement.newInstance(

From e84378681aecdbb87696dc4b53cb6fd336c82b6b Mon Sep 17 00:00:00 2001
From: Stefan Miklosovic <smiklosovic@apache.org>
Date: Wed, 23 Oct 2024 22:23:39 +0200
Subject: [PATCH 048/126] Fix TableMetadata.describe() when containing a vector
 column

patch by Stefan Miklosovic; reviewed by Bret McGuire for CASSJAVA-2
---
 .../internal/core/type/DefaultVectorType.java |  2 +-
 .../metadata/schema/TableMetadataTest.java    | 67 +++++++++++++++++++
 2 files changed, 68 insertions(+), 1 deletion(-)
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/metadata/schema/TableMetadataTest.java

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
index 5915adc2fb3..c9180d44edc 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
@@ -60,7 +60,7 @@ public String getClassName() {
   @NonNull
   @Override
   public String asCql(boolean includeFrozen, boolean pretty) {
-    return String.format("'%s(%d)'", getClassName(), getDimensions());
+    return String.format("vector<%s, %d>", getElementType().asCql(true, false), getDimensions());
   }
 
   /* ============== General class implementation ============== */
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/schema/TableMetadataTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/schema/TableMetadataTest.java
new file mode 100644
index 00000000000..03d63230992
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/schema/TableMetadataTest.java
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.metadata.schema;
+
+import static com.datastax.oss.driver.api.core.CqlIdentifier.fromCql;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.datastax.oss.driver.api.core.metadata.schema.TableMetadata;
+import com.datastax.oss.driver.internal.core.type.DefaultVectorType;
+import com.datastax.oss.driver.internal.core.type.PrimitiveType;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
+import com.datastax.oss.protocol.internal.ProtocolConstants.DataType;
+import com.google.common.collect.ImmutableList;
+import java.util.UUID;
+import org.junit.Test;
+
+public class TableMetadataTest {
+
+  /** Tests CASSJAVA-2 */
+  @Test
+  public void should_describe_table_with_vector_correctly() {
+    TableMetadata tableMetadata =
+        new DefaultTableMetadata(
+            fromCql("ks"),
+            fromCql("tb"),
+            UUID.randomUUID(),
+            false,
+            false,
+            ImmutableList.of(
+                new DefaultColumnMetadata(
+                    fromCql("ks"),
+                    fromCql("ks"),
+                    fromCql("tb"),
+                    new PrimitiveType(DataType.ASCII),
+                    false)),
+            ImmutableMap.of(),
+            ImmutableMap.of(
+                fromCql("a"),
+                new DefaultColumnMetadata(
+                    fromCql("ks"),
+                    fromCql("ks"),
+                    fromCql("tb"),
+                    new DefaultVectorType(new PrimitiveType(DataType.INT), 3),
+                    false)),
+            ImmutableMap.of(),
+            ImmutableMap.of());
+
+    String describe1 = tableMetadata.describe(true);
+
+    assertThat(describe1).contains("vector<int, 3>,");
+  }
+}

From 62cea5a5f34d5cc6ef335f99829d0ae3cf9cf396 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Wed, 6 Nov 2024 17:47:30 -0600
Subject: [PATCH 049/126] Move Apache Cassandra 5.x off of beta1 and remove
 some older Apache Cassandra versions.

patch by Bret McGuire; reviewed by Bret McGuire for CASSJAVA-54
---
 Jenkinsfile-datastax | 52 +++++++++++++-------------------------------
 1 file changed, 15 insertions(+), 37 deletions(-)

diff --git a/Jenkinsfile-datastax b/Jenkinsfile-datastax
index af3faafee20..cd48f325a29 100644
--- a/Jenkinsfile-datastax
+++ b/Jenkinsfile-datastax
@@ -268,13 +268,9 @@ pipeline {
                       </table>''')
     choice(
       name: 'ADHOC_BUILD_AND_EXECUTE_TESTS_SERVER_VERSION',
-      choices: ['2.1',       // Legacy Apache CassandraⓇ
-                '2.2',       // Legacy Apache CassandraⓇ
-                '3.0',       // Previous Apache CassandraⓇ
-                '3.11',      // Previous Apache CassandraⓇ
-                '4.0',       // Previous Apache CassandraⓇ
-                '4.1',       // Current Apache CassandraⓇ
-                '5.0-beta1',    // Development Apache CassandraⓇ
+      choices: ['4.0',       // Previous Apache CassandraⓇ
+                '4.1',       // Previous Apache CassandraⓇ
+                '5.0',       // Current Apache CassandraⓇ
                 'dse-4.8.16',   // Previous EOSL DataStax Enterprise
                 'dse-5.0.15',   // Long Term Support DataStax Enterprise
                 'dse-5.1.35',   // Legacy DataStax Enterprise
@@ -292,22 +288,6 @@ pipeline {
                           <th align="left">Choice</th>
                           <th align="left">Description</th>
                         </tr>
-                        <tr>
-                          <td><strong>2.1</strong></td>
-                          <td>Apache Cassandra&reg; v2.1.x</td>
-                        </tr>
-                        <tr>
-                          <td><strong>2.2</strong></td>
-                          <td>Apache Cassandra&reg; v2.2.x</td>
-                        </tr>
-                        <tr>
-                          <td><strong>3.0</strong></td>
-                          <td>Apache Cassandra&reg; v3.0.x</td>
-                        </tr>
-                        <tr>
-                          <td><strong>3.11</strong></td>
-                          <td>Apache Cassandra&reg; v3.11.x</td>
-                        </tr>
                         <tr>
                           <td><strong>4.0</strong></td>
                           <td>Apache Cassandra&reg; v4.0.x</td>
@@ -316,6 +296,10 @@ pipeline {
                           <td><strong>4.1</strong></td>
                           <td>Apache Cassandra&reg; v4.1.x</td>
                         </tr>
+                        <tr>
+                          <td><strong>5.0</strong></td>
+                          <td>Apache Cassandra&reg; v5.0.x</td>
+                        </tr>
                         <tr>
                           <td><strong>dse-4.8.16</strong></td>
                           <td>DataStax Enterprise v4.8.x (<b>END OF SERVICE LIFE</b>)</td>
@@ -435,13 +419,10 @@ pipeline {
     // schedules only run against release branches (i.e. 3.x, 4.x, 4.5.x, etc.)
     parameterizedCron(branchPatternCron().matcher(env.BRANCH_NAME).matches() ? """
       # Every weekend (Saturday, Sunday) around 2:00 AM
-      ### JDK8 tests against 2.1, 3.0, 4.0, DSE 4.8, DSE 5.0, DSE 5.1, dse-6.0.18 and DSE 6.7
-      H 2 * * 0 %CI_SCHEDULE=WEEKENDS;CI_SCHEDULE_SERVER_VERSIONS=2.1 3.0 4.0 dse-4.8.16 dse-5.0.15 dse-5.1.35 dse-6.0.18 dse-6.7.17;CI_SCHEDULE_JABBA_VERSION=1.8
+      H 2 * * 0 %CI_SCHEDULE=WEEKENDS;CI_SCHEDULE_SERVER_VERSIONS=4.0 4.1 5.0 dse-4.8.16 dse-5.0.15 dse-5.1.35 dse-6.0.18 dse-6.7.17;CI_SCHEDULE_JABBA_VERSION=1.8
       # Every weeknight (Monday - Friday) around 12:00 PM noon
-      ### JDK11 tests against 3.11, 4.1, 5.0-beta1 and DSE 6.8
-      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30 dse-6.9.0 hcd-1.0.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.11
-      ### JDK17 tests against 3.11, 4.1, 5.0-beta1 and DSE 6.8
-      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=3.11 4.1 5.0-beta1 dse-6.8.30 dse-6.9.0 hcd-1.0.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.17
+      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=4.1 5.0 dse-6.8.30 dse-6.9.0 hcd-1.0.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.11
+      H 12 * * 1-5 %CI_SCHEDULE=WEEKNIGHTS;CI_SCHEDULE_SERVER_VERSIONS=4.1 5.0 dse-6.8.30 dse-6.9.0 hcd-1.0.0;CI_SCHEDULE_JABBA_VERSION=openjdk@1.17
     """ : "")
   }
 
@@ -475,8 +456,8 @@ pipeline {
         axes {
           axis {
             name 'SERVER_VERSION'
-            values '3.11',       // Latest stable Apache CassandraⓇ
-                   '4.1',        // Development Apache CassandraⓇ
+            values '4.0',        // Previous Apache CassandraⓇ
+                   '5.0',        // Current Apache CassandraⓇ
                    'dse-6.8.30', // Current DataStax Enterprise
                    'dse-6.9.0',  // Current DataStax Enterprise
                    'hcd-1.0.0'   // Current DataStax HCD
@@ -585,12 +566,9 @@ pipeline {
         axes {
           axis {
             name 'SERVER_VERSION'
-            values '2.1',       // Legacy Apache CassandraⓇ
-                   '3.0',       // Previous Apache CassandraⓇ
-                   '3.11',      // Previous Apache CassandraⓇ
-                   '4.0',       // Previous Apache CassandraⓇ
-                   '4.1',       // Current Apache CassandraⓇ
-                   '5.0-beta1',    // Development Apache CassandraⓇ
+            values '4.0',       // Previous Apache CassandraⓇ
+                   '4.1',       // Previous Apache CassandraⓇ
+                   '5.0',       // Current Apache CassandraⓇ
                    'dse-4.8.16',   // Previous EOSL DataStax Enterprise
                    'dse-5.0.15',   // Last EOSL DataStax Enterprise
                    'dse-5.1.35',   // Legacy DataStax Enterprise

From a322ca265654605123f4d7b889ad736c114f0c7e Mon Sep 17 00:00:00 2001
From: Jeremy Hanna <jeremy.hanna1234@gmail.com>
Date: Wed, 27 Nov 2024 12:41:02 -0600
Subject: [PATCH 050/126] Update link to Jira to be CASSJAVA

Updating the link to Jira.

Previously we had a component in the CASSANDRA Jira project but now we have a project for each driver - in the case of Java, it's CASSJAVA.

Added CASSJAVA to .asf.yaml

patch by Jeremy Hanna; reviewed by Bret McGuire for CASSJAVA-61
---
 .asf.yaml | 1 +
 README.md | 6 +++---
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/.asf.yaml b/.asf.yaml
index ad58f536398..ac29efed9ff 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -34,3 +34,4 @@ github:
     projects: false
   autolink_jira:
     - CASSANDRA
+    - CASSJAVA
diff --git a/README.md b/README.md
index 2a30cb68c9a..b6e1cc337d8 100644
--- a/README.md
+++ b/README.md
@@ -75,13 +75,13 @@ See the [Cassandra error handling done right blog](https://www.datastax.com/blog
 
 * [Manual](manual/)
 * [API docs]
-* Bug tracking: [JIRA].  Make sure to select the "Client/java-driver" component when filing new tickets!
+* Bug tracking: [JIRA]
 * [Mailing list]
 * [Changelog]
 * [FAQ]
 
 [API docs]: https://docs.datastax.com/en/drivers/java/4.17
-[JIRA]: https://issues.apache.org/jira/issues/?jql=project%20%3D%20CASSANDRA%20AND%20component%20%3D%20%22Client%2Fjava-driver%22%20ORDER%20BY%20key%20DESC
+[JIRA]: https://issues.apache.org/jira/issues/?jql=project%20%3D%20CASSJAVA%20ORDER%20BY%20key%20DESC
 [Mailing list]: https://groups.google.com/a/lists.datastax.com/forum/#!forum/java-driver-user
 [Changelog]: changelog/
 [FAQ]: faq/
@@ -108,4 +108,4 @@ Apache Cassandra, Apache, Tomcat, Lucene, Solr, Hadoop, Spark, TinkerPop, and Ca
 trademarks of the [Apache Software Foundation](http://www.apache.org/) or its subsidiaries in
 Canada, the United States and/or other countries. 
 
-Binary artifacts of this product bundle Java Native Runtime libraries, which is available under the Eclipse Public License version 2.0.
\ No newline at end of file
+Binary artifacts of this product bundle Java Native Runtime libraries, which is available under the Eclipse Public License version 2.0.

From 7bc085bdfb337b91255573bc3e130815e280954a Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Wed, 6 Nov 2024 08:31:36 +0100
Subject: [PATCH 051/126] Move DataStax shaded Guava module into Java driver

patch by Lukasz Antoniak; reviewed by Alexandre Dutra and Bret McGuire for CASSJAVA-52
---
 bom/pom.xml                                   |  10 +-
 core-shaded/pom.xml                           |   4 +-
 core/pom.xml                                  |   4 +-
 distribution/src/assembly/binary-tarball.xml  |   6 +-
 guava-shaded/pom.xml                          | 215 ++++++++++++++++++
 guava-shaded/src/assembly/shaded-jar.xml      |  48 ++++
 ...graphicalComparatorHolderSubstitution.java |  39 ++++
 .../UnsafeComparatorSubstitution.java         |  25 ++
 guava-shaded/src/main/javadoc/README.txt      |   2 +
 manual/core/integration/README.md             |   2 +-
 mapper-processor/pom.xml                      |   4 +-
 osgi-tests/pom.xml                            |   4 +-
 .../internal/osgi/support/BundleOptions.java  |   2 +-
 pom.xml                                       |   3 +-
 query-builder/pom.xml                         |   4 +-
 15 files changed, 351 insertions(+), 21 deletions(-)
 create mode 100644 guava-shaded/pom.xml
 create mode 100644 guava-shaded/src/assembly/shaded-jar.xml
 create mode 100644 guava-shaded/src/main/java/com/google/common/primitives/LexicographicalComparatorHolderSubstitution.java
 create mode 100644 guava-shaded/src/main/java/com/google/common/primitives/UnsafeComparatorSubstitution.java
 create mode 100644 guava-shaded/src/main/javadoc/README.txt

diff --git a/bom/pom.xml b/bom/pom.xml
index 96b7a6ceb18..08f212f6157 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -55,6 +55,11 @@
         <artifactId>java-driver-query-builder</artifactId>
         <version>4.18.2-SNAPSHOT</version>
       </dependency>
+      <dependency>
+        <groupId>org.apache.cassandra</groupId>
+        <artifactId>java-driver-guava-shaded</artifactId>
+        <version>4.18.2-SNAPSHOT</version>
+      </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
@@ -75,11 +80,6 @@
         <artifactId>native-protocol</artifactId>
         <version>1.5.1</version>
       </dependency>
-      <dependency>
-        <groupId>com.datastax.oss</groupId>
-        <artifactId>java-driver-shaded-guava</artifactId>
-        <version>25.1-jre-graal-sub-1</version>
-      </dependency>
     </dependencies>
   </dependencyManagement>
   <build>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 6c139aab127..9a708beb2a7 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -57,8 +57,8 @@
       <artifactId>native-protocol</artifactId>
     </dependency>
     <dependency>
-      <groupId>com.datastax.oss</groupId>
-      <artifactId>java-driver-shaded-guava</artifactId>
+      <groupId>org.apache.cassandra</groupId>
+      <artifactId>java-driver-guava-shaded</artifactId>
     </dependency>
     <dependency>
       <groupId>com.typesafe</groupId>
diff --git a/core/pom.xml b/core/pom.xml
index 33688754f1b..2a48e8bf9ce 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -49,8 +49,8 @@
       <artifactId>netty-handler</artifactId>
     </dependency>
     <dependency>
-      <groupId>com.datastax.oss</groupId>
-      <artifactId>java-driver-shaded-guava</artifactId>
+      <groupId>org.apache.cassandra</groupId>
+      <artifactId>java-driver-guava-shaded</artifactId>
     </dependency>
     <dependency>
       <groupId>com.typesafe</groupId>
diff --git a/distribution/src/assembly/binary-tarball.xml b/distribution/src/assembly/binary-tarball.xml
index 0d025fafb2c..b6294a25340 100644
--- a/distribution/src/assembly/binary-tarball.xml
+++ b/distribution/src/assembly/binary-tarball.xml
@@ -66,8 +66,8 @@
               <exclude>org.apache.cassandra:java-driver-core</exclude>
               <exclude>org.apache.cassandra:java-driver-mapper-runtime</exclude>
               <exclude>org.apache.cassandra:java-driver-mapper-processor</exclude>
+              <exclude>org.apache.cassandra:java-driver-guava-shaded</exclude>
               <!-- Don't reinclude dependencies that core also has -->
-              <exclude>com.datastax.oss:java-driver-shaded-guava</exclude>
               <exclude>com.github.stephenc.jcip:jcip-annotations</exclude>
               <exclude>com.github.spotbugs:spotbugs-annotations</exclude>
             </excludes>
@@ -91,8 +91,8 @@
               <exclude>org.apache.cassandra:java-driver-core</exclude>
               <exclude>org.apache.cassandra:java-driver-query-builder</exclude>
               <exclude>org.apache.cassandra:java-driver-mapper-processor</exclude>
+              <exclude>org.apache.cassandra:java-driver-guava-shaded</exclude>
               <!-- Don't reinclude dependencies that core also has -->
-              <exclude>com.datastax.oss:java-driver-shaded-guava</exclude>
               <exclude>com.github.stephenc.jcip:jcip-annotations</exclude>
               <exclude>com.github.spotbugs:spotbugs-annotations</exclude>
             </excludes>
@@ -116,8 +116,8 @@
               <exclude>org.apache.cassandra:java-driver-core</exclude>
               <exclude>org.apache.cassandra:java-driver-query-builder</exclude>
               <exclude>org.apache.cassandra:java-driver-mapper-runtime</exclude>
+              <exclude>org.apache.cassandra:java-driver-guava-shaded</exclude>
               <!-- Don't reinclude dependencies that core also has -->
-              <exclude>com.datastax.oss:java-driver-shaded-guava</exclude>
               <exclude>com.github.stephenc.jcip:jcip-annotations</exclude>
               <exclude>com.github.spotbugs:spotbugs-annotations</exclude>
             </excludes>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
new file mode 100644
index 00000000000..9854fcc48ba
--- /dev/null
+++ b/guava-shaded/pom.xml
@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.apache.cassandra</groupId>
+    <artifactId>java-driver-parent</artifactId>
+    <version>4.18.2-SNAPSHOT</version>
+  </parent>
+  <artifactId>java-driver-guava-shaded</artifactId>
+  <name>Apache Cassandra Java Driver - guava shaded dep</name>
+  <description>Shaded Guava artifact for use in the Java driver for Apache Cassandra®</description>
+  <dependencies>
+    <dependency>
+      <groupId>com.google.guava</groupId>
+      <artifactId>guava</artifactId>
+      <exclusions>
+        <exclusion>
+          <groupId>com.google.code.findbugs</groupId>
+          <artifactId>jsr305</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.checkerframework</groupId>
+          <artifactId>checker-qual</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>com.google.errorprone</groupId>
+          <artifactId>error_prone_annotations</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>com.google.j2objc</groupId>
+          <artifactId>j2objc-annotations</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.codehaus.mojo</groupId>
+          <artifactId>animal-sniffer-annotations</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>org.graalvm.nativeimage</groupId>
+      <artifactId>svm</artifactId>
+      <version>20.0.0</version>
+      <scope>provided</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <plugins>
+      <plugin>
+        <artifactId>maven-shade-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>shade-guava-dependency</id>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <artifactSet>
+                <includes>
+                  <include>org.apache.cassandra:java-driver-guava-shaded</include>
+                  <include>com.google.guava:guava</include>
+                </includes>
+              </artifactSet>
+              <relocations>
+                <relocation>
+                  <pattern>com.google</pattern>
+                  <shadedPattern>com.datastax.oss.driver.shaded.guava</shadedPattern>
+                </relocation>
+              </relocations>
+              <filters>
+                <filter>
+                  <artifact>com.google.guava:*</artifact>
+                  <excludes>
+                    <exclude>META-INF/**</exclude>
+                  </excludes>
+                </filter>
+              </filters>
+              <createSourcesJar>true</createSourcesJar>
+              <shadeSourcesContent>true</shadeSourcesContent>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <artifactId>maven-clean-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>clean-classes</id>
+            <phase>package</phase>
+            <goals>
+              <goal>clean</goal>
+            </goals>
+            <configuration>
+              <directory>${project.build.outputDirectory}</directory>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <artifactId>maven-dependency-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>unpack-shaded-classes</id>
+            <phase>package</phase>
+            <goals>
+              <goal>unpack</goal>
+            </goals>
+            <configuration>
+              <outputDirectory>${project.build.outputDirectory}</outputDirectory>
+              <artifactItems>
+                <artifactItem>
+                  <groupId>org.apache.cassandra</groupId>
+                  <artifactId>java-driver-guava-shaded</artifactId>
+                  <version>${project.version}</version>
+                  <type>jar</type>
+                </artifactItem>
+              </artifactItems>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.felix</groupId>
+        <artifactId>maven-bundle-plugin</artifactId>
+        <!--
+        Using later version of the plugin will scan all dynamically loaded classes
+        with Class.forName(). In the end, more packages will be imported in MANIFEST.MF
+        and OSGi integration tests will break.
+        -->
+        <version>3.5.0</version>
+        <extensions>true</extensions>
+        <executions>
+          <execution>
+            <id>generate-shaded-manifest</id>
+            <phase>package</phase>
+            <goals>
+              <goal>manifest</goal>
+            </goals>
+            <configuration>
+              <instructions>
+                <Bundle-SymbolicName>com.datastax.oss.driver.shaded.guava</Bundle-SymbolicName>
+                <Export-Package>!com.datastax.oss.driver.shaded.guava.errorprone.*, !org.checkerframework.*, *</Export-Package>
+                <Import-Package>javax.annotation.*;resolution:=optional;version="[3.0,4)", javax.crypto.*;resolution:=optional, sun.misc.*;resolution:=optional, !com.oracle.svm.*, !com.datastax.oss.driver.shaded.guava.errorprone.*, !org.checkerframework.*, *</Import-Package>
+              </instructions>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>generate-final-shaded-jar</id>
+            <phase>package</phase>
+            <goals>
+              <goal>single</goal>
+            </goals>
+            <configuration>
+              <archive>
+                <!-- this is the manifest generated by the bundle plugin -->
+                <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+              </archive>
+              <descriptors>
+                <descriptor>src/assembly/shaded-jar.xml</descriptor>
+              </descriptors>
+              <!-- Replace the original artifact -->
+              <appendAssemblyId>false</appendAssemblyId>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <artifactId>maven-jar-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>empty-javadoc-jar</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+            <configuration>
+              <classifier>javadoc</classifier>
+              <classesDirectory>${basedir}/src/main/javadoc</classesDirectory>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.revapi</groupId>
+        <artifactId>revapi-maven-plugin</artifactId>
+        <configuration>
+          <skip>true</skip>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/guava-shaded/src/assembly/shaded-jar.xml b/guava-shaded/src/assembly/shaded-jar.xml
new file mode 100644
index 00000000000..d762a27b20f
--- /dev/null
+++ b/guava-shaded/src/assembly/shaded-jar.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+
+-->
+<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
+  <id>shaded-jar</id>
+  <formats>
+    <format>jar</format>
+  </formats>
+  <includeBaseDirectory>false</includeBaseDirectory>
+  <fileSets>
+    <!--
+    Include everything from the shaded jar created with the shade plugin and
+    unpacked by the dependency plugin
+    -->
+    <fileSet>
+      <directory>${project.build.outputDirectory}</directory>
+      <excludes>
+        <exclude>META-INF/maven/org.apache.cassandra/java-driver-guava-shaded/pom.xml</exclude>
+      </excludes>
+      <outputDirectory/>
+    </fileSet>
+  </fileSets>
+  <!-- Include the transformed pom with shaded deps created by the shade plugin -->
+  <files>
+    <file>
+      <source>${project.basedir}/dependency-reduced-pom.xml</source>
+      <outputDirectory>META-INF/maven/org.apache.cassandra/java-driver-guava-shaded</outputDirectory>
+      <destName>pom.xml</destName>
+    </file>
+  </files>
+</assembly>
diff --git a/guava-shaded/src/main/java/com/google/common/primitives/LexicographicalComparatorHolderSubstitution.java b/guava-shaded/src/main/java/com/google/common/primitives/LexicographicalComparatorHolderSubstitution.java
new file mode 100644
index 00000000000..95e9c70cdbc
--- /dev/null
+++ b/guava-shaded/src/main/java/com/google/common/primitives/LexicographicalComparatorHolderSubstitution.java
@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.google.common.primitives;
+
+import com.oracle.svm.core.annotate.Alias;
+import com.oracle.svm.core.annotate.RecomputeFieldValue;
+import com.oracle.svm.core.annotate.Substitute;
+import com.oracle.svm.core.annotate.TargetClass;
+import java.util.Comparator;
+
+@TargetClass(UnsignedBytes.LexicographicalComparatorHolder.class)
+final class LexicographicalComparatorHolderSubstitution {
+
+  @Alias
+  @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.FromAlias)
+  static Comparator<byte[]> BEST_COMPARATOR = UnsignedBytes.lexicographicalComparatorJavaImpl();
+
+  /* All known cases should be covered by the field substitution above... keeping this only
+   * for sake of completeness */
+  @Substitute
+  static Comparator<byte[]> getBestComparator() {
+    return UnsignedBytes.lexicographicalComparatorJavaImpl();
+  }
+}
diff --git a/guava-shaded/src/main/java/com/google/common/primitives/UnsafeComparatorSubstitution.java b/guava-shaded/src/main/java/com/google/common/primitives/UnsafeComparatorSubstitution.java
new file mode 100644
index 00000000000..549de0b5c02
--- /dev/null
+++ b/guava-shaded/src/main/java/com/google/common/primitives/UnsafeComparatorSubstitution.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.google.common.primitives;
+
+import com.oracle.svm.core.annotate.Delete;
+import com.oracle.svm.core.annotate.TargetClass;
+
+@TargetClass(UnsignedBytes.LexicographicalComparatorHolder.UnsafeComparator.class)
+@Delete
+final class UnsafeComparatorSubstitution {}
diff --git a/guava-shaded/src/main/javadoc/README.txt b/guava-shaded/src/main/javadoc/README.txt
new file mode 100644
index 00000000000..57f82b2a265
--- /dev/null
+++ b/guava-shaded/src/main/javadoc/README.txt
@@ -0,0 +1,2 @@
+This empty JAR is generated for compliance with Maven Central rules. Please refer to the original
+Guava API docs.
\ No newline at end of file
diff --git a/manual/core/integration/README.md b/manual/core/integration/README.md
index 2dfc0155c63..f2a96160bce 100644
--- a/manual/core/integration/README.md
+++ b/manual/core/integration/README.md
@@ -671,7 +671,7 @@ The remaining core driver dependencies are the only ones that are truly mandator
 
 * the [native protocol](https://github.com/datastax/native-protocol) layer. This is essentially part
   of the driver code, but was externalized for reuse in other projects;
-* `java-driver-shaded-guava`, a shaded version of [Guava](https://github.com/google/guava). It is
+* `java-driver-guava-shaded`, a shaded version of [Guava](https://github.com/google/guava). It is
   relocated to a different package, and only used by internal driver code, so it should be
   completely transparent to third-party code;
 * the [SLF4J](https://www.slf4j.org/) API for [logging](../logging/).
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 61906f41987..6588f17d5f7 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -44,8 +44,8 @@
       <artifactId>java-driver-mapper-runtime</artifactId>
     </dependency>
     <dependency>
-      <groupId>com.datastax.oss</groupId>
-      <artifactId>java-driver-shaded-guava</artifactId>
+      <groupId>org.apache.cassandra</groupId>
+      <artifactId>java-driver-guava-shaded</artifactId>
     </dependency>
     <dependency>
       <groupId>com.squareup</groupId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 5947aff1bc5..f0e66b656ca 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -71,8 +71,8 @@
       <artifactId>logback-classic</artifactId>
     </dependency>
     <dependency>
-      <groupId>com.datastax.oss</groupId>
-      <artifactId>java-driver-shaded-guava</artifactId>
+      <groupId>org.apache.cassandra</groupId>
+      <artifactId>java-driver-guava-shaded</artifactId>
     </dependency>
     <dependency>
       <groupId>org.xerial.snappy</groupId>
diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
index 536a6d96c77..3e6171ca530 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
@@ -35,7 +35,7 @@ public class BundleOptions {
   public static CompositeOption commonBundles() {
     return () ->
         options(
-            mavenBundle("com.datastax.oss", "java-driver-shaded-guava").versionAsInProject(),
+            mavenBundle("org.apache.cassandra", "java-driver-guava-shaded").versionAsInProject(),
             mavenBundle("io.dropwizard.metrics", "metrics-core").versionAsInProject(),
             mavenBundle("org.slf4j", "slf4j-api").versionAsInProject(),
             mavenBundle("org.hdrhistogram", "HdrHistogram").versionAsInProject(),
diff --git a/pom.xml b/pom.xml
index 94311719e5f..620cf1db4bb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -40,6 +40,7 @@
     <module>mapper-processor</module>
     <module>metrics/micrometer</module>
     <module>metrics/microprofile</module>
+    <module>guava-shaded</module>
     <module>test-infra</module>
     <module>integration-tests</module>
     <module>osgi-tests</module>
@@ -110,7 +111,7 @@
         <version>${netty.version}</version>
       </dependency>
       <dependency>
-        <!-- Only for integration tests, use the shaded JAR for production code -->
+        <!-- Version of Guava used in shaded module and for integration tests. -->
         <groupId>com.google.guava</groupId>
         <artifactId>guava</artifactId>
         <version>25.1-jre</version>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index bae0e0c6ca0..4e09a10e584 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -45,8 +45,8 @@
       <artifactId>java-driver-core</artifactId>
     </dependency>
     <dependency>
-      <groupId>com.datastax.oss</groupId>
-      <artifactId>java-driver-shaded-guava</artifactId>
+      <groupId>org.apache.cassandra</groupId>
+      <artifactId>java-driver-guava-shaded</artifactId>
     </dependency>
     <dependency>
       <groupId>com.github.stephenc.jcip</groupId>

From 7ca013fbd5f1ec589df52ef0e6441986f07c11ff Mon Sep 17 00:00:00 2001
From: Ammar Khaku <ammar.khaku@gmail.com>
Date: Sat, 22 Apr 2023 16:13:15 -0700
Subject: [PATCH 052/126] JAVA-3057 Allow decoding a UDT that has more fields
 than expected

patch by Ammar Khaku; reviewed by Andy Tolbert and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1635
---
 .../internal/core/type/codec/UdtCodec.java    | 10 ++-
 .../core/type/codec/UdtCodecTest.java         | 24 +++---
 .../internal/core/type/codec/UdtCodecIT.java  | 77 +++++++++++++++++++
 3 files changed, 95 insertions(+), 16 deletions(-)
 create mode 100644 integration-tests/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecIT.java

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodec.java
index f5177e63b5e..5d0a379f761 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodec.java
@@ -30,10 +30,14 @@
 import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
 import net.jcip.annotations.ThreadSafe;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 @ThreadSafe
 public class UdtCodec implements TypeCodec<UdtValue> {
 
+  private static final Logger LOG = LoggerFactory.getLogger(UdtCodec.class);
+
   private final UserDefinedType cqlType;
 
   public UdtCodec(@NonNull UserDefinedType cqlType) {
@@ -107,10 +111,8 @@ public UdtValue decode(@Nullable ByteBuffer bytes, @NonNull ProtocolVersion prot
       int i = 0;
       while (input.hasRemaining()) {
         if (i == cqlType.getFieldTypes().size()) {
-          throw new IllegalArgumentException(
-              String.format(
-                  "Too many fields in encoded UDT value, expected %d",
-                  cqlType.getFieldTypes().size()));
+          LOG.debug("Encountered unexpected fields when parsing codec {}", cqlType);
+          break;
         }
         int elementSize = input.getInt();
         ByteBuffer element;
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecTest.java
index bf7c1e98b26..af94247f937 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecTest.java
@@ -136,18 +136,18 @@ public void should_decode_udt() {
   }
 
   @Test
-  public void should_fail_to_decode_udt_when_too_many_fields() {
-    assertThatThrownBy(
-            () ->
-                decode(
-                    "0x"
-                        + ("00000004" + "00000001")
-                        + "ffffffff"
-                        + ("00000001" + "61")
-                        // extra contents
-                        + "ffffffff"))
-        .isInstanceOf(IllegalArgumentException.class)
-        .hasMessage("Too many fields in encoded UDT value, expected 3");
+  public void should_decode_udt_when_too_many_fields() {
+    UdtValue udt =
+        decode(
+            "0x"
+                + ("00000004" + "00000001")
+                + "ffffffff"
+                + ("00000001" + "61")
+                // extra contents
+                + "ffffffff");
+    assertThat(udt.getInt(0)).isEqualTo(1);
+    assertThat(udt.isNull(1)).isTrue();
+    assertThat(udt.getString(2)).isEqualTo("a");
   }
 
   /** Test for JAVA-2557. Ensures that the codec can decode null fields with any negative length. */
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecIT.java
new file mode 100644
index 00000000000..804a078bbe0
--- /dev/null
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecIT.java
@@ -0,0 +1,77 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.type.codec;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.cql.Row;
+import com.datastax.oss.driver.api.core.data.UdtValue;
+import com.datastax.oss.driver.api.core.type.UserDefinedType;
+import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
+import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.session.SessionRule;
+import com.datastax.oss.driver.categories.ParallelizableTests;
+import java.util.Objects;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.RuleChain;
+import org.junit.rules.TestRule;
+
+@Category(ParallelizableTests.class)
+public class UdtCodecIT {
+
+  private CcmRule ccmRule = CcmRule.getInstance();
+
+  private SessionRule<CqlSession> sessionRule = SessionRule.builder(ccmRule).build();
+
+  @Rule public TestRule chain = RuleChain.outerRule(ccmRule).around(sessionRule);
+
+  @Test
+  public void should_decoding_udt_be_backward_compatible() {
+    CqlSession session = sessionRule.session();
+    session.execute("CREATE TYPE test_type_1 (a text, b int)");
+    session.execute("CREATE TABLE test_table_1 (e int primary key, f frozen<test_type_1>)");
+    // insert a row using version 1 of the UDT schema
+    session.execute("INSERT INTO test_table_1(e, f) VALUES(1, {a: 'a', b: 1})");
+    UserDefinedType udt =
+        session
+            .getMetadata()
+            .getKeyspace(sessionRule.keyspace())
+            .flatMap(ks -> ks.getUserDefinedType("test_type_1"))
+            .orElseThrow(IllegalStateException::new);
+    TypeCodec<?> oldCodec = session.getContext().getCodecRegistry().codecFor(udt);
+    // update UDT schema
+    session.execute("ALTER TYPE test_type_1 add i text");
+    // insert a row using version 2 of the UDT schema
+    session.execute("INSERT INTO test_table_1(e, f) VALUES(2, {a: 'b', b: 2, i: 'b'})");
+    Row row =
+        Objects.requireNonNull(session.execute("SELECT f FROM test_table_1 WHERE e = ?", 2).one());
+    // Try to read new row with old codec. Using row.getUdtValue() would not cause any issues,
+    // because new codec will be automatically registered (using all 3 attributes).
+    // If application leverages generic row.get(String, Codec) method, data reading with old codec
+    // should
+    // be backward-compatible.
+    UdtValue value = Objects.requireNonNull((UdtValue) row.get("f", oldCodec));
+    assertThat(value.getString("a")).isEqualTo("b");
+    assertThat(value.getInt("b")).isEqualTo(2);
+    assertThatThrownBy(() -> value.getString("i")).hasMessage("i is not a field in this UDT");
+  }
+}

From 6a8674f2db92668359196b5492753612b3844594 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Mon, 11 Nov 2024 11:49:20 -0600
Subject: [PATCH 053/126] CASSJAVA-55 Remove setting "Host" header for metadata
 requests.

With some sysprops enabled this will actually be respected which completely borks Astra routing.

patch by Bret McGuire; reviewed by Alexandre Dutra and Bret McGuire for CASSJAVA-55
---
 .../driver/internal/core/config/cloud/CloudConfigFactory.java    | 1 -
 1 file changed, 1 deletion(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/config/cloud/CloudConfigFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/config/cloud/CloudConfigFactory.java
index b6b2cccc466..817b3263d25 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/config/cloud/CloudConfigFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/config/cloud/CloudConfigFactory.java
@@ -229,7 +229,6 @@ protected BufferedReader fetchProxyMetadata(
       HttpsURLConnection connection = (HttpsURLConnection) metadataServiceUrl.openConnection();
       connection.setSSLSocketFactory(sslContext.getSocketFactory());
       connection.setRequestMethod("GET");
-      connection.setRequestProperty("host", "localhost");
       return new BufferedReader(
           new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8));
     } catch (ConnectException e) {

From 7689c5a81e89bce5598d9976a041068a1f5e2a7f Mon Sep 17 00:00:00 2001
From: SiyaoIsHiding <113857408+SiyaoIsHiding@users.noreply.github.com>
Date: Tue, 7 Jan 2025 14:30:58 +0800
Subject: [PATCH 054/126] JAVA-3118: Add support for vector data type in Schema
 Builder, QueryBuilder patch by Jane He; reviewed by Mick Semb Wever and Bret
 McGuire for JAVA-3118 reference: #1931

---
 manual/query_builder/select/README.md         | 23 +++++
 query-builder/revapi.json                     | 10 +++
 .../api/querybuilder/select/Select.java       | 11 +++
 .../querybuilder/select/DefaultSelect.java    | 86 +++++++++++++++++--
 .../delete/DeleteSelectorTest.java            | 11 +++
 .../insert/RegularInsertTest.java             |  7 ++
 .../querybuilder/schema/AlterTableTest.java   |  6 ++
 .../querybuilder/schema/AlterTypeTest.java    |  6 ++
 .../querybuilder/schema/CreateTableTest.java  |  9 ++
 .../querybuilder/schema/CreateTypeTest.java   |  9 ++
 .../select/SelectOrderingTest.java            | 20 +++++
 .../select/SelectSelectorTest.java            | 43 ++++++++++
 12 files changed, 233 insertions(+), 8 deletions(-)

diff --git a/manual/query_builder/select/README.md b/manual/query_builder/select/README.md
index 92c058608e7..0425423a402 100644
--- a/manual/query_builder/select/README.md
+++ b/manual/query_builder/select/README.md
@@ -387,6 +387,29 @@ selectFrom("sensor_data")
 // SELECT reading FROM sensor_data WHERE id=? ORDER BY date DESC
 ```
 
+Vector Search:
+
+```java
+
+import com.datastax.oss.driver.api.core.data.CqlVector;
+
+selectFrom("foo")
+    .all()
+    .where(Relation.column("k").isEqualTo(literal(1)))
+    .orderByAnnOf("c1", CqlVector.newInstance(0.1, 0.2, 0.3));
+// SELECT * FROM foo WHERE k=1 ORDER BY c1 ANN OF [0.1, 0.2, 0.3]
+
+selectFrom("cycling", "comments_vs")
+    .column("comment")
+    .function(
+        "similarity_cosine",
+        Selector.column("comment_vector"),
+        literal(CqlVector.newInstance(0.2, 0.15, 0.3, 0.2, 0.05)))
+    .orderByAnnOf("comment_vector", CqlVector.newInstance(0.1, 0.15, 0.3, 0.12, 0.05))
+    .limit(1);
+// SELECT comment,similarity_cosine(comment_vector,[0.2, 0.15, 0.3, 0.2, 0.05]) FROM cycling.comments_vs ORDER BY comment_vector ANN OF [0.1, 0.15, 0.3, 0.12, 0.05] LIMIT 1
+```
+
 Limits:
 
 ```java
diff --git a/query-builder/revapi.json b/query-builder/revapi.json
index 9d0163b487e..c4d8aa27212 100644
--- a/query-builder/revapi.json
+++ b/query-builder/revapi.json
@@ -2772,6 +2772,16 @@
         "code": "java.method.addedToInterface",
         "new": "method com.datastax.oss.driver.api.querybuilder.update.UpdateStart com.datastax.oss.driver.api.querybuilder.update.UpdateStart::usingTtl(int)",
         "justification": "JAVA-2210: Add ability to set TTL for modification queries"
+      },
+      {
+        "code": "java.method.addedToInterface",
+        "new": "method com.datastax.oss.driver.api.querybuilder.select.Select com.datastax.oss.driver.api.querybuilder.select.Select::orderByAnnOf(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<?>)",
+        "justification": "JAVA-3118: Add support for vector data type in Schema Builder, QueryBuilder"
+      },
+      {
+        "code": "java.method.addedToInterface",
+        "new": "method com.datastax.oss.driver.api.querybuilder.select.Select com.datastax.oss.driver.api.querybuilder.select.Select::orderByAnnOf(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<?>)",
+        "justification": "JAVA-3118: Add support for vector data type in Schema Builder, QueryBuilder"
       }
     ]
   }
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/Select.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/Select.java
index a22b45c35bd..159657989da 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/Select.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/Select.java
@@ -18,6 +18,7 @@
 package com.datastax.oss.driver.api.querybuilder.select;
 
 import com.datastax.oss.driver.api.core.CqlIdentifier;
+import com.datastax.oss.driver.api.core.data.CqlVector;
 import com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder;
 import com.datastax.oss.driver.api.querybuilder.BindMarker;
 import com.datastax.oss.driver.api.querybuilder.BuildableQuery;
@@ -146,6 +147,16 @@ default Select orderBy(@NonNull String columnName, @NonNull ClusteringOrder orde
     return orderBy(CqlIdentifier.fromCql(columnName), order);
   }
 
+  /**
+   * Shortcut for {@link #orderByAnnOf(CqlIdentifier, CqlVector)}, adding an ORDER BY ... ANN OF ...
+   * clause
+   */
+  @NonNull
+  Select orderByAnnOf(@NonNull String columnName, @NonNull CqlVector<?> ann);
+
+  /** Adds the ORDER BY ... ANN OF ... clause, usually used for vector search */
+  @NonNull
+  Select orderByAnnOf(@NonNull CqlIdentifier columnId, @NonNull CqlVector<?> ann);
   /**
    * Adds a LIMIT clause to this query with a literal value.
    *
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java b/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
index 86a2a07a3f2..5daf252a9eb 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
@@ -20,8 +20,10 @@
 import com.datastax.oss.driver.api.core.CqlIdentifier;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.cql.SimpleStatementBuilder;
+import com.datastax.oss.driver.api.core.data.CqlVector;
 import com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder;
 import com.datastax.oss.driver.api.querybuilder.BindMarker;
+import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
 import com.datastax.oss.driver.api.querybuilder.relation.Relation;
 import com.datastax.oss.driver.api.querybuilder.select.Select;
 import com.datastax.oss.driver.api.querybuilder.select.SelectFrom;
@@ -49,6 +51,7 @@ public class DefaultSelect implements SelectFrom, Select {
   private final ImmutableList<Relation> relations;
   private final ImmutableList<Selector> groupByClauses;
   private final ImmutableMap<CqlIdentifier, ClusteringOrder> orderings;
+  private final Ann ann;
   private final Object limit;
   private final Object perPartitionLimit;
   private final boolean allowsFiltering;
@@ -65,6 +68,7 @@ public DefaultSelect(@Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier ta
         ImmutableMap.of(),
         null,
         null,
+        null,
         false);
   }
 
@@ -74,6 +78,8 @@ public DefaultSelect(@Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier ta
    * @param selectors if it contains {@link AllSelector#INSTANCE}, that must be the only element.
    *     This isn't re-checked because methods that call this constructor internally already do it,
    *     make sure you do it yourself.
+   * @param ann Approximate nearest neighbor. ANN ordering does not support secondary ordering or
+   *     ASC order.
    */
   public DefaultSelect(
       @Nullable CqlIdentifier keyspace,
@@ -84,6 +90,7 @@ public DefaultSelect(
       @NonNull ImmutableList<Relation> relations,
       @NonNull ImmutableList<Selector> groupByClauses,
       @NonNull ImmutableMap<CqlIdentifier, ClusteringOrder> orderings,
+      @Nullable Ann ann,
       @Nullable Object limit,
       @Nullable Object perPartitionLimit,
       boolean allowsFiltering) {
@@ -94,6 +101,9 @@ public DefaultSelect(
             || (limit instanceof Integer && (Integer) limit > 0)
             || limit instanceof BindMarker,
         "limit must be a strictly positive integer or a bind marker");
+    Preconditions.checkArgument(
+        orderings.isEmpty() || ann == null, "ANN ordering does not support secondary ordering");
+    this.ann = ann;
     this.keyspace = keyspace;
     this.table = table;
     this.isJson = isJson;
@@ -117,6 +127,7 @@ public SelectFrom json() {
         relations,
         groupByClauses,
         orderings,
+        ann,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -134,6 +145,7 @@ public SelectFrom distinct() {
         relations,
         groupByClauses,
         orderings,
+        ann,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -193,6 +205,7 @@ public Select withSelectors(@NonNull ImmutableList<Selector> newSelectors) {
         relations,
         groupByClauses,
         orderings,
+        ann,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -221,6 +234,7 @@ public Select withRelations(@NonNull ImmutableList<Relation> newRelations) {
         newRelations,
         groupByClauses,
         orderings,
+        ann,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -249,6 +263,7 @@ public Select withGroupByClauses(@NonNull ImmutableList<Selector> newGroupByClau
         relations,
         newGroupByClauses,
         orderings,
+        ann,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -260,6 +275,18 @@ public Select orderBy(@NonNull CqlIdentifier columnId, @NonNull ClusteringOrder
     return withOrderings(ImmutableCollections.append(orderings, columnId, order));
   }
 
+  @NonNull
+  @Override
+  public Select orderByAnnOf(@NonNull String columnName, @NonNull CqlVector<?> ann) {
+    return withAnn(new Ann(CqlIdentifier.fromCql(columnName), ann));
+  }
+
+  @NonNull
+  @Override
+  public Select orderByAnnOf(@NonNull CqlIdentifier columnId, @NonNull CqlVector<?> ann) {
+    return withAnn(new Ann(columnId, ann));
+  }
+
   @NonNull
   @Override
   public Select orderByIds(@NonNull Map<CqlIdentifier, ClusteringOrder> newOrderings) {
@@ -277,6 +304,24 @@ public Select withOrderings(@NonNull ImmutableMap<CqlIdentifier, ClusteringOrder
         relations,
         groupByClauses,
         newOrderings,
+        ann,
+        limit,
+        perPartitionLimit,
+        allowsFiltering);
+  }
+
+  @NonNull
+  Select withAnn(@NonNull Ann ann) {
+    return new DefaultSelect(
+        keyspace,
+        table,
+        isJson,
+        isDistinct,
+        selectors,
+        relations,
+        groupByClauses,
+        orderings,
+        ann,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -295,6 +340,7 @@ public Select limit(int limit) {
         relations,
         groupByClauses,
         orderings,
+        ann,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -312,6 +358,7 @@ public Select limit(@Nullable BindMarker bindMarker) {
         relations,
         groupByClauses,
         orderings,
+        ann,
         bindMarker,
         perPartitionLimit,
         allowsFiltering);
@@ -331,6 +378,7 @@ public Select perPartitionLimit(int perPartitionLimit) {
         relations,
         groupByClauses,
         orderings,
+        ann,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -348,6 +396,7 @@ public Select perPartitionLimit(@Nullable BindMarker bindMarker) {
         relations,
         groupByClauses,
         orderings,
+        ann,
         limit,
         bindMarker,
         allowsFiltering);
@@ -365,6 +414,7 @@ public Select allowFiltering() {
         relations,
         groupByClauses,
         orderings,
+        ann,
         limit,
         perPartitionLimit,
         true);
@@ -391,15 +441,20 @@ public String asCql() {
     CqlHelper.append(relations, builder, " WHERE ", " AND ", null);
     CqlHelper.append(groupByClauses, builder, " GROUP BY ", ",", null);
 
-    boolean first = true;
-    for (Map.Entry<CqlIdentifier, ClusteringOrder> entry : orderings.entrySet()) {
-      if (first) {
-        builder.append(" ORDER BY ");
-        first = false;
-      } else {
-        builder.append(",");
+    if (ann != null) {
+      builder.append(" ORDER BY ").append(this.ann.columnId.asCql(true)).append(" ANN OF ");
+      QueryBuilder.literal(ann.vector).appendTo(builder);
+    } else {
+      boolean first = true;
+      for (Map.Entry<CqlIdentifier, ClusteringOrder> entry : orderings.entrySet()) {
+        if (first) {
+          builder.append(" ORDER BY ");
+          first = false;
+        } else {
+          builder.append(",");
+        }
+        builder.append(entry.getKey().asCql(true)).append(" ").append(entry.getValue().name());
       }
-      builder.append(entry.getKey().asCql(true)).append(" ").append(entry.getValue().name());
     }
 
     if (limit != null) {
@@ -499,6 +554,11 @@ public Object getLimit() {
     return limit;
   }
 
+  @Nullable
+  public Ann getAnn() {
+    return ann;
+  }
+
   @Nullable
   public Object getPerPartitionLimit() {
     return perPartitionLimit;
@@ -512,4 +572,14 @@ public boolean allowsFiltering() {
   public String toString() {
     return asCql();
   }
+
+  public static class Ann {
+    private final CqlVector<?> vector;
+    private final CqlIdentifier columnId;
+
+    private Ann(CqlIdentifier columnId, CqlVector<?> vector) {
+      this.vector = vector;
+      this.columnId = columnId;
+    }
+  }
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/delete/DeleteSelectorTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/delete/DeleteSelectorTest.java
index 23210971bc6..cce4cf51a10 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/delete/DeleteSelectorTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/delete/DeleteSelectorTest.java
@@ -22,6 +22,7 @@
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.deleteFrom;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
 
+import com.datastax.oss.driver.api.core.data.CqlVector;
 import org.junit.Test;
 
 public class DeleteSelectorTest {
@@ -34,6 +35,16 @@ public void should_generate_column_deletion() {
         .hasCql("DELETE v FROM ks.foo WHERE k=?");
   }
 
+  @Test
+  public void should_generate_vector_deletion() {
+    assertThat(
+            deleteFrom("foo")
+                .column("v")
+                .whereColumn("k")
+                .isEqualTo(literal(CqlVector.newInstance(0.1, 0.2))))
+        .hasCql("DELETE v FROM foo WHERE k=[0.1, 0.2]");
+  }
+
   @Test
   public void should_generate_field_deletion() {
     assertThat(
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/insert/RegularInsertTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/insert/RegularInsertTest.java
index 36133445b34..89c833ff1c6 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/insert/RegularInsertTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/insert/RegularInsertTest.java
@@ -23,6 +23,7 @@
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
 import static org.assertj.core.api.Assertions.catchThrowable;
 
+import com.datastax.oss.driver.api.core.data.CqlVector;
 import com.datastax.oss.driver.api.querybuilder.term.Term;
 import com.datastax.oss.driver.internal.querybuilder.insert.DefaultInsert;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
@@ -41,6 +42,12 @@ public void should_generate_column_assignments() {
         .hasCql("INSERT INTO foo (a,b) VALUES (?,?)");
   }
 
+  @Test
+  public void should_generate_vector_literals() {
+    assertThat(insertInto("foo").value("a", literal(CqlVector.newInstance(0.1, 0.2, 0.3))))
+        .hasCql("INSERT INTO foo (a) VALUES ([0.1, 0.2, 0.3])");
+  }
+
   @Test
   public void should_keep_last_assignment_if_column_listed_twice() {
     assertThat(
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/AlterTableTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/AlterTableTest.java
index 1567b0848cf..2c99b154b38 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/AlterTableTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/AlterTableTest.java
@@ -108,4 +108,10 @@ public void should_generate_alter_table_with_no_compression() {
     assertThat(alterTable("bar").withNoCompression())
         .hasCql("ALTER TABLE bar WITH compression={'sstable_compression':''}");
   }
+
+  @Test
+  public void should_generate_alter_table_with_vector() {
+    assertThat(alterTable("bar").alterColumn("v", DataTypes.vectorOf(DataTypes.FLOAT, 3)))
+        .hasCql("ALTER TABLE bar ALTER v TYPE vector<float, 3>");
+  }
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/AlterTypeTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/AlterTypeTest.java
index 2becb9338f9..14bec0a6ce3 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/AlterTypeTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/AlterTypeTest.java
@@ -53,4 +53,10 @@ public void should_generate_alter_table_with_rename_three_columns() {
     assertThat(alterType("bar").renameField("x", "y").renameField("u", "v").renameField("b", "a"))
         .hasCql("ALTER TYPE bar RENAME x TO y AND u TO v AND b TO a");
   }
+
+  @Test
+  public void should_generate_alter_type_with_vector() {
+    assertThat(alterType("foo", "bar").alterField("vec", DataTypes.vectorOf(DataTypes.FLOAT, 3)))
+        .hasCql("ALTER TYPE foo.bar ALTER vec TYPE vector<float, 3>");
+  }
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
index 7a5542c51f0..15cd12c75eb 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
@@ -314,4 +314,13 @@ public void should_generate_create_table_time_window_compaction() {
         .hasCql(
             "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compaction={'class':'TimeWindowCompactionStrategy','compaction_window_size':10,'compaction_window_unit':'DAYS','timestamp_resolution':'MICROSECONDS','unsafe_aggressive_sstable_expiration':false}");
   }
+
+  @Test
+  public void should_generate_vector_column() {
+    assertThat(
+            createTable("foo")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.vectorOf(DataTypes.FLOAT, 3)))
+        .hasCql("CREATE TABLE foo (k int PRIMARY KEY,v vector<float, 3>)");
+  }
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTypeTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTypeTest.java
index d881a0500cb..f7c15788a0f 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTypeTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTypeTest.java
@@ -83,4 +83,13 @@ public void should_create_type_with_collections() {
                 .withField("map", DataTypes.mapOf(DataTypes.INT, DataTypes.TEXT)))
         .hasCql("CREATE TYPE ks1.type (map map<int, text>)");
   }
+
+  @Test
+  public void should_create_type_with_vector() {
+    assertThat(
+            createType("ks1", "type")
+                .withField("c1", DataTypes.INT)
+                .withField("vec", DataTypes.vectorOf(DataTypes.FLOAT, 3)))
+        .hasCql("CREATE TYPE ks1.type (c1 int,vec vector<float, 3>)");
+  }
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectOrderingTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectOrderingTest.java
index ff27fde4f8f..a9c618e9559 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectOrderingTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectOrderingTest.java
@@ -23,6 +23,7 @@
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.selectFrom;
 
+import com.datastax.oss.driver.api.core.data.CqlVector;
 import com.datastax.oss.driver.api.querybuilder.relation.Relation;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import org.junit.Test;
@@ -74,4 +75,23 @@ public void should_replace_previous_ordering() {
                 .orderBy(ImmutableMap.of("c1", DESC, "c2", ASC)))
         .hasCql("SELECT * FROM foo WHERE k=1 ORDER BY c3 ASC,c1 DESC,c2 ASC");
   }
+
+  @Test
+  public void should_generate_ann_clause() {
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(Relation.column("k").isEqualTo(literal(1)))
+                .orderByAnnOf("c1", CqlVector.newInstance(0.1, 0.2, 0.3)))
+        .hasCql("SELECT * FROM foo WHERE k=1 ORDER BY c1 ANN OF [0.1, 0.2, 0.3]");
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void should_fail_when_provided_ann_with_other_orderings() {
+    selectFrom("foo")
+        .all()
+        .where(Relation.column("k").isEqualTo(literal(1)))
+        .orderBy("c1", ASC)
+        .orderByAnnOf("c2", CqlVector.newInstance(0.1, 0.2, 0.3));
+  }
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectSelectorTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectSelectorTest.java
index dc7cc98c6cc..7e03627d4b7 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectSelectorTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectSelectorTest.java
@@ -22,6 +22,7 @@
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.raw;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.selectFrom;
 
+import com.datastax.oss.driver.api.core.data.CqlVector;
 import com.datastax.oss.driver.api.core.type.DataTypes;
 import com.datastax.oss.driver.api.core.type.codec.CodecNotFoundException;
 import com.datastax.oss.driver.api.querybuilder.CharsetCodec;
@@ -230,6 +231,48 @@ public void should_generate_raw_selector() {
         .hasCql("SELECT bar,baz FROM foo");
   }
 
+  @Test
+  public void should_generate_similarity_functions() {
+    Select similarity_cosine_clause =
+        selectFrom("cycling", "comments_vs")
+            .column("comment")
+            .function(
+                "similarity_cosine",
+                Selector.column("comment_vector"),
+                literal(CqlVector.newInstance(0.2, 0.15, 0.3, 0.2, 0.05)))
+            .orderByAnnOf("comment_vector", CqlVector.newInstance(0.1, 0.15, 0.3, 0.12, 0.05))
+            .limit(1);
+    assertThat(similarity_cosine_clause)
+        .hasCql(
+            "SELECT comment,similarity_cosine(comment_vector,[0.2, 0.15, 0.3, 0.2, 0.05]) FROM cycling.comments_vs ORDER BY comment_vector ANN OF [0.1, 0.15, 0.3, 0.12, 0.05] LIMIT 1");
+
+    Select similarity_euclidean_clause =
+        selectFrom("cycling", "comments_vs")
+            .column("comment")
+            .function(
+                "similarity_euclidean",
+                Selector.column("comment_vector"),
+                literal(CqlVector.newInstance(0.2, 0.15, 0.3, 0.2, 0.05)))
+            .orderByAnnOf("comment_vector", CqlVector.newInstance(0.1, 0.15, 0.3, 0.12, 0.05))
+            .limit(1);
+    assertThat(similarity_euclidean_clause)
+        .hasCql(
+            "SELECT comment,similarity_euclidean(comment_vector,[0.2, 0.15, 0.3, 0.2, 0.05]) FROM cycling.comments_vs ORDER BY comment_vector ANN OF [0.1, 0.15, 0.3, 0.12, 0.05] LIMIT 1");
+
+    Select similarity_dot_product_clause =
+        selectFrom("cycling", "comments_vs")
+            .column("comment")
+            .function(
+                "similarity_dot_product",
+                Selector.column("comment_vector"),
+                literal(CqlVector.newInstance(0.2, 0.15, 0.3, 0.2, 0.05)))
+            .orderByAnnOf("comment_vector", CqlVector.newInstance(0.1, 0.15, 0.3, 0.12, 0.05))
+            .limit(1);
+    assertThat(similarity_dot_product_clause)
+        .hasCql(
+            "SELECT comment,similarity_dot_product(comment_vector,[0.2, 0.15, 0.3, 0.2, 0.05]) FROM cycling.comments_vs ORDER BY comment_vector ANN OF [0.1, 0.15, 0.3, 0.12, 0.05] LIMIT 1");
+  }
+
   @Test
   public void should_alias_selectors() {
     assertThat(selectFrom("foo").column("bar").as("baz")).hasCql("SELECT bar AS baz FROM foo");

From 8c1009959e988d9f7249151ad260f64aa6afed63 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Mon, 23 Dec 2024 08:20:42 +0100
Subject: [PATCH 055/126] Upgrade Guava to 33.3.1-jre

patch by Lukasz Antoniak; reviewed by Alexandre Dutra and Bret McGuire for CASSJAVA-53
---
 .../internal/core/cql/reactive/TestSubscriber.java     |  5 +++--
 guava-shaded/pom.xml                                   | 10 ++--------
 .../dse/driver/api/mapper/reactive/TestSubscriber.java |  6 +++++-
 pom.xml                                                |  2 +-
 4 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/core/src/test/java/com/datastax/dse/driver/internal/core/cql/reactive/TestSubscriber.java b/core/src/test/java/com/datastax/dse/driver/internal/core/cql/reactive/TestSubscriber.java
index aed7a4dfc8e..652155e5309 100644
--- a/core/src/test/java/com/datastax/dse/driver/internal/core/cql/reactive/TestSubscriber.java
+++ b/core/src/test/java/com/datastax/dse/driver/internal/core/cql/reactive/TestSubscriber.java
@@ -81,7 +81,8 @@ public List<T> getElements() {
   }
 
   public void awaitTermination() {
-    Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.MINUTES);
-    if (latch.getCount() > 0) fail("subscriber not terminated");
+    if (!Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.MINUTES)) {
+      fail("subscriber not terminated");
+    }
   }
 }
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 9854fcc48ba..f480f9258cc 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -45,14 +45,6 @@
           <groupId>com.google.errorprone</groupId>
           <artifactId>error_prone_annotations</artifactId>
         </exclusion>
-        <exclusion>
-          <groupId>com.google.j2objc</groupId>
-          <artifactId>j2objc-annotations</artifactId>
-        </exclusion>
-        <exclusion>
-          <groupId>org.codehaus.mojo</groupId>
-          <artifactId>animal-sniffer-annotations</artifactId>
-        </exclusion>
       </exclusions>
     </dependency>
     <dependency>
@@ -78,6 +70,8 @@
                 <includes>
                   <include>org.apache.cassandra:java-driver-guava-shaded</include>
                   <include>com.google.guava:guava</include>
+                  <include>com.google.guava:failureaccess</include>
+                  <include>com.google.j2objc:j2objc-annotations</include>
                 </includes>
               </artifactSet>
               <relocations>
diff --git a/mapper-runtime/src/test/java/com/datastax/dse/driver/api/mapper/reactive/TestSubscriber.java b/mapper-runtime/src/test/java/com/datastax/dse/driver/api/mapper/reactive/TestSubscriber.java
index 6f23cfca98a..6886b9a7622 100644
--- a/mapper-runtime/src/test/java/com/datastax/dse/driver/api/mapper/reactive/TestSubscriber.java
+++ b/mapper-runtime/src/test/java/com/datastax/dse/driver/api/mapper/reactive/TestSubscriber.java
@@ -17,6 +17,8 @@
  */
 package com.datastax.dse.driver.api.mapper.reactive;
 
+import static org.assertj.core.api.Fail.fail;
+
 import com.datastax.oss.driver.shaded.guava.common.util.concurrent.Uninterruptibles;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
@@ -70,6 +72,8 @@ public List<T> getElements() {
   }
 
   public void awaitTermination() {
-    Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.MINUTES);
+    if (!Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.MINUTES)) {
+      fail("subscriber not terminated");
+    }
   }
 }
diff --git a/pom.xml b/pom.xml
index 620cf1db4bb..c61e6485fd3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -114,7 +114,7 @@
         <!-- Version of Guava used in shaded module and for integration tests. -->
         <groupId>com.google.guava</groupId>
         <artifactId>guava</artifactId>
-        <version>25.1-jre</version>
+        <version>33.3.1-jre</version>
       </dependency>
       <dependency>
         <groupId>com.typesafe</groupId>

From 75a269d04d49630032be6afedae2ded0c4334e42 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Mon, 30 Dec 2024 07:18:06 +0100
Subject: [PATCH 056/126] Do not always cleanup Guava shaded module before
 packaging

---
 guava-shaded/pom.xml | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index f480f9258cc..6a22663e956 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -94,21 +94,6 @@
           </execution>
         </executions>
       </plugin>
-      <plugin>
-        <artifactId>maven-clean-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>clean-classes</id>
-            <phase>package</phase>
-            <goals>
-              <goal>clean</goal>
-            </goals>
-            <configuration>
-              <directory>${project.build.outputDirectory}</directory>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
       <plugin>
         <artifactId>maven-dependency-plugin</artifactId>
         <executions>

From 01671d99247bdc783c832c128a8570ba846875c4 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Fri, 10 Jan 2025 16:05:42 +0100
Subject: [PATCH 057/126] Revert "Do not always cleanup Guava shaded module
 before packaging"

This reverts commit 5be52ec1a8d014c81566180c731b828a591082da.
---
 guava-shaded/pom.xml | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 6a22663e956..f480f9258cc 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -94,6 +94,21 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <artifactId>maven-clean-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>clean-classes</id>
+            <phase>package</phase>
+            <goals>
+              <goal>clean</goal>
+            </goals>
+            <configuration>
+              <directory>${project.build.outputDirectory}</directory>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
       <plugin>
         <artifactId>maven-dependency-plugin</artifactId>
         <executions>

From 342e2dcf47afab238f357ac2afde65b079ce6b79 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Fri, 10 Jan 2025 16:16:26 +0100
Subject: [PATCH 058/126] Conditionally compile shaded Guava module

---
 guava-shaded/pom.xml | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index f480f9258cc..ca8f0161b04 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -56,6 +56,32 @@
   </dependencies>
   <build>
     <plugins>
+      <plugin>
+        <!--
+          Do not attempt to recompile the module if we are not running JVM 1.8.
+          Having additional Java source files and having to shade Guava will break
+          in CI environment, when we run 'mvn verify' on newer JVM and assume that
+          all classes have been compiled with JVM 1.8.
+        -->
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>build-helper-maven-plugin</artifactId>
+        <version>1.12</version>
+        <executions>
+          <execution>
+            <id>regex-property</id>
+            <goals>
+              <goal>regex-property</goal>
+            </goals>
+            <configuration>
+              <name>maven.main.skip</name>
+              <value>${java.version}</value>
+              <regex>^(?!1.8).+</regex>
+              <replacement>true</replacement>
+              <failIfNoMatch>false</failIfNoMatch>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
       <plugin>
         <artifactId>maven-shade-plugin</artifactId>
         <executions>
@@ -95,6 +121,12 @@
         </executions>
       </plugin>
       <plugin>
+        <!--
+          Cleaning up target directory is required, because module's Java source files
+          (e.g. LexicographicalComparatorHolderSubstitution) will be left with
+          their original Java package AND eventually shaded one. This plugin removes
+          the Java class from its unshaded package.
+        -->
         <artifactId>maven-clean-plugin</artifactId>
         <executions>
           <execution>

From 2e0c44c020819c928730e1aac812bf2f475d8256 Mon Sep 17 00:00:00 2001
From: SiyaoIsHiding <113857408+SiyaoIsHiding@users.noreply.github.com>
Date: Sun, 26 Jan 2025 22:38:52 +0800
Subject: [PATCH 059/126] JAVA-3143: Extend driver vector support to arbitrary
 subtypes and fix handling of variable length types (OSS C* 5.0)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

patch by Jane He; reviewed by Bret McGuire and João Reis
reference: https://github.com/apache/cassandra-java-driver/pull/1952
---
 core/revapi.json                              | 297 ++++++++++++++++++
 .../oss/driver/api/core/data/CqlVector.java   |  72 ++++-
 .../driver/api/core/data/GettableById.java    |   2 +-
 .../driver/api/core/data/GettableByIndex.java |   3 +-
 .../driver/api/core/data/GettableByName.java  |   2 +-
 .../driver/api/core/data/SettableById.java    |   2 +-
 .../driver/api/core/data/SettableByIndex.java |   2 +-
 .../driver/api/core/data/SettableByName.java  |   2 +-
 .../oss/driver/api/core/type/DataTypes.java   |  19 +-
 .../driver/api/core/type/codec/TypeCodec.java |   6 +
 .../api/core/type/codec/TypeCodecs.java       |   4 +-
 .../api/core/type/reflect/GenericType.java    |   6 +-
 .../parsing/DataTypeClassNameParser.java      |   8 +
 .../internal/core/type/DefaultVectorType.java |   2 +-
 .../internal/core/type/codec/BigIntCodec.java |   7 +
 .../core/type/codec/BooleanCodec.java         |   7 +
 .../internal/core/type/codec/DoubleCodec.java |   7 +
 .../internal/core/type/codec/FloatCodec.java  |   7 +
 .../internal/core/type/codec/IntCodec.java    |   7 +
 .../core/type/codec/TimestampCodec.java       |   7 +
 .../internal/core/type/codec/UuidCodec.java   |   7 +
 .../internal/core/type/codec/VectorCodec.java |  86 +++--
 .../extras/time/TimestampMillisCodec.java     |   7 +
 .../codec/registry/CachingCodecRegistry.java  |  12 +-
 .../internal/core/type/util/VIntCoding.java   |  77 ++++-
 .../driver/api/core/data/CqlVectorTest.java   | 167 +++++-----
 .../core/type/codec/VectorCodecTest.java      | 265 ++++++++++++----
 ...CachingCodecRegistryTestDataProviders.java |  20 ++
 .../core/type/util/VIntCodingTest.java        |  86 +++++
 .../oss/driver/core/data/DataTypeIT.java      |  38 ++-
 30 files changed, 1002 insertions(+), 232 deletions(-)
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/type/util/VIntCodingTest.java

diff --git a/core/revapi.json b/core/revapi.json
index 1c875895d6c..5aa46a3ccad 100644
--- a/core/revapi.json
+++ b/core/revapi.json
@@ -7089,6 +7089,303 @@
         "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValues(java.util.Map<java.lang.String, java.lang.Object>)",
         "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
         "justification": "Annotate mutating methods with @CheckReturnValue"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>===)",
+        "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
+        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
+        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeChanged",
+        "old": "method T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::get(int)",
+        "new": "method T com.datastax.oss.driver.api.core.data.CqlVector<T>::get(int)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method java.util.Iterator<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::iterator()",
+        "new": "method java.util.Iterator<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::iterator()",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeChanged",
+        "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(===V[]===)",
+        "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(===V[]===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(V[])",
+        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(V[])",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(V[])",
+        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(V[])",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(===java.util.List<V>===)",
+        "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(===java.util.List<V>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(java.util.List<V>)",
+        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(java.util.List<V>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(java.util.List<V>)",
+        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(java.util.List<V>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeChanged",
+        "old": "parameter T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::set(int, ===T===)",
+        "new": "parameter T com.datastax.oss.driver.api.core.data.CqlVector<T>::set(int, ===T===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeChanged",
+        "old": "method T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::set(int, T)",
+        "new": "method T com.datastax.oss.driver.api.core.data.CqlVector<T>::set(int, T)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method java.util.Spliterator<T> java.lang.Iterable<T>::spliterator() @ com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
+        "new": "method java.util.Spliterator<T> java.lang.Iterable<T>::spliterator() @ com.datastax.oss.driver.api.core.data.CqlVector<T>",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method java.util.stream.Stream<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::stream()",
+        "new": "method java.util.stream.Stream<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::stream()",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method com.datastax.oss.driver.api.core.data.CqlVector<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::subVector(int, int)",
+        "new": "method com.datastax.oss.driver.api.core.data.CqlVector<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::subVector(int, int)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.class.noLongerImplementsInterface",
+        "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
+        "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
+        "interface": "java.lang.Iterable<T extends java.lang.Number>",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
+        "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.class.superTypeTypeParametersChanged",
+        "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
+        "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
+        "oldSuperType": "java.lang.Iterable<T extends java.lang.Number>",
+        "newSuperType": "java.lang.Iterable<T>",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===java.lang.Class<ElementT>===)",
+        "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===java.lang.Class<ElementT>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, ===java.lang.Class<ElementT>===)",
+        "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, ===java.lang.Class<ElementT>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, ===java.lang.Class<ElementT>===)",
+        "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, ===java.lang.Class<ElementT>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
+        "new": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+        "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+        "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
+        "new": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+        "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+        "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===com.datastax.oss.driver.api.core.type.reflect.GenericType<T>===)",
+        "new": "parameter <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===com.datastax.oss.driver.api.core.type.reflect.GenericType<T>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
+        "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
+        "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.parameterTypeParameterChanged",
+        "old": "parameter <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===java.lang.Class<T>===)",
+        "new": "parameter <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===java.lang.Class<T>===)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.method.returnTypeTypeParametersChanged",
+        "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
+        "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.generics.formalTypeParameterChanged",
+        "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
+        "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
+        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
       }
     ]
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
index 911b6187f6d..8089d551750 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
@@ -18,11 +18,10 @@
 package com.datastax.oss.driver.api.core.data;
 
 import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
+import com.datastax.oss.driver.internal.core.type.codec.ParseUtils;
 import com.datastax.oss.driver.shaded.guava.common.base.Preconditions;
 import com.datastax.oss.driver.shaded.guava.common.base.Predicates;
-import com.datastax.oss.driver.shaded.guava.common.base.Splitter;
 import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
-import com.datastax.oss.driver.shaded.guava.common.collect.Streams;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.io.IOException;
 import java.io.InvalidObjectException;
@@ -35,7 +34,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
@@ -52,7 +50,7 @@
  * where possible we've tried to make the API of this class similar to the equivalent methods on
  * {@link List}.
  */
-public class CqlVector<T extends Number> implements Iterable<T>, Serializable {
+public class CqlVector<T> implements Iterable<T>, Serializable {
 
   /**
    * Create a new CqlVector containing the specified values.
@@ -60,7 +58,7 @@ public class CqlVector<T extends Number> implements Iterable<T>, Serializable {
    * @param vals the collection of values to wrap.
    * @return a CqlVector wrapping those values
    */
-  public static <V extends Number> CqlVector<V> newInstance(V... vals) {
+  public static <V> CqlVector<V> newInstance(V... vals) {
 
     // Note that Array.asList() guarantees the return of an array which implements RandomAccess
     return new CqlVector(Arrays.asList(vals));
@@ -73,29 +71,64 @@ public static <V extends Number> CqlVector<V> newInstance(V... vals) {
    * @param list the collection of values to wrap.
    * @return a CqlVector wrapping those values
    */
-  public static <V extends Number> CqlVector<V> newInstance(List<V> list) {
+  public static <V> CqlVector<V> newInstance(List<V> list) {
     Preconditions.checkArgument(list != null, "Input list should not be null");
     return new CqlVector(list);
   }
 
   /**
-   * Create a new CqlVector instance from the specified string representation. Note that this method
-   * is intended to mirror {@link #toString()}; passing this method the output from a <code>toString
-   * </code> call on some CqlVector should return a CqlVector that is equal to the origin instance.
+   * Create a new CqlVector instance from the specified string representation.
    *
    * @param str a String representation of a CqlVector
    * @param subtypeCodec
    * @return a new CqlVector built from the String representation
    */
-  public static <V extends Number> CqlVector<V> from(
-      @NonNull String str, @NonNull TypeCodec<V> subtypeCodec) {
+  public static <V> CqlVector<V> from(@NonNull String str, @NonNull TypeCodec<V> subtypeCodec) {
     Preconditions.checkArgument(str != null, "Cannot create CqlVector from null string");
     Preconditions.checkArgument(!str.isEmpty(), "Cannot create CqlVector from empty string");
-    ArrayList<V> vals =
-        Streams.stream(Splitter.on(", ").split(str.substring(1, str.length() - 1)))
-            .map(subtypeCodec::parse)
-            .collect(Collectors.toCollection(ArrayList::new));
-    return new CqlVector(vals);
+    if (str.equalsIgnoreCase("NULL")) return null;
+
+    int idx = ParseUtils.skipSpaces(str, 0);
+    if (str.charAt(idx++) != '[')
+      throw new IllegalArgumentException(
+          String.format(
+              "Cannot parse vector value from \"%s\", at character %d expecting '[' but got '%c'",
+              str, idx, str.charAt(idx)));
+
+    idx = ParseUtils.skipSpaces(str, idx);
+
+    if (str.charAt(idx) == ']') {
+      return new CqlVector<>(new ArrayList<>());
+    }
+
+    List<V> list = new ArrayList<>();
+    while (idx < str.length()) {
+      int n;
+      try {
+        n = ParseUtils.skipCQLValue(str, idx);
+      } catch (IllegalArgumentException e) {
+        throw new IllegalArgumentException(
+            String.format(
+                "Cannot parse vector value from \"%s\", invalid CQL value at character %d",
+                str, idx),
+            e);
+      }
+
+      list.add(subtypeCodec.parse(str.substring(idx, n)));
+      idx = n;
+
+      idx = ParseUtils.skipSpaces(str, idx);
+      if (str.charAt(idx) == ']') return new CqlVector<>(list);
+      if (str.charAt(idx++) != ',')
+        throw new IllegalArgumentException(
+            String.format(
+                "Cannot parse vector value from \"%s\", at character %d expecting ',' but got '%c'",
+                str, idx, str.charAt(idx)));
+
+      idx = ParseUtils.skipSpaces(str, idx);
+    }
+    throw new IllegalArgumentException(
+        String.format("Malformed vector value \"%s\", missing closing ']'", str));
   }
 
   private final List<T> list;
@@ -194,6 +227,11 @@ public int hashCode() {
     return Objects.hash(list);
   }
 
+  /**
+   * The string representation of the vector. Elements, like strings, may not be properly quoted.
+   *
+   * @return the string representation
+   */
   @Override
   public String toString() {
     return Iterables.toString(this.list);
@@ -205,7 +243,7 @@ public String toString() {
    *
    * @param <T> inner type of CqlVector, assume Number is always Serializable.
    */
-  private static class SerializationProxy<T extends Number> implements Serializable {
+  private static class SerializationProxy<T> implements Serializable {
 
     private static final long serialVersionUID = 1;
 
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java
index 0a24214b20a..8393bc9f758 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java
@@ -531,7 +531,7 @@ default CqlDuration getCqlDuration(@NonNull CqlIdentifier id) {
    * @throws IllegalArgumentException if the id is invalid.
    */
   @Nullable
-  default <ElementT extends Number> CqlVector<ElementT> getVector(
+  default <ElementT> CqlVector<ElementT> getVector(
       @NonNull CqlIdentifier id, @NonNull Class<ElementT> elementsClass) {
     return getVector(firstIndexOf(id), elementsClass);
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java
index 53541b0ac58..bb75bd9a2b4 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java
@@ -446,8 +446,7 @@ default CqlDuration getCqlDuration(int i) {
    * @throws IndexOutOfBoundsException if the index is invalid.
    */
   @Nullable
-  default <ElementT extends Number> CqlVector<ElementT> getVector(
-      int i, @NonNull Class<ElementT> elementsClass) {
+  default <ElementT> CqlVector<ElementT> getVector(int i, @NonNull Class<ElementT> elementsClass) {
     return get(i, GenericType.vectorOf(elementsClass));
   }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java
index ec3ee362ca8..b0a4660033b 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java
@@ -527,7 +527,7 @@ default CqlDuration getCqlDuration(@NonNull String name) {
    * @throws IllegalArgumentException if the name is invalid.
    */
   @Nullable
-  default <ElementT extends Number> CqlVector<ElementT> getVector(
+  default <ElementT> CqlVector<ElementT> getVector(
       @NonNull String name, @NonNull Class<ElementT> elementsClass) {
     return getVector(firstIndexOf(name), elementsClass);
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java
index 8452446205e..0f5e3cd9daa 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java
@@ -573,7 +573,7 @@ default SelfT setCqlDuration(@NonNull CqlIdentifier id, @Nullable CqlDuration v)
    */
   @NonNull
   @CheckReturnValue
-  default <ElementT extends Number> SelfT setVector(
+  default <ElementT> SelfT setVector(
       @NonNull CqlIdentifier id,
       @Nullable CqlVector<ElementT> v,
       @NonNull Class<ElementT> elementsClass) {
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java
index bb55db3adde..4ecdf647590 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java
@@ -425,7 +425,7 @@ default SelfT setCqlDuration(int i, @Nullable CqlDuration v) {
    */
   @NonNull
   @CheckReturnValue
-  default <ElementT extends Number> SelfT setVector(
+  default <ElementT> SelfT setVector(
       int i, @Nullable CqlVector<ElementT> v, @NonNull Class<ElementT> elementsClass) {
     return set(i, v, GenericType.vectorOf(elementsClass));
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java
index c25a7074373..afe9ba59f64 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java
@@ -572,7 +572,7 @@ default SelfT setCqlDuration(@NonNull String name, @Nullable CqlDuration v) {
    */
   @NonNull
   @CheckReturnValue
-  default <ElementT extends Number> SelfT setVector(
+  default <ElementT> SelfT setVector(
       @NonNull String name,
       @Nullable CqlVector<ElementT> v,
       @NonNull Class<ElementT> elementsClass) {
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/DataTypes.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/DataTypes.java
index 3a341eaa5aa..492fc121c71 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/type/DataTypes.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/type/DataTypes.java
@@ -27,12 +27,10 @@
 import com.datastax.oss.driver.internal.core.type.DefaultTupleType;
 import com.datastax.oss.driver.internal.core.type.DefaultVectorType;
 import com.datastax.oss.driver.internal.core.type.PrimitiveType;
-import com.datastax.oss.driver.shaded.guava.common.base.Splitter;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
 import com.datastax.oss.protocol.internal.ProtocolConstants;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.util.Arrays;
-import java.util.List;
 
 /** Constants and factory methods to obtain data type instances. */
 public class DataTypes {
@@ -59,7 +57,6 @@ public class DataTypes {
   public static final DataType DURATION = new PrimitiveType(ProtocolConstants.DataType.DURATION);
 
   private static final DataTypeClassNameParser classNameParser = new DataTypeClassNameParser();
-  private static final Splitter paramSplitter = Splitter.on(',').trimResults();
 
   @NonNull
   public static DataType custom(@NonNull String className) {
@@ -68,20 +65,8 @@ public static DataType custom(@NonNull String className) {
     if (className.equals("org.apache.cassandra.db.marshal.DurationType")) return DURATION;
 
     /* Vector support is currently implemented as a custom type but is also parameterized */
-    if (className.startsWith(DefaultVectorType.VECTOR_CLASS_NAME)) {
-      List<String> params =
-          paramSplitter.splitToList(
-              className.substring(
-                  DefaultVectorType.VECTOR_CLASS_NAME.length() + 1, className.length() - 1));
-      DataType subType = classNameParser.parse(params.get(0), AttachmentPoint.NONE);
-      int dimensions = Integer.parseInt(params.get(1));
-      if (dimensions <= 0) {
-        throw new IllegalArgumentException(
-            String.format(
-                "Request to create vector of size %d, size must be positive", dimensions));
-      }
-      return new DefaultVectorType(subType, dimensions);
-    }
+    if (className.startsWith(DefaultVectorType.VECTOR_CLASS_NAME))
+      return classNameParser.parse(className, AttachmentPoint.NONE);
     return new DefaultCustomType(className);
   }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodec.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodec.java
index 05ae3980823..d6afbe0380a 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodec.java
@@ -28,6 +28,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
+import java.util.Optional;
 
 /**
  * Manages the two-way conversion between a CQL type and a Java type.
@@ -234,4 +235,9 @@ default boolean accepts(@NonNull DataType cqlType) {
    */
   @Nullable
   JavaTypeT parse(@Nullable String value);
+
+  @NonNull
+  default Optional<Integer> serializedSize() {
+    return Optional.empty();
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java
index 9f2fd5cc69e..68f1b07b106 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java
@@ -210,13 +210,13 @@ public static TypeCodec<TupleValue> tupleOf(@NonNull TupleType cqlType) {
     return new TupleCodec(cqlType);
   }
 
-  public static <SubtypeT extends Number> TypeCodec<CqlVector<SubtypeT>> vectorOf(
+  public static <SubtypeT> TypeCodec<CqlVector<SubtypeT>> vectorOf(
       @NonNull VectorType type, @NonNull TypeCodec<SubtypeT> subtypeCodec) {
     return new VectorCodec(
         DataTypes.vectorOf(subtypeCodec.getCqlType(), type.getDimensions()), subtypeCodec);
   }
 
-  public static <SubtypeT extends Number> TypeCodec<CqlVector<SubtypeT>> vectorOf(
+  public static <SubtypeT> TypeCodec<CqlVector<SubtypeT>> vectorOf(
       int dimensions, @NonNull TypeCodec<SubtypeT> subtypeCodec) {
     return new VectorCodec(DataTypes.vectorOf(subtypeCodec.getCqlType(), dimensions), subtypeCodec);
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java
index c6482d4f4d1..d22b6f1bfaf 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java
@@ -151,8 +151,7 @@ public static <T> GenericType<Set<T>> setOf(@NonNull GenericType<T> elementType)
   }
 
   @NonNull
-  public static <T extends Number> GenericType<CqlVector<T>> vectorOf(
-      @NonNull Class<T> elementType) {
+  public static <T> GenericType<CqlVector<T>> vectorOf(@NonNull Class<T> elementType) {
     TypeToken<CqlVector<T>> token =
         new TypeToken<CqlVector<T>>() {}.where(
             new TypeParameter<T>() {}, TypeToken.of(elementType));
@@ -160,8 +159,7 @@ public static <T extends Number> GenericType<CqlVector<T>> vectorOf(
   }
 
   @NonNull
-  public static <T extends Number> GenericType<CqlVector<T>> vectorOf(
-      @NonNull GenericType<T> elementType) {
+  public static <T> GenericType<CqlVector<T>> vectorOf(@NonNull GenericType<T> elementType) {
     TypeToken<CqlVector<T>> token =
         new TypeToken<CqlVector<T>>() {}.where(new TypeParameter<T>() {}, elementType.token);
     return new GenericType<>(token);
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java
index fd6f1a4bd51..bf252d0bc57 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java
@@ -34,6 +34,7 @@
 import com.datastax.oss.protocol.internal.util.Bytes;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -164,6 +165,13 @@ private DataType parse(
       return new DefaultTupleType(componentTypesBuilder.build(), attachmentPoint);
     }
 
+    if (next.startsWith("org.apache.cassandra.db.marshal.VectorType")) {
+      Iterator<String> rawTypes = parser.getTypeParameters().iterator();
+      DataType subtype = parse(rawTypes.next(), userTypes, attachmentPoint, logPrefix);
+      int dimensions = Integer.parseInt(rawTypes.next());
+      return DataTypes.vectorOf(subtype, dimensions);
+    }
+
     DataType type = NATIVE_TYPES_BY_CLASS_NAME.get(next);
     return type == null ? DataTypes.custom(toParse) : type;
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
index c9180d44edc..0b1ced94769 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
@@ -78,7 +78,7 @@ public boolean equals(Object o) {
 
   @Override
   public int hashCode() {
-    return Objects.hash(super.hashCode(), subtype, dimensions);
+    return Objects.hash(DefaultVectorType.class, subtype, dimensions);
   }
 
   @Override
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BigIntCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BigIntCodec.java
index 2b3b8255cc1..8496da17fa6 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BigIntCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BigIntCodec.java
@@ -25,6 +25,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
+import java.util.Optional;
 import net.jcip.annotations.ThreadSafe;
 
 @ThreadSafe
@@ -90,4 +91,10 @@ public Long parse(@Nullable String value) {
           String.format("Cannot parse 64-bits long value from \"%s\"", value));
     }
   }
+
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return Optional.of(8);
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BooleanCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BooleanCodec.java
index 7a982a9e6ca..af388982be9 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BooleanCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BooleanCodec.java
@@ -25,6 +25,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
+import java.util.Optional;
 import net.jcip.annotations.ThreadSafe;
 
 @ThreadSafe
@@ -98,4 +99,10 @@ public Boolean parse(@Nullable String value) {
           String.format("Cannot parse boolean value from \"%s\"", value));
     }
   }
+
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return Optional.of(1);
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/DoubleCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/DoubleCodec.java
index 28eff6f9463..b01847517d9 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/DoubleCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/DoubleCodec.java
@@ -25,6 +25,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
+import java.util.Optional;
 import net.jcip.annotations.ThreadSafe;
 
 @ThreadSafe
@@ -90,4 +91,10 @@ public Double parse(@Nullable String value) {
           String.format("Cannot parse 64-bits double value from \"%s\"", value));
     }
   }
+
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return Optional.of(8);
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/FloatCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/FloatCodec.java
index 11786dbc77d..fd851edfad3 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/FloatCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/FloatCodec.java
@@ -25,6 +25,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
+import java.util.Optional;
 import net.jcip.annotations.ThreadSafe;
 
 @ThreadSafe
@@ -90,4 +91,10 @@ public Float parse(@Nullable String value) {
           String.format("Cannot parse 32-bits float value from \"%s\"", value));
     }
   }
+
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return Optional.of(4);
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/IntCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/IntCodec.java
index e5bb530ba79..b11b164a445 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/IntCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/IntCodec.java
@@ -25,6 +25,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
+import java.util.Optional;
 import net.jcip.annotations.ThreadSafe;
 
 @ThreadSafe
@@ -90,4 +91,10 @@ public Integer parse(@Nullable String value) {
           String.format("Cannot parse 32-bits int value from \"%s\"", value));
     }
   }
+
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return Optional.of(4);
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/TimestampCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/TimestampCodec.java
index eeba3c7c66c..964f774c8d9 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/TimestampCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/TimestampCodec.java
@@ -33,6 +33,7 @@
 import java.time.Instant;
 import java.time.ZoneId;
 import java.util.Date;
+import java.util.Optional;
 import java.util.TimeZone;
 import net.jcip.annotations.ThreadSafe;
 
@@ -293,4 +294,10 @@ public Instant parse(@Nullable String value) {
           String.format("Cannot parse timestamp value from \"%s\"", value));
     }
   }
+
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return Optional.of(8);
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UuidCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UuidCodec.java
index 57feac4ae7e..cc5f48dbe52 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UuidCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UuidCodec.java
@@ -25,6 +25,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
+import java.util.Optional;
 import java.util.UUID;
 import net.jcip.annotations.ThreadSafe;
 
@@ -95,4 +96,10 @@ public UUID parse(@Nullable String value) {
           String.format("Cannot parse UUID value from \"%s\"", value), e);
     }
   }
+
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return Optional.of(16);
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
index 2c4d2200b13..1f8ce1a7166 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
@@ -24,7 +24,7 @@
 import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
 import com.datastax.oss.driver.api.core.type.reflect.GenericType;
 import com.datastax.oss.driver.internal.core.type.DefaultVectorType;
-import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
+import com.datastax.oss.driver.internal.core.type.util.VIntCoding;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.ByteBuffer;
@@ -32,8 +32,10 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
-public class VectorCodec<SubtypeT extends Number> implements TypeCodec<CqlVector<SubtypeT>> {
+public class VectorCodec<SubtypeT> implements TypeCodec<CqlVector<SubtypeT>> {
 
   private final VectorType cqlType;
   private final GenericType<CqlVector<SubtypeT>> javaType;
@@ -55,6 +57,14 @@ public GenericType<CqlVector<SubtypeT>> getJavaType() {
     return this.javaType;
   }
 
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return subtypeCodec.serializedSize().isPresent()
+        ? Optional.of(subtypeCodec.serializedSize().get() * cqlType.getDimensions())
+        : Optional.empty();
+  }
+
   @NonNull
   @Override
   public DataType getCqlType() {
@@ -65,6 +75,7 @@ public DataType getCqlType() {
   @Override
   public ByteBuffer encode(
       @Nullable CqlVector<SubtypeT> value, @NonNull ProtocolVersion protocolVersion) {
+    boolean isVarSized = !subtypeCodec.serializedSize().isPresent();
     if (value == null || cqlType.getDimensions() <= 0) {
       return null;
     }
@@ -92,14 +103,28 @@ public ByteBuffer encode(
       if (valueBuff == null) {
         throw new NullPointerException("Vector elements cannot encode to CQL NULL");
       }
-      allValueBuffsSize += valueBuff.limit();
+      int elementSize = valueBuff.limit();
+      if (isVarSized) {
+        allValueBuffsSize += VIntCoding.computeVIntSize(elementSize);
+      }
+      allValueBuffsSize += elementSize;
       valueBuff.rewind();
       valueBuffs[i] = valueBuff;
     }
+    // if too many elements, throw
+    if (values.hasNext()) {
+      throw new IllegalArgumentException(
+          String.format(
+              "Too many elements; must provide elements for %d dimensions",
+              cqlType.getDimensions()));
+    }
     /* Since we already did an early return for <= 0 dimensions above */
     assert valueBuffs.length > 0;
     ByteBuffer rv = ByteBuffer.allocate(allValueBuffsSize);
     for (int i = 0; i < cqlType.getDimensions(); ++i) {
+      if (isVarSized) {
+        VIntCoding.writeUnsignedVInt32(valueBuffs[i].remaining(), rv);
+      }
       rv.put(valueBuffs[i]);
     }
     rv.flip();
@@ -114,39 +139,58 @@ public CqlVector<SubtypeT> decode(
       return null;
     }
 
-    /* Determine element size by dividing count of remaining bytes by number of elements.  This should have a remainder
-    of zero if we assume all elements are of uniform size (which is really a terrible assumption).
-
-    TODO: We should probably tweak serialization format for vectors if we're going to allow them for arbitrary subtypes.
-     Elements should at least precede themselves with their size (along the lines of what lists do). */
-    int elementSize = Math.floorDiv(bytes.remaining(), cqlType.getDimensions());
-    if (!(bytes.remaining() % cqlType.getDimensions() == 0)) {
-      throw new IllegalArgumentException(
-          String.format(
-              "Expected elements of uniform size, observed %d elements with total bytes %d",
-              cqlType.getDimensions(), bytes.remaining()));
-    }
-
+    // Upfront check for fixed-size types only
+    subtypeCodec
+        .serializedSize()
+        .ifPresent(
+            (fixed_size) -> {
+              if (bytes.remaining() != cqlType.getDimensions() * fixed_size) {
+                throw new IllegalArgumentException(
+                    String.format(
+                        "Expected elements of uniform size, observed %d elements with total bytes %d",
+                        cqlType.getDimensions(), bytes.remaining()));
+              }
+            });
+    ;
     ByteBuffer slice = bytes.slice();
     List<SubtypeT> rv = new ArrayList<SubtypeT>(cqlType.getDimensions());
     for (int i = 0; i < cqlType.getDimensions(); ++i) {
-      // Set the limit for the current element
+
+      int size =
+          subtypeCodec
+              .serializedSize()
+              .orElseGet(() -> VIntCoding.getUnsignedVInt32(slice, slice.position()));
+      // If we aren't dealing with a fixed-size type we need to move the current slice position
+      // beyond the vint-encoded size of the current element.  Ideally this would be
+      // serializedSize().ifNotPresent(Consumer) but the Optional API isn't doing us any favors
+      // there.
+      if (!subtypeCodec.serializedSize().isPresent())
+        slice.position(slice.position() + VIntCoding.computeUnsignedVIntSize(size));
       int originalPosition = slice.position();
-      slice.limit(originalPosition + elementSize);
+      slice.limit(originalPosition + size);
       rv.add(this.subtypeCodec.decode(slice, protocolVersion));
       // Move to the start of the next element
-      slice.position(originalPosition + elementSize);
+      slice.position(originalPosition + size);
       // Reset the limit to the end of the buffer
       slice.limit(slice.capacity());
     }
 
+    // if too many elements, throw
+    if (slice.hasRemaining()) {
+      throw new IllegalArgumentException(
+          String.format(
+              "Too many elements; must provide elements for %d dimensions",
+              cqlType.getDimensions()));
+    }
+
     return CqlVector.newInstance(rv);
   }
 
   @NonNull
   @Override
-  public String format(@Nullable CqlVector<SubtypeT> value) {
-    return value == null ? "NULL" : Iterables.toString(value);
+  public String format(CqlVector<SubtypeT> value) {
+    if (value == null) return "NULL";
+    return value.stream().map(subtypeCodec::format).collect(Collectors.joining(", ", "[", "]"));
   }
 
   @Nullable
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/extras/time/TimestampMillisCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/extras/time/TimestampMillisCodec.java
index a15495a432d..12e3e839d2a 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/extras/time/TimestampMillisCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/extras/time/TimestampMillisCodec.java
@@ -31,6 +31,7 @@
 import java.time.Instant;
 import java.time.ZoneId;
 import java.util.Objects;
+import java.util.Optional;
 import net.jcip.annotations.Immutable;
 
 /**
@@ -114,4 +115,10 @@ public String format(@Nullable Long value) {
     Instant instant = value == null ? null : Instant.ofEpochMilli(value);
     return timestampCodec.format(instant);
   }
+
+  @NonNull
+  @Override
+  public Optional<Integer> serializedSize() {
+    return Optional.of(8);
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java
index 495d6227d93..3af5a30ba27 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java
@@ -394,10 +394,9 @@ protected GenericType<?> inspectType(@NonNull Object value, @Nullable DataType c
               "Can't infer vector codec because the first element is null "
                   + "(note that CQL does not allow null values in collections)");
         }
-        GenericType<? extends Number> elementType =
-            (GenericType<? extends Number>)
-                inspectType(
-                    firstElement, cqlType == null ? null : ((VectorType) cqlType).getElementType());
+        GenericType<?> elementType =
+            inspectType(
+                firstElement, cqlType == null ? null : ((VectorType) cqlType).getElementType());
         return GenericType.vectorOf(elementType);
       }
     } else {
@@ -421,8 +420,7 @@ protected GenericType<?> inferJavaTypeFromCqlType(@NonNull DataType cqlType) {
           inferJavaTypeFromCqlType(keyType), inferJavaTypeFromCqlType(valueType));
     } else if (cqlType instanceof VectorType) {
       DataType elementType = ((VectorType) cqlType).getElementType();
-      GenericType<? extends Number> numberType =
-          (GenericType<? extends Number>) inferJavaTypeFromCqlType(elementType);
+      GenericType<?> numberType = inferJavaTypeFromCqlType(elementType);
       return GenericType.vectorOf(numberType);
     }
     switch (cqlType.getProtocolCode()) {
@@ -657,7 +655,7 @@ protected TypeCodec<?> createCodec(
         /* For a vector type we'll always get back an instance of TypeCodec<? extends Number> due to the
          * type of CqlVector... but getElementCodecForCqlAndJavaType() is a generalized function that can't
          * return this more precise type.  Thus the cast here. */
-        TypeCodec<? extends Number> elementCodec =
+        TypeCodec<?> elementCodec =
             uncheckedCast(getElementCodecForCqlAndJavaType(vectorType, token, isJavaCovariant));
         return TypeCodecs.vectorOf(vectorType, elementCodec);
       } else if (cqlType instanceof CustomType
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/util/VIntCoding.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/util/VIntCoding.java
index 5ee375a81e5..552f84f2ae1 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/util/VIntCoding.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/util/VIntCoding.java
@@ -49,6 +49,7 @@
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
+import java.nio.ByteBuffer;
 
 /**
  * Variable length encoding inspired from Google <a
@@ -174,10 +175,84 @@ public static int computeVIntSize(final long param) {
   }
 
   /** Compute the number of bytes that would be needed to encode an unsigned varint. */
-  private static int computeUnsignedVIntSize(final long value) {
+  public static int computeUnsignedVIntSize(final long value) {
     int magnitude =
         Long.numberOfLeadingZeros(
             value | 1); // | with 1 to ensure magnitude <= 63, so (63 - 1) / 7 <= 8
     return (639 - magnitude * 9) >> 6;
   }
+
+  public static void writeUnsignedVInt32(int value, ByteBuffer output) {
+    writeUnsignedVInt((long) value, output);
+  }
+
+  public static void writeUnsignedVInt(long value, ByteBuffer output) {
+    int size = VIntCoding.computeUnsignedVIntSize(value);
+    if (size == 1) {
+      output.put((byte) value);
+      return;
+    }
+
+    output.put(VIntCoding.encodeVInt(value, size), 0, size);
+  }
+
+  /**
+   * Read up to a 32-bit integer back, using the unsigned (no zigzag) encoding.
+   *
+   * <p>Note this method is the same as {@link #readUnsignedVInt(DataInput)}, except that we do
+   * *not* block if there are not enough bytes in the buffer to reconstruct the value.
+   *
+   * @throws VIntOutOfRangeException If the vint doesn't fit into a 32-bit integer
+   */
+  public static int getUnsignedVInt32(ByteBuffer input, int readerIndex) {
+    return checkedCast(getUnsignedVInt(input, readerIndex));
+  }
+
+  public static long getUnsignedVInt(ByteBuffer input, int readerIndex) {
+    return getUnsignedVInt(input, readerIndex, input.limit());
+  }
+
+  public static long getUnsignedVInt(ByteBuffer input, int readerIndex, int readerLimit) {
+    if (readerIndex < 0)
+      throw new IllegalArgumentException(
+          "Reader index should be non-negative, but was " + readerIndex);
+
+    if (readerIndex >= readerLimit) return -1;
+
+    int firstByte = input.get(readerIndex++);
+
+    // Bail out early if this is one byte, necessary or it fails later
+    if (firstByte >= 0) return firstByte;
+
+    int size = numberOfExtraBytesToRead(firstByte);
+    if (readerIndex + size > readerLimit) return -1;
+
+    long retval = firstByte & firstByteValueMask(size);
+    for (int ii = 0; ii < size; ii++) {
+      byte b = input.get(readerIndex++);
+      retval <<= 8;
+      retval |= b & 0xff;
+    }
+
+    return retval;
+  }
+
+  public static int checkedCast(long value) {
+    int result = (int) value;
+    if ((long) result != value) throw new VIntOutOfRangeException(value);
+    return result;
+  }
+
+  /**
+   * Throw when attempting to decode a vint and the output type doesn't have enough space to fit the
+   * value that was decoded
+   */
+  public static class VIntOutOfRangeException extends RuntimeException {
+    public final long value;
+
+    private VIntOutOfRangeException(long value) {
+      super(value + " is out of range for a 32-bit integer");
+      this.value = value;
+    }
+  }
 }
diff --git a/core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java b/core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java
index 90f4cc6e776..3e0872cb946 100644
--- a/core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java
@@ -23,56 +23,60 @@
 
 import com.datastax.oss.driver.api.core.type.codec.TypeCodecs;
 import com.datastax.oss.driver.internal.SerializationHelper;
-import com.datastax.oss.driver.shaded.guava.common.collect.Iterators;
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import com.tngtech.java.junit.dataprovider.UseDataProvider;
 import java.io.ByteArrayInputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectStreamException;
+import java.time.LocalTime;
 import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 import java.util.stream.Collectors;
 import org.apache.commons.codec.DecoderException;
 import org.apache.commons.codec.binary.Hex;
 import org.assertj.core.util.Lists;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 
+@RunWith(DataProviderRunner.class)
 public class CqlVectorTest {
 
-  private static final Float[] VECTOR_ARGS = {1.0f, 2.5f};
-
-  private void validate_built_vector(CqlVector<Float> vec) {
+  @DataProvider
+  public static Object[][] dataProvider() {
+    return new Object[][] {
+      {new Float[] {1.0f, 2.5f}},
+      {new LocalTime[] {LocalTime.of(1, 2), LocalTime.of(3, 4)}},
+      {new List[] {Arrays.asList(1, 2), Arrays.asList(3, 4)}},
+      {new CqlVector[] {CqlVector.newInstance("a", "bc"), CqlVector.newInstance("d", "ef")}}
+    };
+  }
 
+  private void validate_built_vector(CqlVector<?> vec, Object[] expectedVals) {
     assertThat(vec.size()).isEqualTo(2);
     assertThat(vec.isEmpty()).isFalse();
-    assertThat(vec.get(0)).isEqualTo(VECTOR_ARGS[0]);
-    assertThat(vec.get(1)).isEqualTo(VECTOR_ARGS[1]);
+    assertThat(vec.get(0)).isEqualTo(expectedVals[0]);
+    assertThat(vec.get(1)).isEqualTo(expectedVals[1]);
   }
 
+  @UseDataProvider("dataProvider")
   @Test
-  public void should_build_vector_from_elements() {
-
-    validate_built_vector(CqlVector.newInstance(VECTOR_ARGS));
+  public void should_build_vector_from_elements(Object[] vals) {
+    validate_built_vector(CqlVector.newInstance(vals), vals);
   }
 
   @Test
-  public void should_build_vector_from_list() {
-
-    validate_built_vector(CqlVector.newInstance(Lists.newArrayList(VECTOR_ARGS)));
-  }
-
-  @Test
-  public void should_build_vector_from_tostring_output() {
-
-    CqlVector<Float> vector1 = CqlVector.newInstance(VECTOR_ARGS);
-    CqlVector<Float> vector2 = CqlVector.from(vector1.toString(), TypeCodecs.FLOAT);
-    assertThat(vector2).isEqualTo(vector1);
+  @UseDataProvider("dataProvider")
+  public void should_build_vector_from_list(Object[] vals) {
+    validate_built_vector(CqlVector.newInstance(Lists.newArrayList(vals)), vals);
   }
 
   @Test
   public void should_throw_from_null_string() {
-
     assertThatThrownBy(
             () -> {
               CqlVector.from(null, TypeCodecs.FLOAT);
@@ -116,101 +120,97 @@ public void should_throw_when_building_with_nulls() {
 
   @Test
   public void should_build_empty_vector() {
-
     CqlVector<Float> vector = CqlVector.newInstance();
     assertThat(vector.isEmpty()).isTrue();
     assertThat(vector.size()).isEqualTo(0);
   }
 
   @Test
-  public void should_behave_mostly_like_a_list() {
-
-    CqlVector<Float> vector = CqlVector.newInstance(VECTOR_ARGS);
-    assertThat(vector.get(0)).isEqualTo(VECTOR_ARGS[0]);
-    Float newVal = VECTOR_ARGS[0] * 2;
-    vector.set(0, newVal);
-    assertThat(vector.get(0)).isEqualTo(newVal);
+  @UseDataProvider("dataProvider")
+  public <T> void should_behave_mostly_like_a_list(T[] vals) {
+    T[] theArray = Arrays.copyOf(vals, vals.length);
+    CqlVector<T> vector = CqlVector.newInstance(theArray);
+    assertThat(vector.get(0)).isEqualTo(theArray[0]);
+    vector.set(0, theArray[1]);
+    assertThat(vector.get(0)).isEqualTo(theArray[1]);
     assertThat(vector.isEmpty()).isFalse();
     assertThat(vector.size()).isEqualTo(2);
-    assertThat(Iterators.toArray(vector.iterator(), Float.class)).isEqualTo(VECTOR_ARGS);
+    Iterator<?> iterator = vector.iterator();
+    assertThat(iterator.next()).isEqualTo(theArray[1]);
+    assertThat(iterator.next()).isEqualTo(theArray[1]);
   }
 
   @Test
-  public void should_play_nicely_with_streams() {
-
-    CqlVector<Float> vector = CqlVector.newInstance(VECTOR_ARGS);
-    List<Float> results =
+  @UseDataProvider("dataProvider")
+  public <T> void should_play_nicely_with_streams(T[] vals) {
+    CqlVector<T> vector = CqlVector.newInstance(vals);
+    List<String> results =
         vector.stream()
-            .map((f) -> f * 2)
-            .collect(Collectors.toCollection(() -> new ArrayList<Float>()));
+            .map(Object::toString)
+            .collect(Collectors.toCollection(() -> new ArrayList<String>()));
     for (int i = 0; i < vector.size(); ++i) {
-      assertThat(results.get(i)).isEqualTo(vector.get(i) * 2);
+      assertThat(results.get(i)).isEqualTo(vector.get(i).toString());
     }
   }
 
   @Test
-  public void should_reflect_changes_to_mutable_list() {
-
-    List<Float> theList = Lists.newArrayList(1.1f, 2.2f, 3.3f);
-    CqlVector<Float> vector = CqlVector.newInstance(theList);
-    assertThat(vector.size()).isEqualTo(3);
-    assertThat(vector.get(2)).isEqualTo(3.3f);
-
-    float newVal1 = 4.4f;
-    theList.set(2, newVal1);
-    assertThat(vector.size()).isEqualTo(3);
-    assertThat(vector.get(2)).isEqualTo(newVal1);
+  @UseDataProvider("dataProvider")
+  public <T> void should_reflect_changes_to_mutable_list(T[] vals) {
+    List<T> theList = Lists.newArrayList(vals);
+    CqlVector<T> vector = CqlVector.newInstance(theList);
+    assertThat(vector.size()).isEqualTo(2);
+    assertThat(vector.get(1)).isEqualTo(vals[1]);
 
-    float newVal2 = 5.5f;
-    theList.add(newVal2);
-    assertThat(vector.size()).isEqualTo(4);
-    assertThat(vector.get(3)).isEqualTo(newVal2);
+    T newVal = vals[0];
+    theList.set(1, newVal);
+    assertThat(vector.size()).isEqualTo(2);
+    assertThat(vector.get(1)).isEqualTo(newVal);
   }
 
   @Test
-  public void should_reflect_changes_to_array() {
-
-    Float[] theArray = new Float[] {1.1f, 2.2f, 3.3f};
-    CqlVector<Float> vector = CqlVector.newInstance(theArray);
-    assertThat(vector.size()).isEqualTo(3);
-    assertThat(vector.get(2)).isEqualTo(3.3f);
+  @UseDataProvider("dataProvider")
+  public <T> void should_reflect_changes_to_array(T[] vals) {
+    T[] theArray = Arrays.copyOf(vals, vals.length);
+    CqlVector<T> vector = CqlVector.newInstance(theArray);
+    assertThat(vector.size()).isEqualTo(2);
+    assertThat(vector.get(1)).isEqualTo(theArray[1]);
 
-    float newVal1 = 4.4f;
-    theArray[2] = newVal1;
-    assertThat(vector.size()).isEqualTo(3);
-    assertThat(vector.get(2)).isEqualTo(newVal1);
+    T newVal = theArray[0];
+    theArray[1] = newVal;
+    assertThat(vector.size()).isEqualTo(2);
+    assertThat(vector.get(1)).isEqualTo(newVal);
   }
 
   @Test
-  public void should_correctly_compare_vectors() {
-
-    Float[] args = VECTOR_ARGS.clone();
-    CqlVector<Float> vector1 = CqlVector.newInstance(args);
-    CqlVector<Float> vector2 = CqlVector.newInstance(args);
-    CqlVector<Float> vector3 = CqlVector.newInstance(Lists.newArrayList(args));
+  @UseDataProvider("dataProvider")
+  public <T> void should_correctly_compare_vectors(T[] vals) {
+    CqlVector<T> vector1 = CqlVector.newInstance(vals);
+    CqlVector<T> vector2 = CqlVector.newInstance(vals);
+    CqlVector<T> vector3 = CqlVector.newInstance(Lists.newArrayList(vals));
     assertThat(vector1).isNotSameAs(vector2);
     assertThat(vector1).isEqualTo(vector2);
     assertThat(vector1).isNotSameAs(vector3);
     assertThat(vector1).isEqualTo(vector3);
 
-    Float[] differentArgs = args.clone();
-    float newVal = differentArgs[0] * 2;
+    T[] differentArgs = Arrays.copyOf(vals, vals.length);
+    T newVal = differentArgs[1];
     differentArgs[0] = newVal;
-    CqlVector<Float> vector4 = CqlVector.newInstance(differentArgs);
+    CqlVector<T> vector4 = CqlVector.newInstance(differentArgs);
     assertThat(vector1).isNotSameAs(vector4);
     assertThat(vector1).isNotEqualTo(vector4);
 
-    Float[] biggerArgs = Arrays.copyOf(args, args.length + 1);
+    T[] biggerArgs = Arrays.copyOf(vals, vals.length + 1);
     biggerArgs[biggerArgs.length - 1] = newVal;
-    CqlVector<Float> vector5 = CqlVector.newInstance(biggerArgs);
+    CqlVector<T> vector5 = CqlVector.newInstance(biggerArgs);
     assertThat(vector1).isNotSameAs(vector5);
     assertThat(vector1).isNotEqualTo(vector5);
   }
 
   @Test
-  public void should_serialize_and_deserialize() throws Exception {
-    CqlVector<Float> initial = CqlVector.newInstance(VECTOR_ARGS);
-    CqlVector<Float> deserialized = SerializationHelper.serializeAndDeserialize(initial);
+  @UseDataProvider("dataProvider")
+  public <T> void should_serialize_and_deserialize(T[] vals) throws Exception {
+    CqlVector<T> initial = CqlVector.newInstance(vals);
+    CqlVector<T> deserialized = SerializationHelper.serializeAndDeserialize(initial);
     assertThat(deserialized).isEqualTo(initial);
   }
 
@@ -222,21 +222,22 @@ public void should_serialize_and_deserialize_empty_vector() throws Exception {
   }
 
   @Test
-  public void should_serialize_and_deserialize_unserializable_list() throws Exception {
-    CqlVector<Float> initial =
+  @UseDataProvider("dataProvider")
+  public <T> void should_serialize_and_deserialize_unserializable_list(T[] vals) throws Exception {
+    CqlVector<T> initial =
         CqlVector.newInstance(
-            new AbstractList<Float>() {
+            new AbstractList<T>() {
               @Override
-              public Float get(int index) {
-                return VECTOR_ARGS[index];
+              public T get(int index) {
+                return vals[index];
               }
 
               @Override
               public int size() {
-                return VECTOR_ARGS.length;
+                return vals.length;
               }
             });
-    CqlVector<Float> deserialized = SerializationHelper.serializeAndDeserialize(initial);
+    CqlVector<T> deserialized = SerializationHelper.serializeAndDeserialize(initial);
     assertThat(deserialized).isEqualTo(initial);
   }
 
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java
index 969d35cbbbe..17c78514127 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java
@@ -20,122 +20,255 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import com.datastax.oss.driver.api.core.ProtocolVersion;
 import com.datastax.oss.driver.api.core.data.CqlVector;
+import com.datastax.oss.driver.api.core.type.DataType;
 import com.datastax.oss.driver.api.core.type.DataTypes;
-import com.datastax.oss.driver.api.core.type.VectorType;
+import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
 import com.datastax.oss.driver.api.core.type.codec.TypeCodecs;
-import com.datastax.oss.driver.api.core.type.reflect.GenericType;
+import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
 import com.datastax.oss.driver.internal.core.type.DefaultVectorType;
-import java.util.Arrays;
+import com.datastax.oss.protocol.internal.util.Bytes;
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import com.tngtech.java.junit.dataprovider.UseDataProvider;
+import java.nio.ByteBuffer;
+import java.time.LocalTime;
+import java.util.HashMap;
+import org.apache.commons.lang3.ArrayUtils;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 
-public class VectorCodecTest extends CodecTestBase<CqlVector<Float>> {
+@RunWith(DataProviderRunner.class)
+public class VectorCodecTest {
 
-  private static final Float[] VECTOR_ARGS = {1.0f, 2.5f};
-
-  private static final CqlVector<Float> VECTOR = CqlVector.newInstance(VECTOR_ARGS);
-
-  private static final String VECTOR_HEX_STRING = "0x" + "3f800000" + "40200000";
-
-  private static final String FORMATTED_VECTOR = "[1.0, 2.5]";
-
-  public VectorCodecTest() {
-    VectorType vectorType = DataTypes.vectorOf(DataTypes.FLOAT, 2);
-    this.codec = TypeCodecs.vectorOf(vectorType, TypeCodecs.FLOAT);
+  @DataProvider
+  public static Object[] dataProvider() {
+    HashMap<Integer, String> map1 = new HashMap<>();
+    map1.put(1, "a");
+    HashMap<Integer, String> map2 = new HashMap<>();
+    map2.put(2, "b");
+    return new TestDataContainer[] {
+      new TestDataContainer(
+          DataTypes.FLOAT,
+          new Float[] {1.0f, 2.5f},
+          "[1.0, 2.5]",
+          Bytes.fromHexString("0x3f80000040200000")),
+      new TestDataContainer(
+          DataTypes.ASCII,
+          new String[] {"ab", "cde"},
+          "['ab', 'cde']",
+          Bytes.fromHexString("0x02616203636465")),
+      new TestDataContainer(
+          DataTypes.BIGINT,
+          new Long[] {1L, 2L},
+          "[1, 2]",
+          Bytes.fromHexString("0x00000000000000010000000000000002")),
+      new TestDataContainer(
+          DataTypes.BLOB,
+          new ByteBuffer[] {Bytes.fromHexString("0xCAFE"), Bytes.fromHexString("0xABCD")},
+          "[0xcafe, 0xabcd]",
+          Bytes.fromHexString("0x02cafe02abcd")),
+      new TestDataContainer(
+          DataTypes.BOOLEAN,
+          new Boolean[] {true, false},
+          "[true, false]",
+          Bytes.fromHexString("0x0100")),
+      new TestDataContainer(
+          DataTypes.TIME,
+          new LocalTime[] {LocalTime.ofNanoOfDay(1), LocalTime.ofNanoOfDay(2)},
+          "['00:00:00.000000001', '00:00:00.000000002']",
+          Bytes.fromHexString("0x080000000000000001080000000000000002")),
+      new TestDataContainer(
+          DataTypes.mapOf(DataTypes.INT, DataTypes.ASCII),
+          new HashMap[] {map1, map2},
+          "[{1:'a'}, {2:'b'}]",
+          Bytes.fromHexString(
+              "0x110000000100000004000000010000000161110000000100000004000000020000000162")),
+      new TestDataContainer(
+          DataTypes.vectorOf(DataTypes.INT, 1),
+          new CqlVector[] {CqlVector.newInstance(1), CqlVector.newInstance(2)},
+          "[[1], [2]]",
+          Bytes.fromHexString("0x0000000100000002")),
+      new TestDataContainer(
+          DataTypes.vectorOf(DataTypes.TEXT, 1),
+          new CqlVector[] {CqlVector.newInstance("ab"), CqlVector.newInstance("cdef")},
+          "[['ab'], ['cdef']]",
+          Bytes.fromHexString("0x03026162050463646566")),
+      new TestDataContainer(
+          DataTypes.vectorOf(DataTypes.vectorOf(DataTypes.FLOAT, 2), 1),
+          new CqlVector[] {
+            CqlVector.newInstance(CqlVector.newInstance(1.0f, 2.5f)),
+            CqlVector.newInstance(CqlVector.newInstance(3.0f, 4.5f))
+          },
+          "[[[1.0, 2.5]], [[3.0, 4.5]]]",
+          Bytes.fromHexString("0x3f800000402000004040000040900000"))
+    };
   }
 
+  @UseDataProvider("dataProvider")
   @Test
-  public void should_encode() {
-    assertThat(encode(VECTOR)).isEqualTo(VECTOR_HEX_STRING);
-    assertThat(encode(null)).isNull();
+  public void should_encode(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    CqlVector<Object> vector = CqlVector.newInstance(testData.getValues());
+    assertThat(codec.encode(vector, ProtocolVersion.DEFAULT)).isEqualTo(testData.getBytes());
   }
 
-  /** Too few eleements will cause an exception, extra elements will be silently ignored */
   @Test
-  public void should_throw_on_encode_with_too_few_elements() {
-    assertThatThrownBy(() -> encode(VECTOR.subVector(0, 1)))
+  @UseDataProvider("dataProvider")
+  public void should_throw_on_encode_with_too_few_elements(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    assertThatThrownBy(
+            () ->
+                codec.encode(
+                    CqlVector.newInstance(testData.getValues()[0]), ProtocolVersion.DEFAULT))
         .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
-  public void should_throw_on_encode_with_empty_list() {
-    assertThatThrownBy(() -> encode(CqlVector.newInstance()))
+  @UseDataProvider("dataProvider")
+  public void should_throw_on_encode_with_too_many_elements(TestDataContainer testData) {
+    Object[] doubled = ArrayUtils.addAll(testData.getValues(), testData.getValues());
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    assertThatThrownBy(() -> codec.encode(CqlVector.newInstance(doubled), ProtocolVersion.DEFAULT))
         .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
-  public void should_encode_with_too_many_elements() {
-    Float[] doubledVectorContents = Arrays.copyOf(VECTOR_ARGS, VECTOR_ARGS.length * 2);
-    System.arraycopy(VECTOR_ARGS, 0, doubledVectorContents, VECTOR_ARGS.length, VECTOR_ARGS.length);
-    assertThat(encode(CqlVector.newInstance(doubledVectorContents))).isEqualTo(VECTOR_HEX_STRING);
+  @UseDataProvider("dataProvider")
+  public void should_decode(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    assertThat(codec.decode(testData.getBytes(), ProtocolVersion.DEFAULT))
+        .isEqualTo(CqlVector.newInstance(testData.getValues()));
   }
 
   @Test
-  public void should_decode() {
-    assertThat(decode(VECTOR_HEX_STRING)).isEqualTo(VECTOR);
-    assertThat(decode("0x")).isNull();
-    assertThat(decode(null)).isNull();
+  @UseDataProvider("dataProvider")
+  public void should_throw_on_decode_if_too_few_bytes(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    int lastIndex = testData.getBytes().remaining() - 1;
+    assertThatThrownBy(
+            () ->
+                codec.decode(
+                    (ByteBuffer) testData.getBytes().duplicate().limit(lastIndex),
+                    ProtocolVersion.DEFAULT))
+        .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
-  public void should_throw_on_decode_if_too_few_bytes() {
-    // Dropping 4 bytes would knock off exactly 1 float, anything less than that would be something
-    // we couldn't parse a float out of
-    for (int i = 1; i <= 3; ++i) {
-      // 2 chars of hex encoded string = 1 byte
-      int lastIndex = VECTOR_HEX_STRING.length() - (2 * i);
-      assertThatThrownBy(() -> decode(VECTOR_HEX_STRING.substring(0, lastIndex)))
-          .isInstanceOf(IllegalArgumentException.class);
-    }
+  @UseDataProvider("dataProvider")
+  public void should_throw_on_decode_if_too_many_bytes(TestDataContainer testData) {
+    ByteBuffer doubled = ByteBuffer.allocate(testData.getBytes().remaining() * 2);
+    doubled.put(testData.getBytes().duplicate()).put(testData.getBytes().duplicate()).flip();
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    assertThatThrownBy(() -> codec.decode(doubled, ProtocolVersion.DEFAULT))
+        .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
-  public void should_format() {
-    assertThat(format(VECTOR)).isEqualTo(FORMATTED_VECTOR);
-    assertThat(format(null)).isEqualTo("NULL");
+  @UseDataProvider("dataProvider")
+  public void should_format(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    CqlVector<Object> vector = CqlVector.newInstance(testData.getValues());
+    assertThat(codec.format(vector)).isEqualTo(testData.getFormatted());
   }
 
   @Test
-  public void should_parse() {
-    assertThat(parse(FORMATTED_VECTOR)).isEqualTo(VECTOR);
-    assertThat(parse("NULL")).isNull();
-    assertThat(parse("null")).isNull();
-    assertThat(parse("")).isNull();
-    assertThat(parse(null)).isNull();
+  @UseDataProvider("dataProvider")
+  public void should_parse(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    assertThat(codec.parse(testData.getFormatted()))
+        .isEqualTo(CqlVector.newInstance(testData.getValues()));
   }
 
   @Test
-  public void should_accept_data_type() {
-    assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, 2))).isTrue();
-    assertThat(codec.accepts(DataTypes.INT)).isFalse();
+  @UseDataProvider("dataProvider")
+  public void should_accept_data_type(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    assertThat(codec.accepts(new DefaultVectorType(testData.getDataType(), 2))).isTrue();
+    assertThat(codec.accepts(new DefaultVectorType(DataTypes.custom("non-existent"), 2))).isFalse();
   }
 
   @Test
-  public void should_accept_vector_type_correct_dimension_only() {
-    assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, 0))).isFalse();
-    assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, 1))).isFalse();
-    assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, 2))).isTrue();
-    for (int i = 3; i < 1000; ++i) {
-      assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, i))).isFalse();
-    }
+  @UseDataProvider("dataProvider")
+  public void should_accept_vector_type_correct_dimension_only(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    assertThat(codec.accepts(new DefaultVectorType(testData.getDataType(), 0))).isFalse();
+    assertThat(codec.accepts(new DefaultVectorType(testData.getDataType(), 1))).isFalse();
+    assertThat(codec.accepts(new DefaultVectorType(testData.getDataType(), 3))).isFalse();
   }
 
   @Test
-  public void should_accept_generic_type() {
-    assertThat(codec.accepts(GenericType.vectorOf(GenericType.FLOAT))).isTrue();
-    assertThat(codec.accepts(GenericType.vectorOf(GenericType.INTEGER))).isFalse();
-    assertThat(codec.accepts(GenericType.of(Integer.class))).isFalse();
+  @UseDataProvider("dataProvider")
+  public void should_accept_generic_type(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    assertThat(codec.accepts(codec.getJavaType())).isTrue();
   }
 
   @Test
-  public void should_accept_raw_type() {
+  @UseDataProvider("dataProvider")
+  public void should_accept_raw_type(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
     assertThat(codec.accepts(CqlVector.class)).isTrue();
     assertThat(codec.accepts(Integer.class)).isFalse();
   }
 
   @Test
-  public void should_accept_object() {
-    assertThat(codec.accepts(VECTOR)).isTrue();
+  @UseDataProvider("dataProvider")
+  public void should_accept_object(TestDataContainer testData) {
+    TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+    CqlVector<?> vector = CqlVector.newInstance(testData.getValues());
+    assertThat(codec.accepts(vector)).isTrue();
     assertThat(codec.accepts(Integer.MIN_VALUE)).isFalse();
   }
+
+  @Test
+  public void should_handle_null_and_empty() {
+    TypeCodec<CqlVector<Object>> codec = getCodec(DataTypes.FLOAT);
+    assertThat(codec.encode(null, ProtocolVersion.DEFAULT)).isNull();
+    assertThat(codec.decode(Bytes.fromHexString("0x"), ProtocolVersion.DEFAULT)).isNull();
+    assertThat(codec.format(null)).isEqualTo("NULL");
+    assertThat(codec.parse("NULL")).isNull();
+    assertThat(codec.parse("null")).isNull();
+    assertThat(codec.parse("")).isNull();
+    assertThat(codec.parse(null)).isNull();
+    assertThatThrownBy(() -> codec.encode(CqlVector.newInstance(), ProtocolVersion.DEFAULT))
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  private static TypeCodec<CqlVector<Object>> getCodec(DataType dataType) {
+    return TypeCodecs.vectorOf(
+        DataTypes.vectorOf(dataType, 2), CodecRegistry.DEFAULT.codecFor(dataType));
+  }
+
+  private static class TestDataContainer {
+    private final DataType dataType;
+    private final Object[] values;
+    private final String formatted;
+    private final ByteBuffer bytes;
+
+    public TestDataContainer(
+        DataType dataType, Object[] values, String formatted, ByteBuffer bytes) {
+      this.dataType = dataType;
+      this.values = values;
+      this.formatted = formatted;
+      this.bytes = bytes;
+    }
+
+    public DataType getDataType() {
+      return dataType;
+    }
+
+    public Object[] getValues() {
+      return values;
+    }
+
+    public String getFormatted() {
+      return formatted;
+    }
+
+    public ByteBuffer getBytes() {
+      return bytes;
+    }
+  }
 }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTestDataProviders.java b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTestDataProviders.java
index 1f3f6bbff97..4c0298bafad 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTestDataProviders.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTestDataProviders.java
@@ -337,6 +337,26 @@ public static Object[][] collectionsWithCqlAndJavaTypes()
         GenericType.vectorOf(BigInteger.class),
         CqlVector.newInstance(BigInteger.ONE)
       },
+      // vector with arbitrary types
+      {
+        DataTypes.vectorOf(DataTypes.TEXT, 2),
+        GenericType.vectorOf(String.class),
+        GenericType.vectorOf(String.class),
+        CqlVector.newInstance("abc", "de")
+      },
+      {
+        DataTypes.vectorOf(DataTypes.TIME, 2),
+        GenericType.vectorOf(LocalTime.class),
+        GenericType.vectorOf(LocalTime.class),
+        CqlVector.newInstance(LocalTime.MIDNIGHT, LocalTime.NOON)
+      },
+      {
+        DataTypes.vectorOf(DataTypes.vectorOf(DataTypes.TINYINT, 2), 2),
+        GenericType.vectorOf(GenericType.vectorOf(Byte.class)),
+        GenericType.vectorOf(GenericType.vectorOf(Byte.class)),
+        CqlVector.newInstance(
+            CqlVector.newInstance((byte) 1, (byte) 2), CqlVector.newInstance((byte) 3, (byte) 4))
+      },
     };
   }
 
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/type/util/VIntCodingTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/type/util/VIntCodingTest.java
new file mode 100644
index 00000000000..b85d6d66844
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/type/util/VIntCodingTest.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.type.util;
+
+import static org.junit.Assert.assertEquals;
+
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import com.tngtech.java.junit.dataprovider.UseDataProvider;
+import java.nio.ByteBuffer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(DataProviderRunner.class)
+public class VIntCodingTest {
+  @DataProvider
+  public static Object[] roundTripTestValues() {
+    return new Integer[] {
+      Integer.MAX_VALUE + 1,
+      Integer.MAX_VALUE,
+      Integer.MAX_VALUE - 1,
+      Integer.MIN_VALUE,
+      Integer.MIN_VALUE + 1,
+      Integer.MIN_VALUE - 1,
+      0,
+      -1,
+      1
+    };
+  };
+
+  private static final long[] LONGS =
+      new long[] {
+        53L,
+        10201L,
+        1097151L,
+        168435455L,
+        33251130335L,
+        3281283447775L,
+        417672546086779L,
+        52057592037927932L,
+        72057594037927937L
+      };
+
+  @Test
+  public void should_compute_unsigned_vint_size() {
+    for (int i = 0; i < LONGS.length; i++) {
+      long val = LONGS[i];
+      assertEquals(i + 1, VIntCoding.computeUnsignedVIntSize(val));
+    }
+  }
+
+  @Test
+  @UseDataProvider("roundTripTestValues")
+  public void should_write_and_read_unsigned_vint_32(int value) {
+    ByteBuffer bb = ByteBuffer.allocate(9);
+
+    VIntCoding.writeUnsignedVInt32(value, bb);
+    bb.flip();
+    assertEquals(value, VIntCoding.getUnsignedVInt32(bb, 0));
+  }
+
+  @Test
+  @UseDataProvider("roundTripTestValues")
+  public void should_write_and_read_unsigned_vint(int value) {
+    ByteBuffer bb = ByteBuffer.allocate(9);
+
+    VIntCoding.writeUnsignedVInt(value, bb);
+    bb.flip();
+    assertEquals(value, VIntCoding.getUnsignedVInt(bb, 0));
+  }
+}
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java
index a33c8704876..e3d891454de 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java
@@ -32,6 +32,7 @@
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.cql.Statement;
 import com.datastax.oss.driver.api.core.data.CqlDuration;
+import com.datastax.oss.driver.api.core.data.CqlVector;
 import com.datastax.oss.driver.api.core.data.SettableByIndex;
 import com.datastax.oss.driver.api.core.data.SettableByName;
 import com.datastax.oss.driver.api.core.data.TupleValue;
@@ -183,6 +184,7 @@ public static Object[][] typeSamples() {
     // 5) include map<type, int>
     // 6) include tuple<int, type>
     // 7) include udt<int, type>
+    // 8) include vector<type>
     return Arrays.stream(primitiveSamples)
         .flatMap(
             o -> {
@@ -263,6 +265,30 @@ public static Object[][] typeSamples() {
               UdtValue udtValue2 = udt.newValue(1, o[1]);
               samples.add(new Object[] {udt, udtValue2});
 
+              if (CCM_RULE.getCassandraVersion().compareTo(Version.parse("5.0")) >= 0) {
+                // vector of type
+                CqlVector<?> vector = CqlVector.newInstance(o[1]);
+                samples.add(new Object[] {DataTypes.vectorOf(dataType, 1), vector});
+              }
+
+              return samples.stream();
+            })
+        .toArray(Object[][]::new);
+  }
+
+  @DataProvider
+  public static Object[][] addVectors() {
+    Object[][] previousSamples = typeSamples();
+    if (CCM_RULE.getCassandraVersion().compareTo(Version.parse("5.0")) < 0) return previousSamples;
+    return Arrays.stream(previousSamples)
+        .flatMap(
+            o -> {
+              List<Object[]> samples = new ArrayList<>();
+              samples.add(o);
+              if (o[1] == null) return samples.stream();
+              DataType dataType = (DataType) o[0];
+              CqlVector<?> vector = CqlVector.newInstance(o[1]);
+              samples.add(new Object[] {DataTypes.vectorOf(dataType, 1), vector});
               return samples.stream();
             })
         .toArray(Object[][]::new);
@@ -278,7 +304,7 @@ public static void createTable() {
 
     List<String> columnData = new ArrayList<>();
 
-    for (Object[] sample : typeSamples()) {
+    for (Object[] sample : addVectors()) {
       DataType dataType = (DataType) sample[0];
 
       if (!typeToColumnName.containsKey(dataType)) {
@@ -308,7 +334,7 @@ private static int nextKey() {
     return keyCounter.incrementAndGet();
   }
 
-  @UseDataProvider("typeSamples")
+  @UseDataProvider("addVectors")
   @Test
   public <K> void should_insert_non_primary_key_column_simple_statement_using_format(
       DataType dataType, K value, K expectedPrimitiveValue) {
@@ -335,7 +361,7 @@ public <K> void should_insert_non_primary_key_column_simple_statement_using_form
     readValue(select, dataType, value, expectedPrimitiveValue);
   }
 
-  @UseDataProvider("typeSamples")
+  @UseDataProvider("addVectors")
   @Test
   public <K> void should_insert_non_primary_key_column_simple_statement_positional_value(
       DataType dataType, K value, K expectedPrimitiveValue) {
@@ -358,7 +384,7 @@ public <K> void should_insert_non_primary_key_column_simple_statement_positional
     readValue(select, dataType, value, expectedPrimitiveValue);
   }
 
-  @UseDataProvider("typeSamples")
+  @UseDataProvider("addVectors")
   @Test
   public <K> void should_insert_non_primary_key_column_simple_statement_named_value(
       DataType dataType, K value, K expectedPrimitiveValue) {
@@ -382,7 +408,7 @@ public <K> void should_insert_non_primary_key_column_simple_statement_named_valu
     readValue(select, dataType, value, expectedPrimitiveValue);
   }
 
-  @UseDataProvider("typeSamples")
+  @UseDataProvider("addVectors")
   @Test
   public <K> void should_insert_non_primary_key_column_bound_statement_positional_value(
       DataType dataType, K value, K expectedPrimitiveValue) {
@@ -411,7 +437,7 @@ public <K> void should_insert_non_primary_key_column_bound_statement_positional_
     readValue(boundSelect, dataType, value, expectedPrimitiveValue);
   }
 
-  @UseDataProvider("typeSamples")
+  @UseDataProvider("addVectors")
   @Test
   public <K> void should_insert_non_primary_key_column_bound_statement_named_value(
       DataType dataType, K value, K expectedPrimitiveValue) {

From 04d34a8989b89c1addaab7f248b1fa9aa535da5e Mon Sep 17 00:00:00 2001
From: Alex Sasnouskikh <jahstreetlove@gmail.com>
Date: Thu, 30 Jan 2025 22:36:29 +0000
Subject: [PATCH 060/126] JAVA-3168 Copy node info for contact points on
 initial node refresh only from first match by endpoint

patch by Alex Sasnouskikh; reviewed by Andy Tolbert and Alexandre Dura for JAVA-3168
---
 .../core/metadata/InitialNodeListRefresh.java | 36 +++++++++++--------
 .../metadata/InitialNodeListRefreshTest.java  | 34 ++++++++++++++++--
 2 files changed, 54 insertions(+), 16 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/InitialNodeListRefresh.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/InitialNodeListRefresh.java
index c21d5d8171e..517bfca27fa 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/InitialNodeListRefresh.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/InitialNodeListRefresh.java
@@ -18,14 +18,16 @@
 package com.datastax.oss.driver.internal.core.metadata;
 
 import com.datastax.oss.driver.api.core.metadata.EndPoint;
-import com.datastax.oss.driver.api.core.metadata.Node;
 import com.datastax.oss.driver.internal.core.context.InternalDriverContext;
 import com.datastax.oss.driver.internal.core.metadata.token.TokenFactory;
 import com.datastax.oss.driver.internal.core.metadata.token.TokenFactoryRegistry;
 import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
@@ -63,22 +65,31 @@ public Result compute(
     TokenFactory tokenFactory = null;
 
     Map<UUID, DefaultNode> newNodes = new HashMap<>();
+    // Contact point nodes don't have host ID as well as other info yet, so we fill them with node
+    // info found on first match by endpoint
+    Set<EndPoint> matchedContactPoints = new HashSet<>();
+    List<DefaultNode> addedNodes = new ArrayList<>();
 
     for (NodeInfo nodeInfo : nodeInfos) {
       UUID hostId = nodeInfo.getHostId();
       if (newNodes.containsKey(hostId)) {
         LOG.warn(
             "[{}] Found duplicate entries with host_id {} in system.peers, "
-                + "keeping only the first one",
+                + "keeping only the first one {}",
             logPrefix,
-            hostId);
+            hostId,
+            newNodes.get(hostId));
       } else {
         EndPoint endPoint = nodeInfo.getEndPoint();
-        DefaultNode node = findIn(contactPoints, endPoint);
-        if (node == null) {
+        DefaultNode contactPointNode = findContactPointNode(endPoint);
+        DefaultNode node;
+        if (contactPointNode == null || matchedContactPoints.contains(endPoint)) {
           node = new DefaultNode(endPoint, context);
+          addedNodes.add(node);
           LOG.debug("[{}] Adding new node {}", logPrefix, node);
         } else {
+          matchedContactPoints.add(contactPointNode.getEndPoint());
+          node = contactPointNode;
           LOG.debug("[{}] Copying contact point {}", logPrefix, node);
         }
         if (tokenMapEnabled && tokenFactory == null && nodeInfo.getPartitioner() != null) {
@@ -90,14 +101,11 @@ public Result compute(
     }
 
     ImmutableList.Builder<Object> eventsBuilder = ImmutableList.builder();
-
-    for (DefaultNode newNode : newNodes.values()) {
-      if (findIn(contactPoints, newNode.getEndPoint()) == null) {
-        eventsBuilder.add(NodeStateEvent.added(newNode));
-      }
+    for (DefaultNode addedNode : addedNodes) {
+      eventsBuilder.add(NodeStateEvent.added(addedNode));
     }
     for (DefaultNode contactPoint : contactPoints) {
-      if (findIn(newNodes.values(), contactPoint.getEndPoint()) == null) {
+      if (!matchedContactPoints.contains(contactPoint.getEndPoint())) {
         eventsBuilder.add(NodeStateEvent.removed(contactPoint));
       }
     }
@@ -108,10 +116,10 @@ public Result compute(
         eventsBuilder.build());
   }
 
-  private DefaultNode findIn(Iterable<? extends Node> nodes, EndPoint endPoint) {
-    for (Node node : nodes) {
+  private DefaultNode findContactPointNode(EndPoint endPoint) {
+    for (DefaultNode node : contactPoints) {
       if (node.getEndPoint().equals(endPoint)) {
-        return (DefaultNode) node;
+        return node;
       }
     }
     return null;
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/InitialNodeListRefreshTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/InitialNodeListRefreshTest.java
index 095662257f6..3787bf8fe10 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/InitialNodeListRefreshTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/metadata/InitialNodeListRefreshTest.java
@@ -48,6 +48,8 @@ public class InitialNodeListRefreshTest {
   private UUID hostId1;
   private UUID hostId2;
   private UUID hostId3;
+  private UUID hostId4;
+  private UUID hostId5;
 
   @Before
   public void setup() {
@@ -61,10 +63,12 @@ public void setup() {
     hostId1 = UUID.randomUUID();
     hostId2 = UUID.randomUUID();
     hostId3 = UUID.randomUUID();
+    hostId4 = UUID.randomUUID();
+    hostId5 = UUID.randomUUID();
   }
 
   @Test
-  public void should_copy_contact_points() {
+  public void should_copy_contact_points_on_first_endpoint_match_only() {
     // Given
     Iterable<NodeInfo> newInfos =
         ImmutableList.of(
@@ -76,6 +80,17 @@ public void should_copy_contact_points() {
             DefaultNodeInfo.builder()
                 .withEndPoint(contactPoint2.getEndPoint())
                 .withHostId(hostId2)
+                .build(),
+            DefaultNodeInfo.builder().withEndPoint(endPoint3).withHostId(hostId3).build(),
+            DefaultNodeInfo.builder()
+                // address translator can translate node addresses to the same endpoints
+                .withEndPoint(contactPoint2.getEndPoint())
+                .withHostId(hostId4)
+                .build(),
+            DefaultNodeInfo.builder()
+                // address translator can translate node addresses to the same endpoints
+                .withEndPoint(endPoint3)
+                .withHostId(hostId5)
                 .build());
     InitialNodeListRefresh refresh =
         new InitialNodeListRefresh(newInfos, ImmutableSet.of(contactPoint1, contactPoint2));
@@ -86,11 +101,26 @@ public void should_copy_contact_points() {
     // Then
     // contact points have been copied to the metadata, and completed with missing information
     Map<UUID, Node> newNodes = result.newMetadata.getNodes();
-    assertThat(newNodes).containsOnlyKeys(hostId1, hostId2);
+    assertThat(newNodes).containsOnlyKeys(hostId1, hostId2, hostId3, hostId4, hostId5);
     assertThat(newNodes.get(hostId1)).isEqualTo(contactPoint1);
     assertThat(contactPoint1.getHostId()).isEqualTo(hostId1);
     assertThat(newNodes.get(hostId2)).isEqualTo(contactPoint2);
     assertThat(contactPoint2.getHostId()).isEqualTo(hostId2);
+    // And
+    // node has been added for the new endpoint
+    assertThat(newNodes.get(hostId3).getEndPoint()).isEqualTo(endPoint3);
+    assertThat(newNodes.get(hostId3).getHostId()).isEqualTo(hostId3);
+    // And
+    // nodes have been added for duplicated endpoints
+    assertThat(newNodes.get(hostId4).getEndPoint()).isEqualTo(contactPoint2.getEndPoint());
+    assertThat(newNodes.get(hostId4).getHostId()).isEqualTo(hostId4);
+    assertThat(newNodes.get(hostId5).getEndPoint()).isEqualTo(endPoint3);
+    assertThat(newNodes.get(hostId5).getHostId()).isEqualTo(hostId5);
+    assertThat(result.events)
+        .containsExactlyInAnyOrder(
+            NodeStateEvent.added((DefaultNode) newNodes.get(hostId3)),
+            NodeStateEvent.added((DefaultNode) newNodes.get(hostId4)),
+            NodeStateEvent.added((DefaultNode) newNodes.get(hostId5)));
   }
 
   @Test

From eac7b24d60d87e912ea70ba3ddee2755a6fa28cf Mon Sep 17 00:00:00 2001
From: Luc Boutier <luc.boutier@me.com>
Date: Fri, 3 Nov 2023 10:13:13 +0100
Subject: [PATCH 061/126] JAVA-3055: Prevent PreparedStatement cache to be
 polluted if a request is cancelled.

There was a critical issue when the external code cancels a request, indeed the cached CompletableFuture will then always throw a CancellationException.
This may happens, for example, when used by reactive like Mono.zip or Mono.firstWithValue.

patch by Luc Boutier; reviewed by Alexandre Dutra and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1757
---
 .../driver/internal/core/cql/CqlPrepareAsyncProcessor.java    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
index ffbc8ee046a..d777e35e50f 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
@@ -159,7 +159,9 @@ public CompletionStage<PreparedStatement> process(
                   });
         }
       }
-      return result;
+      // Return a defensive copy. So if a client cancels its request, the cache won't be impacted
+      // nor a potential concurrent request.
+      return result.thenApply(x -> x); // copy() is available only since Java 9
     } catch (ExecutionException e) {
       return CompletableFutures.failedFuture(e.getCause());
     }

From 64b3568dfa6dd58e8c16d28cafbe8dbf16f1e622 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Mon, 3 Feb 2025 17:56:54 -0600
Subject: [PATCH 062/126] Expose a decorator for CqlPrepareAsyncProcessor cache
 rather than the ability to specify an arbitrary cache from scratch.

Also bringing tests from https://github.com/apache/cassandra-java-driver/pull/2003 forward
with a few minor changes due to this implementation

patch by Bret McGuire; reviewed by Bret McGuire and Andy Tolbert
reference: #2008
---
 .../core/cql/CqlPrepareAsyncProcessor.java    |  11 +-
 .../core/cql/PreparedStatementCachingIT.java  |  13 +-
 .../cql/PreparedStatementCancellationIT.java  | 166 ++++++++++++++++++
 3 files changed, 178 insertions(+), 12 deletions(-)
 create mode 100644 integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCancellationIT.java

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
index d777e35e50f..918d75e9ecb 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
@@ -38,6 +38,7 @@
 import com.datastax.oss.driver.shaded.guava.common.cache.CacheBuilder;
 import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
 import com.datastax.oss.protocol.internal.ProtocolConstants;
+import com.google.common.base.Functions;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import io.netty.util.concurrent.EventExecutor;
 import java.util.Map;
@@ -45,6 +46,7 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
+import java.util.function.Function;
 import net.jcip.annotations.ThreadSafe;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -62,14 +64,15 @@ public CqlPrepareAsyncProcessor() {
   }
 
   public CqlPrepareAsyncProcessor(@NonNull Optional<? extends DefaultDriverContext> context) {
-    this(CacheBuilder.newBuilder().weakValues().build(), context);
+    this(context, Functions.identity());
   }
 
   protected CqlPrepareAsyncProcessor(
-      Cache<PrepareRequest, CompletableFuture<PreparedStatement>> cache,
-      Optional<? extends DefaultDriverContext> context) {
+      Optional<? extends DefaultDriverContext> context,
+      Function<CacheBuilder<Object, Object>, CacheBuilder<Object, Object>> decorator) {
 
-    this.cache = cache;
+    CacheBuilder<Object, Object> baseCache = CacheBuilder.newBuilder().weakValues();
+    this.cache = decorator.apply(baseCache).build();
     context.ifPresent(
         (ctx) -> {
           LOG.info("Adding handler to invalidate cached prepared statements on type changes");
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
index 05ac3bd0e92..617d489fb95 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
@@ -24,7 +24,6 @@
 import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
 import com.datastax.oss.driver.api.core.context.DriverContext;
-import com.datastax.oss.driver.api.core.cql.PrepareRequest;
 import com.datastax.oss.driver.api.core.cql.PreparedStatement;
 import com.datastax.oss.driver.api.core.metrics.DefaultSessionMetric;
 import com.datastax.oss.driver.api.core.session.ProgrammaticArguments;
@@ -41,7 +40,6 @@
 import com.datastax.oss.driver.internal.core.session.BuiltInRequestProcessors;
 import com.datastax.oss.driver.internal.core.session.RequestProcessor;
 import com.datastax.oss.driver.internal.core.session.RequestProcessorRegistry;
-import com.datastax.oss.driver.shaded.guava.common.cache.CacheBuilder;
 import com.datastax.oss.driver.shaded.guava.common.cache.RemovalListener;
 import com.datastax.oss.driver.shaded.guava.common.util.concurrent.Uninterruptibles;
 import com.google.common.collect.ImmutableList;
@@ -119,11 +117,12 @@ private static class TestCqlPrepareAsyncProcessor extends CqlPrepareAsyncProcess
     private static final Logger LOG =
         LoggerFactory.getLogger(PreparedStatementCachingIT.TestCqlPrepareAsyncProcessor.class);
 
-    private static RemovalListener<PrepareRequest, CompletableFuture<PreparedStatement>>
-        buildCacheRemoveCallback(@NonNull Optional<DefaultDriverContext> context) {
+    private static RemovalListener<Object, Object> buildCacheRemoveCallback(
+        @NonNull Optional<DefaultDriverContext> context) {
       return (evt) -> {
         try {
-          CompletableFuture<PreparedStatement> future = evt.getValue();
+          CompletableFuture<PreparedStatement> future =
+              (CompletableFuture<PreparedStatement>) evt.getValue();
           ByteBuffer queryId = Uninterruptibles.getUninterruptibly(future).getId();
           context.ifPresent(
               ctx -> ctx.getEventBus().fire(new PreparedStatementRemovalEvent(queryId)));
@@ -136,9 +135,7 @@ private static class TestCqlPrepareAsyncProcessor extends CqlPrepareAsyncProcess
     public TestCqlPrepareAsyncProcessor(@NonNull Optional<DefaultDriverContext> context) {
       // Default CqlPrepareAsyncProcessor uses weak values here as well.  We avoid doing so
       // to prevent cache entries from unexpectedly disappearing mid-test.
-      super(
-          CacheBuilder.newBuilder().removalListener(buildCacheRemoveCallback(context)).build(),
-          context);
+      super(context, builder -> builder.removalListener(buildCacheRemoveCallback(context)));
     }
   }
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCancellationIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCancellationIT.java
new file mode 100644
index 00000000000..d7e581e4606
--- /dev/null
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCancellationIT.java
@@ -0,0 +1,166 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.core.cql;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.cql.PrepareRequest;
+import com.datastax.oss.driver.api.core.cql.PreparedStatement;
+import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
+import com.datastax.oss.driver.api.testinfra.session.SessionRule;
+import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
+import com.datastax.oss.driver.categories.IsolatedTests;
+import com.datastax.oss.driver.internal.core.context.DefaultDriverContext;
+import com.datastax.oss.driver.internal.core.cql.CqlPrepareAsyncProcessor;
+import com.datastax.oss.driver.shaded.guava.common.base.Predicates;
+import com.datastax.oss.driver.shaded.guava.common.cache.Cache;
+import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
+import java.util.concurrent.CompletableFuture;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.RuleChain;
+import org.junit.rules.TestRule;
+
+@Category(IsolatedTests.class)
+public class PreparedStatementCancellationIT {
+
+  private CustomCcmRule ccmRule = CustomCcmRule.builder().build();
+
+  private SessionRule<CqlSession> sessionRule = SessionRule.builder(ccmRule).build();
+
+  @Rule public TestRule chain = RuleChain.outerRule(ccmRule).around(sessionRule);
+
+  @Before
+  public void setup() {
+
+    CqlSession session = SessionUtils.newSession(ccmRule, sessionRule.keyspace());
+    session.execute("DROP TABLE IF EXISTS test_table_1");
+    session.execute("CREATE TABLE test_table_1 (k int primary key, v int)");
+    session.execute("INSERT INTO test_table_1 (k,v) VALUES (1, 100)");
+    session.execute("INSERT INTO test_table_1 (k,v) VALUES (2, 200)");
+    session.execute("INSERT INTO test_table_1 (k,v) VALUES (3, 300)");
+    session.close();
+  }
+
+  @After
+  public void teardown() {
+
+    CqlSession session = SessionUtils.newSession(ccmRule, sessionRule.keyspace());
+    session.execute("DROP TABLE test_table_1");
+    session.close();
+  }
+
+  private CompletableFuture<PreparedStatement> toCompletableFuture(CqlSession session, String cql) {
+
+    return session.prepareAsync(cql).toCompletableFuture();
+  }
+
+  private CqlPrepareAsyncProcessor findProcessor(CqlSession session) {
+
+    DefaultDriverContext context = (DefaultDriverContext) session.getContext();
+    return (CqlPrepareAsyncProcessor)
+        Iterables.find(
+            context.getRequestProcessorRegistry().getProcessors(),
+            Predicates.instanceOf(CqlPrepareAsyncProcessor.class));
+  }
+
+  @Test
+  public void should_cache_valid_cql() throws Exception {
+
+    CqlSession session = SessionUtils.newSession(ccmRule, sessionRule.keyspace());
+    CqlPrepareAsyncProcessor processor = findProcessor(session);
+    Cache<PrepareRequest, CompletableFuture<PreparedStatement>> cache = processor.getCache();
+    assertThat(cache.size()).isEqualTo(0);
+
+    // Make multiple CompletableFuture requests for the specified CQL, then wait until
+    // the cached request finishes and confirm that all futures got the same values
+    String cql = "select v from test_table_1 where k = ?";
+    CompletableFuture<PreparedStatement> cf1 = toCompletableFuture(session, cql);
+    CompletableFuture<PreparedStatement> cf2 = toCompletableFuture(session, cql);
+    assertThat(cache.size()).isEqualTo(1);
+
+    CompletableFuture<PreparedStatement> future = Iterables.get(cache.asMap().values(), 0);
+    PreparedStatement stmt = future.get();
+
+    assertThat(cf1.isDone()).isTrue();
+    assertThat(cf2.isDone()).isTrue();
+
+    assertThat(cf1.join()).isEqualTo(stmt);
+    assertThat(cf2.join()).isEqualTo(stmt);
+  }
+
+  // A holdover from work done on JAVA-3055.  This probably isn't _desired_ behaviour but this test
+  // documents the fact that the current driver impl will behave in this way.  We should probably
+  // consider changing this in a future release, although it's worthwhile fully considering the
+  // implications of such a change.
+  @Test
+  public void will_cache_invalid_cql() throws Exception {
+
+    CqlSession session = SessionUtils.newSession(ccmRule, sessionRule.keyspace());
+    CqlPrepareAsyncProcessor processor = findProcessor(session);
+    Cache<PrepareRequest, CompletableFuture<PreparedStatement>> cache = processor.getCache();
+    assertThat(cache.size()).isEqualTo(0);
+
+    // Verify that we get the CompletableFuture even if the CQL is invalid but that nothing is
+    // cached
+    String cql = "select v fromfrom test_table_1 where k = ?";
+    CompletableFuture<PreparedStatement> cf = toCompletableFuture(session, cql);
+
+    // join() here should throw exceptions due to the invalid syntax... for purposes of this test we
+    // can ignore this
+    try {
+      cf.join();
+      fail();
+    } catch (Exception e) {
+    }
+
+    assertThat(cache.size()).isEqualTo(1);
+  }
+
+  @Test
+  public void should_not_affect_cache_if_returned_futures_are_cancelled() throws Exception {
+
+    CqlSession session = SessionUtils.newSession(ccmRule, sessionRule.keyspace());
+    CqlPrepareAsyncProcessor processor = findProcessor(session);
+    Cache<PrepareRequest, CompletableFuture<PreparedStatement>> cache = processor.getCache();
+    assertThat(cache.size()).isEqualTo(0);
+
+    String cql = "select v from test_table_1 where k = ?";
+    CompletableFuture<PreparedStatement> cf = toCompletableFuture(session, cql);
+
+    assertThat(cf.isCancelled()).isFalse();
+    assertThat(cf.cancel(false)).isTrue();
+    assertThat(cf.isCancelled()).isTrue();
+    assertThat(cf.isCompletedExceptionally()).isTrue();
+
+    // Confirm that cancelling the CompletableFuture returned to the user does _not_ cancel the
+    // future used within the cache.  CacheEntry very deliberately doesn't maintain a reference
+    // to it's contained CompletableFuture so we have to get at this by secondary effects.
+    assertThat(cache.size()).isEqualTo(1);
+    CompletableFuture<PreparedStatement> future = Iterables.get(cache.asMap().values(), 0);
+    PreparedStatement rv = future.get();
+    assertThat(rv).isNotNull();
+    assertThat(rv.getQuery()).isEqualTo(cql);
+    assertThat(cache.size()).isEqualTo(1);
+  }
+}

From 94e73d9f4e95cd74b319495663862ad50c63f589 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Wed, 5 Feb 2025 15:33:46 -0600
Subject: [PATCH 063/126] ninja-fix Using shaded Guava classes for import in
 order to make OSGi class paths happy.

Major hat tip to Dmitry Konstantinov for the find here!
---
 .../oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
index 918d75e9ecb..a3d11cff054 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
@@ -34,11 +34,11 @@
 import com.datastax.oss.driver.internal.core.session.RequestProcessor;
 import com.datastax.oss.driver.internal.core.util.concurrent.CompletableFutures;
 import com.datastax.oss.driver.internal.core.util.concurrent.RunOrSchedule;
+import com.datastax.oss.driver.shaded.guava.common.base.Functions;
 import com.datastax.oss.driver.shaded.guava.common.cache.Cache;
 import com.datastax.oss.driver.shaded.guava.common.cache.CacheBuilder;
 import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
 import com.datastax.oss.protocol.internal.ProtocolConstants;
-import com.google.common.base.Functions;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import io.netty.util.concurrent.EventExecutor;
 import java.util.Map;

From 610b91b160948c96c2d61aa34021db3cdac73aa2 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Tue, 4 Feb 2025 15:22:14 -0600
Subject: [PATCH 064/126] Changelog updates for 4.19.0

---
 changelog/README.md | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/changelog/README.md b/changelog/README.md
index 83ebb44239f..08634bcb834 100644
--- a/changelog/README.md
+++ b/changelog/README.md
@@ -21,6 +21,30 @@ under the License.
 
 <!-- Note: contrary to 3.x, insert new entries *first* in their section -->
 
+### 4.19.0
+
+- [bug] JAVA-3055: Prevent PreparedStatement cache to be polluted if a request is cancelled.
+- [bug] JAVA-3168: Copy node info for contact points on initial node refresh only from first match by endpoint
+- [improvement] JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)
+- [improvement] CASSJAVA-53: Update Guava version used in cassandra-java-driver
+- [improvement] JAVA-3118: Add support for vector data type in Schema Builder, QueryBuilder
+- [bug] CASSJAVA-55: Remove setting "Host" header for metadata requests
+- [bug] JAVA-3057: Allow decoding a UDT that has more fields than expected
+- [improvement] CASSJAVA-52: Bring java-driver-shaded-guava into the repo as a submodule
+- [bug] CASSJAVA-2: TableMetadata#describe produces invalid CQL when a type of a column is a vector
+- [bug] JAVA-3051: Memory leak in DefaultLoadBalancingPolicy measurement of response times
+- [improvement] CASSJAVA-14: Query builder support for NOT CQL syntax
+- [bug] CASSJAVA-12: DefaultSslEngineFactory missing null check on close
+- [improvement] CASSJAVA-46: Expose table extensions via schema builders
+- [bug] PR 1938: Fix uncaught exception during graceful channel shutdown after exceeding max orphan ids
+- [improvement] PR 1607: Annotate BatchStatement, Statement, SimpleStatement methods with CheckReturnValue
+- [improvement] CASSJAVA-41: Reduce lock held duration in ConcurrencyLimitingRequestThrottler
+- [bug] JAVA-3149: Async Query Cancellation Not Propagated To RequestThrottler
+- [bug] JAVA-3167: CompletableFutures.allSuccessful() may return never completed future
+- [bug] PR 1620: Don't return empty routing key when partition key is unbound
+- [improvement] PR 1623: Limit calls to Conversions.resolveExecutionProfile
+- [improvement] CASSJAVA-29: Update target Cassandra versions for integration tests, support new 5.0.x
+
 ### 4.18.1
 
 - [improvement] JAVA-3142: Ability to specify ordering of remote local dc's via new configuration for graceful automatic failovers

From 46444eaabdbd23e9231123198536d070e99aca27 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Thu, 6 Feb 2025 15:51:51 -0600
Subject: [PATCH 065/126] [maven-release-plugin] prepare release 4.19.0

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 08f212f6157..bb39a484f71 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.18.2-SNAPSHOT</version>
+        <version>4.19.0</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 9a708beb2a7..82f45050098 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 2a48e8bf9ce..ea0efdddc08 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index ee5b52958c3..d3275565827 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index fafd8c4678b..0bb2ccef386 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index dfc406baf43..4edc44d2131 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index a76cc8d2bf1..ee90d5c2c65 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index ca8f0161b04..a0627c376ff 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index d1b0a736bb0..1052f96ae35 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 6588f17d5f7..0b201db2473 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 28483ee93ff..f846fc68dec 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 8ab939cbb37..80ec51605ab 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 521a67f9075..955160dd621 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index f0e66b656ca..7b761aa12a0 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index c61e6485fd3..ecb800b7ebb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.18.2-SNAPSHOT</version>
+  <version>4.19.0</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1029,7 +1029,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>HEAD</tag>
+    <tag>4.19.0</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 4e09a10e584..144906adecb 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 262627e5536..0252683ca2b 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.18.2-SNAPSHOT</version>
+    <version>4.19.0</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 90612f6758eb0f0ba964daf054f397a47a90a736 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Thu, 6 Feb 2025 15:51:54 -0600
Subject: [PATCH 066/126] [maven-release-plugin] prepare for next development
 iteration

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index bb39a484f71..8e7bc467fe7 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.0</version>
+        <version>4.19.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 82f45050098..451db1dcd1b 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index ea0efdddc08..b8d7d5c2d3b 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index d3275565827..e930f4c0610 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 0bb2ccef386..1c762074673 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 4edc44d2131..8f7740e148f 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index ee90d5c2c65..15f082e6864 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index a0627c376ff..8053af94911 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 1052f96ae35..b489076c257 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 0b201db2473..519f1411ce9 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index f846fc68dec..3a767c2a352 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 80ec51605ab..091bb5f3e93 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 955160dd621..5163b5366f4 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 7b761aa12a0..4b41f790145 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index ecb800b7ebb..3fd2d1347c2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.0</version>
+  <version>4.19.1-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1029,7 +1029,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>4.19.0</tag>
+    <tag>HEAD</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 144906adecb..0bc46f9bb91 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 0252683ca2b..b0808757ce4 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.0</version>
+    <version>4.19.1-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 3bb5b18903636976279506308c60f1911b7b8ed5 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <abe@aber.io>
Date: Thu, 13 Feb 2025 17:11:36 -0500
Subject: [PATCH 067/126] CASSJAVA-80: Support configuration to disable DNS
 reverse-lookups for SAN validation

patch by Abe Ratnofsky; reviewed by Alexandre Dutra, Andy Tolbert, and Francisco Guerrero for CASSJAVA-80
---
 .../api/core/config/DefaultDriverOption.java  |  6 ++
 .../api/core/config/TypedDriverOption.java    |  4 ++
 .../ssl/ProgrammaticSslEngineFactory.java     | 27 +++++++-
 .../core/ssl/DefaultSslEngineFactory.java     | 26 +++++++-
 .../core/ssl/SniSslEngineFactory.java         | 10 ++-
 core/src/main/resources/reference.conf        |  6 ++
 .../core/ssl/DefaultSslEngineFactoryIT.java   | 66 +++++++++++++++++++
 7 files changed, 141 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
index 11f2702c3cf..acd4bb9cc1d 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
@@ -243,6 +243,12 @@ public enum DefaultDriverOption implements DriverOption {
    * <p>Value-type: boolean
    */
   SSL_HOSTNAME_VALIDATION("advanced.ssl-engine-factory.hostname-validation"),
+  /**
+   * Whether or not to do a DNS reverse-lookup of provided server addresses for SAN addresses.
+   *
+   * <p>Value-type: boolean
+   */
+  SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN("advanced.ssl-engine-factory.allow-dns-reverse-lookup-san"),
   /**
    * The location of the keystore file.
    *
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
index ca60b67f0ba..93e2b468461 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
@@ -229,6 +229,10 @@ public String toString() {
    */
   public static final TypedDriverOption<Boolean> SSL_HOSTNAME_VALIDATION =
       new TypedDriverOption<>(DefaultDriverOption.SSL_HOSTNAME_VALIDATION, GenericType.BOOLEAN);
+
+  public static final TypedDriverOption<Boolean> SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN =
+      new TypedDriverOption<>(
+          DefaultDriverOption.SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN, GenericType.BOOLEAN);
   /** The location of the keystore file. */
   public static final TypedDriverOption<String> SSL_KEYSTORE_PATH =
       new TypedDriverOption<>(DefaultDriverOption.SSL_KEYSTORE_PATH, GenericType.STRING);
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/ssl/ProgrammaticSslEngineFactory.java b/core/src/main/java/com/datastax/oss/driver/api/core/ssl/ProgrammaticSslEngineFactory.java
index 6dfe4087b91..d65eaa864aa 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/ssl/ProgrammaticSslEngineFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/ssl/ProgrammaticSslEngineFactory.java
@@ -45,6 +45,7 @@ public class ProgrammaticSslEngineFactory implements SslEngineFactory {
   protected final SSLContext sslContext;
   protected final String[] cipherSuites;
   protected final boolean requireHostnameValidation;
+  protected final boolean allowDnsReverseLookupSan;
 
   /**
    * Creates an instance with the given {@link SSLContext}, default cipher suites and no host name
@@ -80,9 +81,28 @@ public ProgrammaticSslEngineFactory(
       @NonNull SSLContext sslContext,
       @Nullable String[] cipherSuites,
       boolean requireHostnameValidation) {
+    this(sslContext, cipherSuites, requireHostnameValidation, true);
+  }
+
+  /**
+   * Creates an instance with the given {@link SSLContext}, cipher suites and host name validation.
+   *
+   * @param sslContext the {@link SSLContext} to use.
+   * @param cipherSuites the cipher suites to use, or null to use the default ones.
+   * @param requireHostnameValidation whether to enable host name validation. If enabled, host name
+   *     validation will be done using HTTPS algorithm.
+   * @param allowDnsReverseLookupSan whether to allow raw server IPs to be DNS reverse-resolved to
+   *     choose the appropriate Subject Alternative Name.
+   */
+  public ProgrammaticSslEngineFactory(
+      @NonNull SSLContext sslContext,
+      @Nullable String[] cipherSuites,
+      boolean requireHostnameValidation,
+      boolean allowDnsReverseLookupSan) {
     this.sslContext = sslContext;
     this.cipherSuites = cipherSuites;
     this.requireHostnameValidation = requireHostnameValidation;
+    this.allowDnsReverseLookupSan = allowDnsReverseLookupSan;
   }
 
   @NonNull
@@ -92,7 +112,12 @@ public SSLEngine newSslEngine(@NonNull EndPoint remoteEndpoint) {
     SocketAddress remoteAddress = remoteEndpoint.resolve();
     if (remoteAddress instanceof InetSocketAddress) {
       InetSocketAddress socketAddress = (InetSocketAddress) remoteAddress;
-      engine = sslContext.createSSLEngine(socketAddress.getHostName(), socketAddress.getPort());
+      engine =
+          sslContext.createSSLEngine(
+              allowDnsReverseLookupSan
+                  ? socketAddress.getHostName()
+                  : socketAddress.getHostString(),
+              socketAddress.getPort());
     } else {
       engine = sslContext.createSSLEngine();
     }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
index 475ec38d578..343d3f9e4e7 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/DefaultSslEngineFactory.java
@@ -22,6 +22,7 @@
 import com.datastax.oss.driver.api.core.context.DriverContext;
 import com.datastax.oss.driver.api.core.metadata.EndPoint;
 import com.datastax.oss.driver.api.core.ssl.SslEngineFactory;
+import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.io.InputStream;
 import java.net.InetSocketAddress;
@@ -69,6 +70,7 @@ public class DefaultSslEngineFactory implements SslEngineFactory {
   private final SSLContext sslContext;
   private final String[] cipherSuites;
   private final boolean requireHostnameValidation;
+  private final boolean allowDnsReverseLookupSan;
   private ReloadingKeyManagerFactory kmf;
 
   /** Builds a new instance from the driver configuration. */
@@ -88,6 +90,28 @@ public DefaultSslEngineFactory(DriverContext driverContext) {
     }
     this.requireHostnameValidation =
         config.getBoolean(DefaultDriverOption.SSL_HOSTNAME_VALIDATION, true);
+    this.allowDnsReverseLookupSan =
+        config.getBoolean(DefaultDriverOption.SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN, true);
+  }
+
+  @VisibleForTesting
+  protected String hostname(InetSocketAddress addr) {
+    return allowDnsReverseLookupSan ? hostMaybeFromDnsReverseLookup(addr) : hostNoLookup(addr);
+  }
+
+  @VisibleForTesting
+  protected String hostMaybeFromDnsReverseLookup(InetSocketAddress addr) {
+    // See java.net.InetSocketAddress.getHostName:
+    // "This method may trigger a name service reverse lookup if the address was created with a
+    // literal IP address."
+    return addr.getHostName();
+  }
+
+  @VisibleForTesting
+  protected String hostNoLookup(InetSocketAddress addr) {
+    // See java.net.InetSocketAddress.getHostString:
+    // "This has the benefit of not attempting a reverse lookup"
+    return addr.getHostString();
   }
 
   @NonNull
@@ -97,7 +121,7 @@ public SSLEngine newSslEngine(@NonNull EndPoint remoteEndpoint) {
     SocketAddress remoteAddress = remoteEndpoint.resolve();
     if (remoteAddress instanceof InetSocketAddress) {
       InetSocketAddress socketAddress = (InetSocketAddress) remoteAddress;
-      engine = sslContext.createSSLEngine(socketAddress.getHostName(), socketAddress.getPort());
+      engine = sslContext.createSSLEngine(hostname(socketAddress), socketAddress.getPort());
     } else {
       engine = sslContext.createSSLEngine();
     }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/SniSslEngineFactory.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/SniSslEngineFactory.java
index 98af19045dc..4d2cb69fbfc 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/SniSslEngineFactory.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ssl/SniSslEngineFactory.java
@@ -38,9 +38,15 @@ public class SniSslEngineFactory implements SslEngineFactory {
 
   private final SSLContext sslContext;
   private final CopyOnWriteArrayList<String> fakePorts = new CopyOnWriteArrayList<>();
+  private final boolean allowDnsReverseLookupSan;
 
   public SniSslEngineFactory(SSLContext sslContext) {
+    this(sslContext, true);
+  }
+
+  public SniSslEngineFactory(SSLContext sslContext, boolean allowDnsReverseLookupSan) {
     this.sslContext = sslContext;
+    this.allowDnsReverseLookupSan = allowDnsReverseLookupSan;
   }
 
   @NonNull
@@ -71,8 +77,8 @@ public SSLEngine newSslEngine(@NonNull EndPoint remoteEndpoint) {
     // To avoid that, we create a unique "fake" port for every node. We still get session reuse for
     // a given node, but not across nodes. This is safe because the advisory port is only used for
     // session caching.
-    SSLEngine engine =
-        sslContext.createSSLEngine(address.getHostName(), getFakePort(sniServerName));
+    String peerHost = allowDnsReverseLookupSan ? address.getHostName() : address.getHostString();
+    SSLEngine engine = sslContext.createSSLEngine(peerHost, getFakePort(sniServerName));
     engine.setUseClientMode(true);
     SSLParameters parameters = engine.getSSLParameters();
     parameters.setServerNames(ImmutableList.of(new SNIHostName(sniServerName)));
diff --git a/core/src/main/resources/reference.conf b/core/src/main/resources/reference.conf
index 7b1c43f8bea..f09ffd18a10 100644
--- a/core/src/main/resources/reference.conf
+++ b/core/src/main/resources/reference.conf
@@ -789,6 +789,12 @@ datastax-java-driver {
     # name matches the hostname of the server being connected to. If not set, defaults to true.
     // hostname-validation = true
 
+    # Whether or not to allow a DNS reverse-lookup of provided server addresses for SAN addresses,
+    # if cluster endpoints are specified as literal IPs.
+    # This is left as true for compatibility, but in most environments a DNS reverse-lookup should
+    # not be necessary to get an address that matches the server certificate SANs.
+    // allow-dns-reverse-lookup-san = true
+
     # The locations and passwords used to access truststore and keystore contents.
     # These properties are optional. If either truststore-path or keystore-path are specified,
     # the driver builds an SSLContext from these files.  If neither option is specified, the
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/ssl/DefaultSslEngineFactoryIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/ssl/DefaultSslEngineFactoryIT.java
index 5f97e661eb1..a2afeade3ce 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/ssl/DefaultSslEngineFactoryIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/ssl/DefaultSslEngineFactoryIT.java
@@ -21,10 +21,13 @@
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.api.core.context.DriverContext;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmBridge;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
+import com.datastax.oss.driver.assertions.Assertions;
 import com.datastax.oss.driver.internal.core.ssl.DefaultSslEngineFactory;
+import java.net.InetSocketAddress;
 import org.junit.ClassRule;
 import org.junit.Test;
 
@@ -88,4 +91,67 @@ public void should_not_connect_if_not_using_ssl() {
       session.execute("select * from system.local");
     }
   }
+
+  public static class InstrumentedSslEngineFactory extends DefaultSslEngineFactory {
+    int countReverseLookups = 0;
+    int countNoLookups = 0;
+
+    public InstrumentedSslEngineFactory(DriverContext driverContext) {
+      super(driverContext);
+    }
+
+    @Override
+    protected String hostMaybeFromDnsReverseLookup(InetSocketAddress addr) {
+      countReverseLookups++;
+      return super.hostMaybeFromDnsReverseLookup(addr);
+    }
+
+    @Override
+    protected String hostNoLookup(InetSocketAddress addr) {
+      countNoLookups++;
+      return super.hostNoLookup(addr);
+    }
+  };
+
+  @Test
+  public void should_respect_config_for_san_resolution() {
+    DriverConfigLoader loader =
+        SessionUtils.configLoaderBuilder()
+            .withClass(
+                DefaultDriverOption.SSL_ENGINE_FACTORY_CLASS, InstrumentedSslEngineFactory.class)
+            .withBoolean(DefaultDriverOption.SSL_HOSTNAME_VALIDATION, false)
+            .withString(
+                DefaultDriverOption.SSL_TRUSTSTORE_PATH,
+                CcmBridge.DEFAULT_CLIENT_TRUSTSTORE_FILE.getAbsolutePath())
+            .withString(
+                DefaultDriverOption.SSL_TRUSTSTORE_PASSWORD,
+                CcmBridge.DEFAULT_CLIENT_TRUSTSTORE_PASSWORD)
+            .build();
+    try (CqlSession session = SessionUtils.newSession(CCM_RULE, loader)) {
+      InstrumentedSslEngineFactory ssl =
+          (InstrumentedSslEngineFactory) session.getContext().getSslEngineFactory().get();
+      Assertions.assertThat(ssl.countReverseLookups).isGreaterThan(0);
+      Assertions.assertThat(ssl.countNoLookups).isEqualTo(0);
+    }
+
+    loader =
+        SessionUtils.configLoaderBuilder()
+            .withClass(
+                DefaultDriverOption.SSL_ENGINE_FACTORY_CLASS, InstrumentedSslEngineFactory.class)
+            .withBoolean(DefaultDriverOption.SSL_HOSTNAME_VALIDATION, false)
+            .withString(
+                DefaultDriverOption.SSL_TRUSTSTORE_PATH,
+                CcmBridge.DEFAULT_CLIENT_TRUSTSTORE_FILE.getAbsolutePath())
+            .withString(
+                DefaultDriverOption.SSL_TRUSTSTORE_PASSWORD,
+                CcmBridge.DEFAULT_CLIENT_TRUSTSTORE_PASSWORD)
+            .withBoolean(DefaultDriverOption.SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN, false)
+            .build();
+    try (CqlSession session = SessionUtils.newSession(CCM_RULE, loader)) {
+      InstrumentedSslEngineFactory ssl =
+          (InstrumentedSslEngineFactory) session.getContext().getSslEngineFactory().get();
+      Assertions.assertThat(ssl.countReverseLookups).isEqualTo(0);
+      Assertions.assertThat(ssl.countNoLookups).isGreaterThan(0);
+    }
+  }
 }

From 7982f413a90935a91549aa3ee7cc64fa25d7c113 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Mon, 3 Mar 2025 11:46:42 -0600
Subject: [PATCH 068/126] ninja-fix Minor fix to CASSJAVA-80 change.  Adding
 new entries to DefaultDriverOption anywhere other than at the end messes with
 the ordinal guarantees for exisitng apps.  We have a check for such a thing
 in the build; moving this around avoids that concern.

---
 .../api/core/config/DefaultDriverOption.java       | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
index acd4bb9cc1d..6ffd51d86ef 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
@@ -243,12 +243,6 @@ public enum DefaultDriverOption implements DriverOption {
    * <p>Value-type: boolean
    */
   SSL_HOSTNAME_VALIDATION("advanced.ssl-engine-factory.hostname-validation"),
-  /**
-   * Whether or not to do a DNS reverse-lookup of provided server addresses for SAN addresses.
-   *
-   * <p>Value-type: boolean
-   */
-  SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN("advanced.ssl-engine-factory.allow-dns-reverse-lookup-san"),
   /**
    * The location of the keystore file.
    *
@@ -994,7 +988,13 @@ public enum DefaultDriverOption implements DriverOption {
    * <p>Value type: {@link java.util.List List}&#60;{@link String}&#62;
    */
   LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS(
-      "advanced.load-balancing-policy.dc-failover.preferred-remote-dcs");
+      "advanced.load-balancing-policy.dc-failover.preferred-remote-dcs"),
+  /**
+   * Whether or not to do a DNS reverse-lookup of provided server addresses for SAN addresses.
+   *
+   * <p>Value-type: boolean
+   */
+  SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN("advanced.ssl-engine-factory.allow-dns-reverse-lookup-san");
 
   private final String path;
 

From c0cae9bf76024f8004abaa1ddb871b7351fc253e Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Tue, 25 Mar 2025 15:27:55 -0500
Subject: [PATCH 069/126] CASSJAVA-90 Update native-protocol version

patch by Bret McGuire; reviewed by Abe Ratnofsky and Bret McGuire for CASSJAVA-90
---
 bom/pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 8e7bc467fe7..f03317edc03 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -78,7 +78,7 @@
       <dependency>
         <groupId>com.datastax.oss</groupId>
         <artifactId>native-protocol</artifactId>
-        <version>1.5.1</version>
+        <version>1.5.2</version>
       </dependency>
     </dependencies>
   </dependencyManagement>

From 204dd09329a073043b5b7cc170a9850e270c5a63 Mon Sep 17 00:00:00 2001
From: janehe <siyaoh4@uci.edu>
Date: Mon, 31 Mar 2025 13:24:31 -0700
Subject: [PATCH 070/126] CASSJAVA-40: Driver testing against Java 21 patch by
 Jane He; reviewed by Bret McGuire for CASSJAVA-40

---
 Jenkinsfile-asf                                     |  4 ++--
 .../oss/driver/internal/core/util/ArrayUtils.java   |  3 ++-
 .../internal/core/cql/QueryTraceFetcherTest.java    |  2 +-
 .../driver/internal/core/util/ArrayUtilsTest.java   |  4 ++--
 pom.xml                                             | 13 +++++++++++++
 5 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/Jenkinsfile-asf b/Jenkinsfile-asf
index 0217d0455d6..d6318585489 100644
--- a/Jenkinsfile-asf
+++ b/Jenkinsfile-asf
@@ -35,7 +35,7 @@ pipeline {
                 axes {
                     axis {
                         name 'TEST_JAVA_VERSION'
-                        values  'openjdk@1.8.0-292', 'openjdk@1.11.0-9', 'openjdk@17'
+                        values  'openjdk@1.8.0-292', 'openjdk@1.11.0-9', 'openjdk@17', 'openjdk@1.21.0'
                     }
                     axis {
                         name 'SERVER_VERSION'
@@ -67,7 +67,7 @@ pipeline {
 def executeTests() {
     def testJavaMajorVersion = (TEST_JAVA_VERSION =~ /@(?:1\.)?(\d+)/)[0][1]
     sh """
-        container_id=\$(docker run -td -e TEST_JAVA_VERSION=${TEST_JAVA_VERSION} -e SERVER_VERSION=${SERVER_VERSION} -e TEST_JAVA_MAJOR_VERSION=${testJavaMajorVersion} -v \$(pwd):/home/docker/cassandra-java-driver apache.jfrog.io/cassan-docker/apache/cassandra-java-driver-testing-ubuntu2204 'sleep 2h')
+        container_id=\$(docker run -td -e TEST_JAVA_VERSION=${TEST_JAVA_VERSION} -e SERVER_VERSION=${SERVER_VERSION} -e TEST_JAVA_MAJOR_VERSION=${testJavaMajorVersion} -v \$(pwd):/home/docker/cassandra-java-driver janehe158/cassandra-java-driver-dev-env 'sleep 2h')
         docker exec --user root \$container_id bash -c \"sudo bash /home/docker/cassandra-java-driver/ci/create-user.sh docker \$(id -u) \$(id -g) /home/docker/cassandra-java-driver\"
         docker exec --user docker \$container_id './cassandra-java-driver/ci/run-tests.sh'
         ( nohup docker stop \$container_id >/dev/null 2>/dev/null & )
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/util/ArrayUtils.java b/core/src/main/java/com/datastax/oss/driver/internal/core/util/ArrayUtils.java
index f5fcb98e8b7..490b1dc7d17 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/util/ArrayUtils.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/util/ArrayUtils.java
@@ -18,6 +18,7 @@
 package com.datastax.oss.driver.internal.core.util;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
+import java.util.Random;
 import java.util.concurrent.ThreadLocalRandom;
 
 public class ArrayUtils {
@@ -77,7 +78,7 @@ public static <ElementT> void shuffleHead(@NonNull ElementT[] elements, int n) {
    *     Fisher-Yates shuffle</a>
    */
   public static <ElementT> void shuffleHead(
-      @NonNull ElementT[] elements, int n, @NonNull ThreadLocalRandom random) {
+      @NonNull ElementT[] elements, int n, @NonNull Random random) {
     if (n > elements.length) {
       throw new ArrayIndexOutOfBoundsException(
           String.format(
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/cql/QueryTraceFetcherTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/cql/QueryTraceFetcherTest.java
index b355e0fc9f0..dc238775bc1 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/cql/QueryTraceFetcherTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/cql/QueryTraceFetcherTest.java
@@ -79,7 +79,7 @@ public class QueryTraceFetcherTest {
   @Mock private NettyOptions nettyOptions;
   @Mock private EventExecutorGroup adminEventExecutorGroup;
   @Mock private EventExecutor eventExecutor;
-  @Mock private InetAddress address;
+  private InetAddress address = InetAddress.getLoopbackAddress();
 
   @Captor private ArgumentCaptor<SimpleStatement> statementCaptor;
 
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/util/ArrayUtilsTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/util/ArrayUtilsTest.java
index c2a7fb70304..c2df6449fdb 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/util/ArrayUtilsTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/util/ArrayUtilsTest.java
@@ -22,7 +22,7 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-import java.util.concurrent.ThreadLocalRandom;
+import java.util.Random;
 import org.junit.Test;
 
 public class ArrayUtilsTest {
@@ -86,7 +86,7 @@ public void should_not_bubble_down_when_target_index_lower() {
   @Test
   public void should_shuffle_head() {
     String[] array = {"a", "b", "c", "d", "e"};
-    ThreadLocalRandom random = mock(ThreadLocalRandom.class);
+    Random random = mock(Random.class);
     when(random.nextInt(anyInt()))
         .thenAnswer(
             (invocation) -> {
diff --git a/pom.xml b/pom.xml
index 3fd2d1347c2..088d7b07532 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1016,6 +1016,19 @@ limitations under the License.]]></inlineHeader>
         <mockitoopens.argline>--add-opens java.base/jdk.internal.util.random=ALL-UNNAMED</mockitoopens.argline>
       </properties>
     </profile>
+    <profile>
+      <!-- workarounds for running tests with JDK21 -->
+      <id>test-jdk-21</id>
+      <activation>
+        <jdk>[21,)</jdk>
+      </activation>
+      <properties>
+        <!-- for DriverBlockHoundIntegrationIT when using JDK 13+, see https://github.com/reactor/BlockHound/issues/33 -->
+        <blockhound.argline>-XX:+AllowRedefinitionToAddDeleteMethods</blockhound.argline>
+        <!-- allow deep reflection for mockito when using JDK 17+, see https://stackoverflow.com/questions/70993863/mockito-can-not-mock-random-in-java-17 -->
+        <mockitoopens.argline>--add-opens=java.base/jdk.internal.util.random=ALL-UNNAMED</mockitoopens.argline>
+      </properties>
+    </profile>
   </profiles>
   <licenses>
     <license>

From 529d56e1742dcd1df3ca55c00fd8e02c0e484c68 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Mon, 31 Mar 2025 16:00:18 -0500
Subject: [PATCH 071/126] Add support for Java21 builds to test runs (plus a
 few other small cleanups)

patch by Bret McGuire; reviewed by Joao Reis for CASSJAVA-40
---
 Jenkinsfile-datastax | 50 ++++++++++++--------------------------------
 1 file changed, 13 insertions(+), 37 deletions(-)

diff --git a/Jenkinsfile-datastax b/Jenkinsfile-datastax
index cd48f325a29..af1aab6e0f4 100644
--- a/Jenkinsfile-datastax
+++ b/Jenkinsfile-datastax
@@ -19,22 +19,15 @@
  */
 
 def initializeEnvironment() {
-  env.DRIVER_DISPLAY_NAME = 'CassandraⓇ Java Driver'
+  env.DRIVER_DISPLAY_NAME = 'Java Driver for Apache CassandraⓇ'
   env.DRIVER_METRIC_TYPE = 'oss'
-  if (env.GIT_URL.contains('riptano/java-driver')) {
-    env.DRIVER_DISPLAY_NAME = 'private ' + env.DRIVER_DISPLAY_NAME
-    env.DRIVER_METRIC_TYPE = 'oss-private'
-  } else if (env.GIT_URL.contains('java-dse-driver')) {
-    env.DRIVER_DISPLAY_NAME = 'DSE Java Driver'
-    env.DRIVER_METRIC_TYPE = 'dse'
-  }
 
   env.GIT_SHA = "${env.GIT_COMMIT.take(7)}"
   env.GITHUB_PROJECT_URL = "https://${GIT_URL.replaceFirst(/(git@|http:\/\/|https:\/\/)/, '').replace(':', '/').replace('.git', '')}"
   env.GITHUB_BRANCH_URL = "${GITHUB_PROJECT_URL}/tree/${env.BRANCH_NAME}"
   env.GITHUB_COMMIT_URL = "${GITHUB_PROJECT_URL}/commit/${env.GIT_COMMIT}"
 
-  env.MAVEN_HOME = "${env.HOME}/.mvn/apache-maven-3.3.9"
+  env.MAVEN_HOME = "${env.HOME}/.mvn/apache-maven-3.6.3"
   env.PATH = "${env.MAVEN_HOME}/bin:${env.PATH}"
 
   /*
@@ -335,14 +328,12 @@ pipeline {
                       </table>''')
     choice(
       name: 'ADHOC_BUILD_AND_EXECUTE_TESTS_JABBA_VERSION',
-      choices: ['1.8',           // Oracle JDK version 1.8 (current default)
-                'openjdk@1.9',   // OpenJDK version 9
-                'openjdk@1.10',  // OpenJDK version 10
+      choices: [
+                '1.8',           // Oracle JDK version 1.8 (current default)
                 'openjdk@1.11',  // OpenJDK version 11
-                'openjdk@1.12',  // OpenJDK version 12
-                'openjdk@1.13',  // OpenJDK version 13
-                'openjdk@1.14',  // OpenJDK version 14
-                'openjdk@1.17'], // OpenJDK version 17
+                'openjdk@1.17',  // OpenJDK version 17
+                'openjdk@1.21'   // OpenJDK version 21
+                ],
       description: '''JDK version to use for <b>TESTING</b> when running adhoc <b>BUILD-AND-EXECUTE-TESTS</b> builds. <i>All builds will use JDK8 for building the driver</i>
                       <table style="width:100%">
                         <col width="15%">
@@ -355,34 +346,18 @@ pipeline {
                           <td><strong>1.8</strong></td>
                           <td>Oracle JDK version 1.8 (<i>Used for compiling regardless of choice</i>)</td>
                         </tr>
-                        <tr>
-                          <td><strong>openjdk@1.9</strong></td>
-                          <td>OpenJDK version 9</td>
-                        </tr>
-                        <tr>
-                          <td><strong>openjdk@1.10</strong></td>
-                          <td>OpenJDK version 10</td>
-                        </tr>
                         <tr>
                           <td><strong>openjdk@1.11</strong></td>
                           <td>OpenJDK version 11</td>
                         </tr>
-                        <tr>
-                          <td><strong>openjdk@1.12</strong></td>
-                          <td>OpenJDK version 12</td>
-                        </tr>
-                        <tr>
-                          <td><strong>openjdk@1.13</strong></td>
-                          <td>OpenJDK version 13</td>
-                        </tr>
-                        <tr>
-                          <td><strong>openjdk@1.14</strong></td>
-                          <td>OpenJDK version 14</td>
-                        </tr>
                         <tr>
                           <td><strong>openjdk@1.17</strong></td>
                           <td>OpenJDK version 17</td>
                         </tr>
+                        <tr>
+                          <td><strong>openjdk@1.21</strong></td>
+                          <td>OpenJDK version 21</td>
+                        </tr>
                       </table>''')
     booleanParam(
       name: 'SKIP_SERIAL_ITS',
@@ -466,7 +441,8 @@ pipeline {
             name 'JABBA_VERSION'
             values '1.8',           // jdk8
                    'openjdk@1.11',  // jdk11
-                   'openjdk@1.17'   // jdk17
+                   'openjdk@1.17',  // jdk17
+                   'openjdk@1.21'   // jdk21
           }
         }
 

From f42ab99ccc031bca7db6cf69aec70771d65799e1 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <abe@aber.io>
Date: Mon, 10 Feb 2025 13:11:06 -0500
Subject: [PATCH 072/126] Upgrade Netty to 4.1.119

patch by Abe Ratnofsky; reviewed by Bret McGuire for CASSJAVA-77
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 088d7b07532..a8841a9caca 100644
--- a/pom.xml
+++ b/pom.xml
@@ -57,7 +57,7 @@
     <!-- when changing version also update version in LICENSE_binary  -->
     <hdrhistogram.version>2.1.12</hdrhistogram.version>
     <metrics.version>4.1.18</metrics.version>
-    <netty.version>4.1.94.Final</netty.version>
+    <netty.version>4.1.119.Final</netty.version>
     <esri.version>1.2.1</esri.version>
     <!--
     When upgrading TinkerPop please upgrade the version matrix in

From c43efd42cbe2b33e129578902e3ae21627d0fd1a Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Wed, 9 Apr 2025 00:29:46 -0500
Subject: [PATCH 073/126] ninja-fix Update revapi to key off of the artifact ID
 (and group ID)

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index a8841a9caca..c69dabb84ce 100644
--- a/pom.xml
+++ b/pom.xml
@@ -575,7 +575,7 @@
             </analysisConfiguration>
             <oldArtifacts>
               <!-- The previous release used DataStax groupId, remove this after the next release -->
-              <artifact>com.datastax.oss:${project.artifactId}:RELEASE</artifact>
+              <artifact>${project.groupId}:${project.artifactId}:RELEASE</artifact>
             </oldArtifacts>
           </configuration>
           <dependencies>

From 0115cd67c18835b89d8888d405d455045737a630 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Fri, 11 Apr 2025 13:19:45 +0200
Subject: [PATCH 074/126] Prevent long overflow in SNI address resolution

patch by Lukasz Antoniak and Alexandre Dutra; reviewed by Bret McGuire
---
 .../oss/driver/internal/core/metadata/SniEndPoint.java   | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/SniEndPoint.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/SniEndPoint.java
index ace4e82617d..d1ab8eec98d 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/SniEndPoint.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/SniEndPoint.java
@@ -26,10 +26,10 @@
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Objects;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class SniEndPoint implements EndPoint {
-  private static final AtomicLong OFFSET = new AtomicLong();
+  private static final AtomicInteger OFFSET = new AtomicInteger();
 
   private final InetSocketAddress proxyAddress;
   private final String serverName;
@@ -64,7 +64,10 @@ public InetSocketAddress resolve() {
       // The order of the returned address is unspecified. Sort by IP to make sure we get a true
       // round-robin
       Arrays.sort(aRecords, IP_COMPARATOR);
-      int index = (aRecords.length == 1) ? 0 : (int) OFFSET.getAndIncrement() % aRecords.length;
+      int index =
+          (aRecords.length == 1)
+              ? 0
+              : OFFSET.getAndUpdate(x -> x == Integer.MAX_VALUE ? 0 : x + 1) % aRecords.length;
       return new InetSocketAddress(aRecords[index], proxyAddress.getPort());
     } catch (UnknownHostException e) {
       throw new IllegalArgumentException(

From 7161d12fb28d16e2928cfe98bbada151ff6ae058 Mon Sep 17 00:00:00 2001
From: janehe <siyaoh4@uci.edu>
Date: Wed, 23 Apr 2025 22:25:03 -0700
Subject: [PATCH 075/126] ninja-fix Revert docker image name (CASSJAVA-40)

---
 Jenkinsfile-asf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Jenkinsfile-asf b/Jenkinsfile-asf
index d6318585489..24800ba9051 100644
--- a/Jenkinsfile-asf
+++ b/Jenkinsfile-asf
@@ -67,7 +67,7 @@ pipeline {
 def executeTests() {
     def testJavaMajorVersion = (TEST_JAVA_VERSION =~ /@(?:1\.)?(\d+)/)[0][1]
     sh """
-        container_id=\$(docker run -td -e TEST_JAVA_VERSION=${TEST_JAVA_VERSION} -e SERVER_VERSION=${SERVER_VERSION} -e TEST_JAVA_MAJOR_VERSION=${testJavaMajorVersion} -v \$(pwd):/home/docker/cassandra-java-driver janehe158/cassandra-java-driver-dev-env 'sleep 2h')
+        container_id=\$(docker run -td -e TEST_JAVA_VERSION=${TEST_JAVA_VERSION} -e SERVER_VERSION=${SERVER_VERSION} -e TEST_JAVA_MAJOR_VERSION=${testJavaMajorVersion} -v \$(pwd):/home/docker/cassandra-java-driver apache.jfrog.io/cassan-docker/apache/cassandra-java-driver-testing-ubuntu2204 'sleep 2h')
         docker exec --user root \$container_id bash -c \"sudo bash /home/docker/cassandra-java-driver/ci/create-user.sh docker \$(id -u) \$(id -g) /home/docker/cassandra-java-driver\"
         docker exec --user docker \$container_id './cassandra-java-driver/ci/run-tests.sh'
         ( nohup docker stop \$container_id >/dev/null 2>/dev/null & )

From d7e829775c4956d10c888c86b653f7ac2d10fa4b Mon Sep 17 00:00:00 2001
From: Andy Tolbert <6889771+tolbertam@users.noreply.github.com>
Date: Thu, 6 Feb 2025 14:57:52 -0600
Subject: [PATCH 076/126] Make guava an optional dependency of
 java-driver-guava-shaded

With CASSJAVA-52, the java-driver-guava-shaded is now in tree.

This appears to work great, but there is a slight issue with the
dependency tree that allows unshaded guava packages to be imported
within the project.

It looks like marking guava as an optional dependency in
java-driver-guava-shaded resolves this.

patch by Andy Tolbert; reviewed by Alexandre Dutra and Dmitry Konstantinov for CASSJAVA-76
---
 guava-shaded/pom.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 8053af94911..ed37e861a96 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -46,6 +46,7 @@
           <artifactId>error_prone_annotations</artifactId>
         </exclusion>
       </exclusions>
+      <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.graalvm.nativeimage</groupId>

From eb54934d5d2f38757da3a94a8ad4960f66eb4bd6 Mon Sep 17 00:00:00 2001
From: Tatu Saloranta <tatu.saloranta@iki.fi>
Date: Fri, 15 Nov 2024 19:01:32 -0800
Subject: [PATCH 077/126] Bump Jackson version to la(te)st 2.13, 2.13.5

patch by Tatu Saloranta; reviewed by Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1989
---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index c69dabb84ce..e5cfb58f94d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -69,8 +69,8 @@
     <!-- when changing version also update version in LICENSE_binary  -->
     <reactive-streams.version>1.0.3</reactive-streams.version>
     <json.version>20230227</json.version>
-    <jackson.version>2.13.4</jackson.version>
-    <jackson-databind.version>2.13.4.2</jackson-databind.version>
+    <jackson.version>2.13.5</jackson.version>
+    <jackson-databind.version>${jackson.version}</jackson-databind.version>
     <!-- optional dependencies -->
     <snappy.version>1.1.10.1</snappy.version>
     <lz4.version>1.7.1</lz4.version>

From 53bb5c8b6580c5797e4f148cdc818885327cd19e Mon Sep 17 00:00:00 2001
From: Tatu Saloranta <tatu.saloranta@datastax.com>
Date: Fri, 15 Nov 2024 18:41:50 -0800
Subject: [PATCH 078/126] CASSJAVA-68 Improve
 DefaultCodecRegisry.CacheKey#hashCode() to eliminate Object[] allocation
 (found via profiler)

patch by Tatu Saloranta; reviewed by Dmitry Konstantinov and Bret McGuire for CASSJAVA-68
---
 .../core/type/codec/registry/DefaultCodecRegistry.java       | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/DefaultCodecRegistry.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/DefaultCodecRegistry.java
index cfd053ea56e..4334f22b63d 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/DefaultCodecRegistry.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/DefaultCodecRegistry.java
@@ -159,7 +159,10 @@ public boolean equals(Object other) {
 
     @Override
     public int hashCode() {
-      return Objects.hash(cqlType, javaType, isJavaCovariant);
+      // NOTE: inlined Objects.hash for performance reasons (avoid Object[] allocation
+      // seen in profiler allocation traces)
+      return ((31 + Objects.hashCode(cqlType)) * 31 + Objects.hashCode(javaType)) * 31
+              + Boolean.hashCode(isJavaCovariant);
     }
   }
 }

From c9facc3c36e7ba0b1d30fb9b10de69f879d34fb5 Mon Sep 17 00:00:00 2001
From: janehe <siyaoh4@uci.edu>
Date: Mon, 5 May 2025 19:37:32 -0700
Subject: [PATCH 079/126] ninja-fix Format fix for previous commit

---
 .../internal/core/type/codec/registry/DefaultCodecRegistry.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/DefaultCodecRegistry.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/DefaultCodecRegistry.java
index 4334f22b63d..cc14740e180 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/DefaultCodecRegistry.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/DefaultCodecRegistry.java
@@ -162,7 +162,7 @@ public int hashCode() {
       // NOTE: inlined Objects.hash for performance reasons (avoid Object[] allocation
       // seen in profiler allocation traces)
       return ((31 + Objects.hashCode(cqlType)) * 31 + Objects.hashCode(javaType)) * 31
-              + Boolean.hashCode(isJavaCovariant);
+          + Boolean.hashCode(isJavaCovariant);
     }
   }
 }

From bb9bb11e573258e12e4272379f88e4d8b5f103a0 Mon Sep 17 00:00:00 2001
From: alexsa <alex.sasnouskikh@adyen.com>
Date: Thu, 12 Jun 2025 10:02:09 +0200
Subject: [PATCH 080/126] Add SubnetAddressTranslator to translate Cassandra
 node IPs from private network based on its subnet mask

patch by Alex Sasnouskikh; reviewed by Bret McGuire and Andy Tolbert
reference: https://github.com/apache/cassandra-java-driver/pull/2013
---
 .../api/core/config/DefaultDriverOption.java  |  43 ++++-
 .../api/core/config/TypedDriverOption.java    |  14 ++
 .../driver/internal/core/ContactPoints.java   |  61 ++----
 .../FixedHostNameAddressTranslator.java       |  20 +-
 .../core/addresstranslation/Subnet.java       | 176 ++++++++++++++++++
 .../addresstranslation/SubnetAddress.java     |  65 +++++++
 .../SubnetAddressTranslator.java              | 148 +++++++++++++++
 .../internal/core/util/AddressUtils.java      |  59 ++++++
 core/src/main/resources/reference.conf        |  18 +-
 .../internal/core/ContactPointsTest.java      |   4 +-
 .../FixedHostNameAddressTranslatorTest.java   |   5 +-
 .../addresstranslation/SubnetAddressTest.java |  44 +++++
 .../SubnetAddressTranslatorTest.java          | 153 +++++++++++++++
 .../core/addresstranslation/SubnetTest.java   | 118 ++++++++++++
 .../internal/core/config/MockOptions.java     |   1 +
 .../typesafe/TypesafeDriverConfigTest.java    |  14 +-
 manual/core/address_resolution/README.md      |  49 +++++
 17 files changed, 923 insertions(+), 69 deletions(-)
 create mode 100644 core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/Subnet.java
 create mode 100644 core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddress.java
 create mode 100644 core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslator.java
 create mode 100644 core/src/main/java/com/datastax/oss/driver/internal/core/util/AddressUtils.java
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTest.java
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslatorTest.java
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetTest.java

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
index 6ffd51d86ef..4e45bf7b117 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
@@ -994,7 +994,48 @@ public enum DefaultDriverOption implements DriverOption {
    *
    * <p>Value-type: boolean
    */
-  SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN("advanced.ssl-engine-factory.allow-dns-reverse-lookup-san");
+  SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN("advanced.ssl-engine-factory.allow-dns-reverse-lookup-san"),
+  /**
+   * An address to always translate all node addresses to that same proxy hostname no matter what IP
+   * address a node has, but still using its native transport port.
+   *
+   * <p>Value-Type: {@link String}
+   */
+  ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME("advanced.address-translator.advertised-hostname"),
+  /**
+   * A map of Cassandra node subnets (CIDR notations) to target addresses, for example (note quoted
+   * keys):
+   *
+   * <pre>
+   * advanced.address-translator.subnet-addresses {
+   *   "100.64.0.0/15" = "cassandra.datacenter1.com:9042"
+   *   "100.66.0.0/15" = "cassandra.datacenter2.com:9042"
+   *   # IPv6 example:
+   *   # "::ffff:6440:0/111" = "cassandra.datacenter1.com:9042"
+   *   # "::ffff:6442:0/111" = "cassandra.datacenter2.com:9042"
+   * }
+   * </pre>
+   *
+   * Note: subnets must be represented as prefix blocks, see {@link
+   * inet.ipaddr.Address#isPrefixBlock()}.
+   *
+   * <p>Value type: {@link java.util.Map Map}&#60;{@link String},{@link String}&#62;
+   */
+  ADDRESS_TRANSLATOR_SUBNET_ADDRESSES("advanced.address-translator.subnet-addresses"),
+  /**
+   * A default address to fallback to if Cassandra node IP isn't contained in any of the configured
+   * subnets.
+   *
+   * <p>Value-Type: {@link String}
+   */
+  ADDRESS_TRANSLATOR_DEFAULT_ADDRESS("advanced.address-translator.default-address"),
+  /**
+   * Whether to resolve the addresses on initialization (if true) or on each node (re-)connection
+   * (if false). Defaults to false.
+   *
+   * <p>Value-Type: boolean
+   */
+  ADDRESS_TRANSLATOR_RESOLVE_ADDRESSES("advanced.address-translator.resolve-addresses");
 
   private final String path;
 
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
index 93e2b468461..aa4e4af12dc 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
@@ -896,6 +896,20 @@ public String toString() {
               DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_ALLOW_FOR_LOCAL_CONSISTENCY_LEVELS,
               GenericType.BOOLEAN);
 
+  public static final TypedDriverOption<String> ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME =
+      new TypedDriverOption<>(
+          DefaultDriverOption.ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME, GenericType.STRING);
+  public static final TypedDriverOption<Map<String, String>> ADDRESS_TRANSLATOR_SUBNET_ADDRESSES =
+      new TypedDriverOption<>(
+          DefaultDriverOption.ADDRESS_TRANSLATOR_SUBNET_ADDRESSES,
+          GenericType.mapOf(GenericType.STRING, GenericType.STRING));
+  public static final TypedDriverOption<String> ADDRESS_TRANSLATOR_DEFAULT_ADDRESS =
+      new TypedDriverOption<>(
+          DefaultDriverOption.ADDRESS_TRANSLATOR_DEFAULT_ADDRESS, GenericType.STRING);
+  public static final TypedDriverOption<Boolean> ADDRESS_TRANSLATOR_RESOLVE_ADDRESSES =
+      new TypedDriverOption<>(
+          DefaultDriverOption.ADDRESS_TRANSLATOR_RESOLVE_ADDRESSES, GenericType.BOOLEAN);
+
   /**
    * Ordered preference list of remote dcs optionally supplied for automatic failover and included
    * in query plan. This feature is enabled only when max-nodes-per-remote-dc is greater than 0.
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/ContactPoints.java b/core/src/main/java/com/datastax/oss/driver/internal/core/ContactPoints.java
index 1ed2a1cebf3..bb65661b72f 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/ContactPoints.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/ContactPoints.java
@@ -19,14 +19,11 @@
 
 import com.datastax.oss.driver.api.core.metadata.EndPoint;
 import com.datastax.oss.driver.internal.core.metadata.DefaultEndPoint;
+import com.datastax.oss.driver.internal.core.util.AddressUtils;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableSet;
 import com.datastax.oss.driver.shaded.guava.common.collect.Sets;
-import java.net.InetAddress;
 import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
-import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import org.slf4j.Logger;
@@ -41,7 +38,22 @@ public static Set<EndPoint> merge(
 
     Set<EndPoint> result = Sets.newHashSet(programmaticContactPoints);
     for (String spec : configContactPoints) {
-      for (InetSocketAddress address : extract(spec, resolve)) {
+
+      Set<InetSocketAddress> addresses = Collections.emptySet();
+      try {
+        addresses = AddressUtils.extract(spec, resolve);
+      } catch (RuntimeException e) {
+        LOG.warn("Ignoring invalid contact point {} ({})", spec, e.getMessage(), e);
+      }
+
+      if (addresses.size() > 1) {
+        LOG.info(
+            "Contact point {} resolves to multiple addresses, will use them all ({})",
+            spec,
+            addresses);
+      }
+
+      for (InetSocketAddress address : addresses) {
         DefaultEndPoint endPoint = new DefaultEndPoint(address);
         boolean wasNew = result.add(endPoint);
         if (!wasNew) {
@@ -51,43 +63,4 @@ public static Set<EndPoint> merge(
     }
     return ImmutableSet.copyOf(result);
   }
-
-  private static Set<InetSocketAddress> extract(String spec, boolean resolve) {
-    int separator = spec.lastIndexOf(':');
-    if (separator < 0) {
-      LOG.warn("Ignoring invalid contact point {} (expecting host:port)", spec);
-      return Collections.emptySet();
-    }
-
-    String host = spec.substring(0, separator);
-    String portSpec = spec.substring(separator + 1);
-    int port;
-    try {
-      port = Integer.parseInt(portSpec);
-    } catch (NumberFormatException e) {
-      LOG.warn("Ignoring invalid contact point {} (expecting a number, got {})", spec, portSpec);
-      return Collections.emptySet();
-    }
-    if (!resolve) {
-      return ImmutableSet.of(InetSocketAddress.createUnresolved(host, port));
-    } else {
-      try {
-        InetAddress[] inetAddresses = InetAddress.getAllByName(host);
-        if (inetAddresses.length > 1) {
-          LOG.info(
-              "Contact point {} resolves to multiple addresses, will use them all ({})",
-              spec,
-              Arrays.deepToString(inetAddresses));
-        }
-        Set<InetSocketAddress> result = new HashSet<>();
-        for (InetAddress inetAddress : inetAddresses) {
-          result.add(new InetSocketAddress(inetAddress, port));
-        }
-        return result;
-      } catch (UnknownHostException e) {
-        LOG.warn("Ignoring invalid contact point {} (unknown host {})", spec, host);
-        return Collections.emptySet();
-      }
-    }
-  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslator.java b/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslator.java
index 4fb9782f566..5cc6c2518fb 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslator.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslator.java
@@ -17,8 +17,9 @@
  */
 package com.datastax.oss.driver.internal.core.addresstranslation;
 
+import static com.datastax.oss.driver.api.core.config.DefaultDriverOption.ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME;
+
 import com.datastax.oss.driver.api.core.addresstranslation.AddressTranslator;
-import com.datastax.oss.driver.api.core.config.DriverOption;
 import com.datastax.oss.driver.api.core.context.DriverContext;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.net.InetSocketAddress;
@@ -37,28 +38,13 @@ public class FixedHostNameAddressTranslator implements AddressTranslator {
 
   private static final Logger LOG = LoggerFactory.getLogger(FixedHostNameAddressTranslator.class);
 
-  public static final String ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME =
-      "advanced.address-translator.advertised-hostname";
-
-  public static DriverOption ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME_OPTION =
-      new DriverOption() {
-        @NonNull
-        @Override
-        public String getPath() {
-          return ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME;
-        }
-      };
-
   private final String advertisedHostname;
   private final String logPrefix;
 
   public FixedHostNameAddressTranslator(@NonNull DriverContext context) {
     logPrefix = context.getSessionName();
     advertisedHostname =
-        context
-            .getConfig()
-            .getDefaultProfile()
-            .getString(ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME_OPTION);
+        context.getConfig().getDefaultProfile().getString(ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME);
   }
 
   @NonNull
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/Subnet.java b/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/Subnet.java
new file mode 100644
index 00000000000..7c25e94e2f9
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/Subnet.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.addresstranslation;
+
+import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
+import com.datastax.oss.driver.shaded.guava.common.base.Splitter;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.List;
+
+class Subnet {
+  private final byte[] subnet;
+  private final byte[] networkMask;
+  private final byte[] upper;
+  private final byte[] lower;
+
+  private Subnet(byte[] subnet, byte[] networkMask) {
+    this.subnet = subnet;
+    this.networkMask = networkMask;
+
+    byte[] upper = new byte[subnet.length];
+    byte[] lower = new byte[subnet.length];
+    for (int i = 0; i < subnet.length; i++) {
+      upper[i] = (byte) (subnet[i] | ~networkMask[i]);
+      lower[i] = (byte) (subnet[i] & networkMask[i]);
+    }
+    this.upper = upper;
+    this.lower = lower;
+  }
+
+  static Subnet parse(String subnetCIDR) throws UnknownHostException {
+    List<String> parts = Splitter.on("/").splitToList(subnetCIDR);
+    if (parts.size() != 2) {
+      throw new IllegalArgumentException("Invalid subnet: " + subnetCIDR);
+    }
+
+    boolean isIPv6 = parts.get(0).contains(":");
+    byte[] subnet = InetAddress.getByName(parts.get(0)).getAddress();
+    if (isIPv4(subnet) && isIPv6) {
+      subnet = toIPv6(subnet);
+    }
+    int prefixLength = Integer.parseInt(parts.get(1));
+    validatePrefixLength(subnet, prefixLength);
+
+    byte[] networkMask = toNetworkMask(subnet, prefixLength);
+    validateSubnetIsPrefixBlock(subnet, networkMask, subnetCIDR);
+    return new Subnet(subnet, networkMask);
+  }
+
+  private static byte[] toNetworkMask(byte[] subnet, int prefixLength) {
+    int fullBytes = prefixLength / 8;
+    int remainingBits = prefixLength % 8;
+    byte[] mask = new byte[subnet.length];
+    Arrays.fill(mask, 0, fullBytes, (byte) 0xFF);
+    if (remainingBits > 0) {
+      mask[fullBytes] = (byte) (0xFF << (8 - remainingBits));
+    }
+    return mask;
+  }
+
+  private static void validatePrefixLength(byte[] subnet, int prefixLength) {
+    int max_prefix_length = subnet.length * 8;
+    if (prefixLength < 0 || max_prefix_length < prefixLength) {
+      throw new IllegalArgumentException(
+          String.format(
+              "Prefix length %s must be within [0; %s]", prefixLength, max_prefix_length));
+    }
+  }
+
+  private static void validateSubnetIsPrefixBlock(
+      byte[] subnet, byte[] networkMask, String subnetCIDR) {
+    byte[] prefixBlock = toPrefixBlock(subnet, networkMask);
+    if (!Arrays.equals(subnet, prefixBlock)) {
+      throw new IllegalArgumentException(
+          String.format("Subnet %s must be represented as a network prefix block", subnetCIDR));
+    }
+  }
+
+  private static byte[] toPrefixBlock(byte[] subnet, byte[] networkMask) {
+    byte[] prefixBlock = new byte[subnet.length];
+    for (int i = 0; i < subnet.length; i++) {
+      prefixBlock[i] = (byte) (subnet[i] & networkMask[i]);
+    }
+    return prefixBlock;
+  }
+
+  @VisibleForTesting
+  byte[] getSubnet() {
+    return Arrays.copyOf(subnet, subnet.length);
+  }
+
+  @VisibleForTesting
+  byte[] getNetworkMask() {
+    return Arrays.copyOf(networkMask, networkMask.length);
+  }
+
+  byte[] getUpper() {
+    return Arrays.copyOf(upper, upper.length);
+  }
+
+  byte[] getLower() {
+    return Arrays.copyOf(lower, lower.length);
+  }
+
+  boolean isIPv4() {
+    return isIPv4(subnet);
+  }
+
+  boolean isIPv6() {
+    return isIPv6(subnet);
+  }
+
+  boolean contains(byte[] ip) {
+    if (isIPv4() && !isIPv4(ip)) {
+      return false;
+    }
+    if (isIPv6() && isIPv4(ip)) {
+      ip = toIPv6(ip);
+    }
+    if (subnet.length != ip.length) {
+      throw new IllegalArgumentException(
+          "IP version is unknown: " + Arrays.toString(toZeroBasedByteArray(ip)));
+    }
+    for (int i = 0; i < subnet.length; i++) {
+      if (subnet[i] != (byte) (ip[i] & networkMask[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private static boolean isIPv4(byte[] ip) {
+    return ip.length == 4;
+  }
+
+  private static boolean isIPv6(byte[] ip) {
+    return ip.length == 16;
+  }
+
+  private static byte[] toIPv6(byte[] ipv4) {
+    byte[] ipv6 = new byte[16];
+    ipv6[10] = (byte) 0xFF;
+    ipv6[11] = (byte) 0xFF;
+    System.arraycopy(ipv4, 0, ipv6, 12, 4);
+    return ipv6;
+  }
+
+  @Override
+  public String toString() {
+    return Arrays.toString(toZeroBasedByteArray(subnet));
+  }
+
+  private static int[] toZeroBasedByteArray(byte[] bytes) {
+    int[] res = new int[bytes.length];
+    for (int i = 0; i < bytes.length; i++) {
+      res[i] = bytes[i] & 0xFF;
+    }
+    return res;
+  }
+}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddress.java b/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddress.java
new file mode 100644
index 00000000000..105e776a507
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddress.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.addresstranslation;
+
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+
+class SubnetAddress {
+  private final Subnet subnet;
+  private final InetSocketAddress address;
+
+  SubnetAddress(String subnetCIDR, InetSocketAddress address) {
+    try {
+      this.subnet = Subnet.parse(subnetCIDR);
+    } catch (UnknownHostException e) {
+      throw new RuntimeException(e);
+    }
+    this.address = address;
+  }
+
+  InetSocketAddress getAddress() {
+    return this.address;
+  }
+
+  boolean isOverlapping(SubnetAddress other) {
+    Subnet thisSubnet = this.subnet;
+    Subnet otherSubnet = other.subnet;
+    return thisSubnet.contains(otherSubnet.getLower())
+        || thisSubnet.contains(otherSubnet.getUpper())
+        || otherSubnet.contains(thisSubnet.getLower())
+        || otherSubnet.contains(thisSubnet.getUpper());
+  }
+
+  boolean contains(InetSocketAddress address) {
+    return subnet.contains(address.getAddress().getAddress());
+  }
+
+  boolean isIPv4() {
+    return subnet.isIPv4();
+  }
+
+  boolean isIPv6() {
+    return subnet.isIPv6();
+  }
+
+  @Override
+  public String toString() {
+    return "SubnetAddress[subnet=" + subnet + ", address=" + address + "]";
+  }
+}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslator.java b/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslator.java
new file mode 100644
index 00000000000..85f29e3fadd
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslator.java
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.addresstranslation;
+
+import static com.datastax.oss.driver.api.core.config.DefaultDriverOption.ADDRESS_TRANSLATOR_DEFAULT_ADDRESS;
+import static com.datastax.oss.driver.api.core.config.DefaultDriverOption.ADDRESS_TRANSLATOR_RESOLVE_ADDRESSES;
+import static com.datastax.oss.driver.api.core.config.DefaultDriverOption.ADDRESS_TRANSLATOR_SUBNET_ADDRESSES;
+
+import com.datastax.oss.driver.api.core.addresstranslation.AddressTranslator;
+import com.datastax.oss.driver.api.core.context.DriverContext;
+import com.datastax.oss.driver.internal.core.util.AddressUtils;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
+import java.net.InetSocketAddress;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This translator returns the proxy address of the private subnet containing the Cassandra node IP,
+ * or default address if no matching subnets, or passes through the original node address if no
+ * default configured.
+ *
+ * <p>The translator can be used for scenarios when all nodes are behind some kind of proxy, and
+ * that proxy is different for nodes located in different subnets (eg. when Cassandra is deployed in
+ * multiple datacenters/regions). One can use this, for example, for Cassandra on Kubernetes with
+ * different Cassandra datacenters deployed to different Kubernetes clusters.
+ */
+public class SubnetAddressTranslator implements AddressTranslator {
+  private static final Logger LOG = LoggerFactory.getLogger(SubnetAddressTranslator.class);
+
+  private final List<SubnetAddress> subnetAddresses;
+
+  @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+  private final Optional<InetSocketAddress> defaultAddress;
+
+  private final String logPrefix;
+
+  public SubnetAddressTranslator(@NonNull DriverContext context) {
+    logPrefix = context.getSessionName();
+    boolean resolveAddresses =
+        context
+            .getConfig()
+            .getDefaultProfile()
+            .getBoolean(ADDRESS_TRANSLATOR_RESOLVE_ADDRESSES, false);
+    this.subnetAddresses =
+        context.getConfig().getDefaultProfile().getStringMap(ADDRESS_TRANSLATOR_SUBNET_ADDRESSES)
+            .entrySet().stream()
+            .map(
+                e -> {
+                  // Quoted and/or containing forward slashes map keys in reference.conf are read to
+                  // strings with additional quotes, eg. 100.64.0.0/15 -> '100.64.0."0/15"' or
+                  // "100.64.0.0/15" -> '"100.64.0.0/15"'
+                  String subnetCIDR = e.getKey().replaceAll("\"", "");
+                  String address = e.getValue();
+                  return new SubnetAddress(subnetCIDR, parseAddress(address, resolveAddresses));
+                })
+            .collect(Collectors.toList());
+    this.defaultAddress =
+        Optional.ofNullable(
+                context
+                    .getConfig()
+                    .getDefaultProfile()
+                    .getString(ADDRESS_TRANSLATOR_DEFAULT_ADDRESS, null))
+            .map(address -> parseAddress(address, resolveAddresses));
+
+    validateSubnetsAreOfSameProtocol(this.subnetAddresses);
+    validateSubnetsAreNotOverlapping(this.subnetAddresses);
+  }
+
+  private static void validateSubnetsAreOfSameProtocol(List<SubnetAddress> subnets) {
+    for (int i = 0; i < subnets.size() - 1; i++) {
+      for (int j = i + 1; j < subnets.size(); j++) {
+        SubnetAddress subnet1 = subnets.get(i);
+        SubnetAddress subnet2 = subnets.get(j);
+        if (subnet1.isIPv4() != subnet2.isIPv4() && subnet1.isIPv6() != subnet2.isIPv6()) {
+          throw new IllegalArgumentException(
+              String.format(
+                  "Configured subnets are of the different protocols: %s, %s", subnet1, subnet2));
+        }
+      }
+    }
+  }
+
+  private static void validateSubnetsAreNotOverlapping(List<SubnetAddress> subnets) {
+    for (int i = 0; i < subnets.size() - 1; i++) {
+      for (int j = i + 1; j < subnets.size(); j++) {
+        SubnetAddress subnet1 = subnets.get(i);
+        SubnetAddress subnet2 = subnets.get(j);
+        if (subnet1.isOverlapping(subnet2)) {
+          throw new IllegalArgumentException(
+              String.format("Configured subnets are overlapping: %s, %s", subnet1, subnet2));
+        }
+      }
+    }
+  }
+
+  @NonNull
+  @Override
+  public InetSocketAddress translate(@NonNull InetSocketAddress address) {
+    InetSocketAddress translatedAddress = null;
+    for (SubnetAddress subnetAddress : subnetAddresses) {
+      if (subnetAddress.contains(address)) {
+        translatedAddress = subnetAddress.getAddress();
+      }
+    }
+    if (translatedAddress == null && defaultAddress.isPresent()) {
+      translatedAddress = defaultAddress.get();
+    }
+    if (translatedAddress == null) {
+      translatedAddress = address;
+    }
+    LOG.debug("[{}] Translated {} to {}", logPrefix, address, translatedAddress);
+    return translatedAddress;
+  }
+
+  @Override
+  public void close() {}
+
+  @Nullable
+  private InetSocketAddress parseAddress(String address, boolean resolve) {
+    try {
+      InetSocketAddress parsedAddress = AddressUtils.extract(address, resolve).iterator().next();
+      LOG.debug("[{}] Parsed {} to {}", logPrefix, address, parsedAddress);
+      return parsedAddress;
+    } catch (RuntimeException e) {
+      throw new IllegalArgumentException(
+          String.format("Invalid address %s (%s)", address, e.getMessage()), e);
+    }
+  }
+}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/util/AddressUtils.java b/core/src/main/java/com/datastax/oss/driver/internal/core/util/AddressUtils.java
new file mode 100644
index 00000000000..8905edb9192
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/util/AddressUtils.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.util;
+
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableSet;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+import java.util.HashSet;
+import java.util.Set;
+
+public class AddressUtils {
+
+  public static Set<InetSocketAddress> extract(String address, boolean resolve) {
+    int separator = address.lastIndexOf(':');
+    if (separator < 0) {
+      throw new IllegalArgumentException("expecting format host:port");
+    }
+
+    String host = address.substring(0, separator);
+    String portString = address.substring(separator + 1);
+    int port;
+    try {
+      port = Integer.parseInt(portString);
+    } catch (NumberFormatException e) {
+      throw new IllegalArgumentException("expecting port to be a number, got " + portString, e);
+    }
+    if (!resolve) {
+      return ImmutableSet.of(InetSocketAddress.createUnresolved(host, port));
+    } else {
+      InetAddress[] inetAddresses;
+      try {
+        inetAddresses = InetAddress.getAllByName(host);
+      } catch (UnknownHostException e) {
+        throw new RuntimeException(e);
+      }
+      Set<InetSocketAddress> result = new HashSet<>();
+      for (InetAddress inetAddress : inetAddresses) {
+        result.add(new InetSocketAddress(inetAddress, port));
+      }
+      return result;
+    }
+  }
+}
diff --git a/core/src/main/resources/reference.conf b/core/src/main/resources/reference.conf
index f09ffd18a10..3c6851a48ee 100644
--- a/core/src/main/resources/reference.conf
+++ b/core/src/main/resources/reference.conf
@@ -1026,8 +1026,9 @@ datastax-java-driver {
     # the package com.datastax.oss.driver.internal.core.addresstranslation.
     #
     # The driver provides the following implementations out of the box:
-    # - PassThroughAddressTranslator: returns all addresses unchanged
+    # - PassThroughAddressTranslator: returns all addresses unchanged.
     # - FixedHostNameAddressTranslator: translates all addresses to a specific hostname.
+    # - SubnetAddressTranslator: translates addresses to hostname based on the subnet match.
     # - Ec2MultiRegionAddressTranslator: suitable for an Amazon multi-region EC2 deployment where
     #   clients are also deployed in EC2. It optimizes network costs by favoring private IPs over
     #   public ones whenever possible.
@@ -1035,8 +1036,23 @@ datastax-java-driver {
     # You can also specify a custom class that implements AddressTranslator and has a public
     # constructor with a DriverContext argument.
     class = PassThroughAddressTranslator
+    #
     # This property has to be set only in case you use FixedHostNameAddressTranslator.
     # advertised-hostname = mycustomhostname
+    #
+    # These properties are only applicable in case you use SubnetAddressTranslator.
+    # subnet-addresses {
+    #   "100.64.0.0/15" = "cassandra.datacenter1.com:9042"
+    #   "100.66.0.0/15" = "cassandra.datacenter2.com:9042"
+    #   # IPv6 example:
+    #   # "::ffff:6440:0/111" = "cassandra.datacenter1.com:9042"
+    #   # "::ffff:6442:0/111" = "cassandra.datacenter2.com:9042"
+    # }
+    # Optional. When configured, addresses not matching the configured subnets are translated to this address.
+    # default-address = "cassandra.datacenter1.com:9042"
+    # Whether to resolve the addresses once on initialization (if true) or on each node (re-)connection (if false).
+    # If not configured, defaults to false.
+    # resolve-addresses = false
   }
 
   # Whether to resolve the addresses passed to `basic.contact-points`.
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/ContactPointsTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/ContactPointsTest.java
index 9e0d8737619..72b875b8602 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/ContactPointsTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/ContactPointsTest.java
@@ -121,7 +121,7 @@ public void should_ignore_malformed_host_and_port_and_warn() {
         ContactPoints.merge(Collections.emptySet(), ImmutableList.of("foobar"), true);
 
     assertThat(endPoints).isEmpty();
-    assertLog(Level.WARN, "Ignoring invalid contact point foobar (expecting host:port)");
+    assertLog(Level.WARN, "Ignoring invalid contact point foobar (expecting format host:port)");
   }
 
   @Test
@@ -132,7 +132,7 @@ public void should_ignore_malformed_port_and_warn() {
     assertThat(endPoints).isEmpty();
     assertLog(
         Level.WARN,
-        "Ignoring invalid contact point 127.0.0.1:foobar (expecting a number, got foobar)");
+        "Ignoring invalid contact point 127.0.0.1:foobar (expecting port to be a number, got foobar)");
   }
 
   @Test
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslatorTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslatorTest.java
index c5e864b4bae..92800998056 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslatorTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslatorTest.java
@@ -17,6 +17,7 @@
  */
 package com.datastax.oss.driver.internal.core.addresstranslation;
 
+import static com.datastax.oss.driver.api.core.config.DefaultDriverOption.ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -33,9 +34,7 @@ public class FixedHostNameAddressTranslatorTest {
   @Test
   public void should_translate_address() {
     DriverExecutionProfile defaultProfile = mock(DriverExecutionProfile.class);
-    when(defaultProfile.getString(
-            FixedHostNameAddressTranslator.ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME_OPTION))
-        .thenReturn("myaddress");
+    when(defaultProfile.getString(ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME)).thenReturn("myaddress");
     DefaultDriverContext defaultDriverContext =
         MockedDriverContextFactory.defaultDriverContext(Optional.of(defaultProfile));
 
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTest.java
new file mode 100644
index 00000000000..bd505f5dd44
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTest.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.addresstranslation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+import java.net.InetSocketAddress;
+import org.junit.Test;
+
+public class SubnetAddressTest {
+  @Test
+  public void should_return_return_true_on_overlapping_with_another_subnet_address() {
+    SubnetAddress subnetAddress1 =
+        new SubnetAddress("100.64.0.0/15", mock(InetSocketAddress.class));
+    SubnetAddress subnetAddress2 =
+        new SubnetAddress("100.65.0.0/16", mock(InetSocketAddress.class));
+    assertThat(subnetAddress1.isOverlapping(subnetAddress2)).isTrue();
+  }
+
+  @Test
+  public void should_return_return_false_on_not_overlapping_with_another_subnet_address() {
+    SubnetAddress subnetAddress1 =
+        new SubnetAddress("100.64.0.0/15", mock(InetSocketAddress.class));
+    SubnetAddress subnetAddress2 =
+        new SubnetAddress("100.66.0.0/15", mock(InetSocketAddress.class));
+    assertThat(subnetAddress1.isOverlapping(subnetAddress2)).isFalse();
+  }
+}
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslatorTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslatorTest.java
new file mode 100644
index 00000000000..2aa6ae75bc2
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslatorTest.java
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.addresstranslation;
+
+import static com.datastax.oss.driver.api.core.config.DefaultDriverOption.ADDRESS_TRANSLATOR_DEFAULT_ADDRESS;
+import static com.datastax.oss.driver.api.core.config.DefaultDriverOption.ADDRESS_TRANSLATOR_SUBNET_ADDRESSES;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.datastax.oss.driver.api.core.config.DriverExecutionProfile;
+import com.datastax.oss.driver.internal.core.context.DefaultDriverContext;
+import com.datastax.oss.driver.internal.core.context.MockedDriverContextFactory;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
+import java.net.InetSocketAddress;
+import java.util.Map;
+import java.util.Optional;
+import org.junit.Test;
+
+@SuppressWarnings("resource")
+public class SubnetAddressTranslatorTest {
+
+  @Test
+  public void should_translate_to_correct_subnet_address_ipv4() {
+    Map<String, String> subnetAddresses =
+        ImmutableMap.of(
+            "\"100.64.0.0/15\"", "cassandra.datacenter1.com:19042",
+            "100.66.0.\"0/15\"", "cassandra.datacenter2.com:19042");
+    DefaultDriverContext context = context(subnetAddresses);
+    SubnetAddressTranslator translator = new SubnetAddressTranslator(context);
+    InetSocketAddress address = new InetSocketAddress("100.64.0.1", 9042);
+    assertThat(translator.translate(address))
+        .isEqualTo(InetSocketAddress.createUnresolved("cassandra.datacenter1.com", 19042));
+  }
+
+  @Test
+  public void should_translate_to_correct_subnet_address_ipv6() {
+    Map<String, String> subnetAddresses =
+        ImmutableMap.of(
+            "\"::ffff:6440:0/111\"", "cassandra.datacenter1.com:19042",
+            "\"::ffff:6442:0/111\"", "cassandra.datacenter2.com:19042");
+    DefaultDriverContext context = context(subnetAddresses);
+    SubnetAddressTranslator translator = new SubnetAddressTranslator(context);
+    InetSocketAddress address = new InetSocketAddress("::ffff:6440:1", 9042);
+    assertThat(translator.translate(address))
+        .isEqualTo(InetSocketAddress.createUnresolved("cassandra.datacenter1.com", 19042));
+  }
+
+  @Test
+  public void should_translate_to_default_address() {
+    DefaultDriverContext context = context(ImmutableMap.of());
+    when(context
+            .getConfig()
+            .getDefaultProfile()
+            .getString(ADDRESS_TRANSLATOR_DEFAULT_ADDRESS, null))
+        .thenReturn("cassandra.com:19042");
+    SubnetAddressTranslator translator = new SubnetAddressTranslator(context);
+    InetSocketAddress address = new InetSocketAddress("100.68.0.1", 9042);
+    assertThat(translator.translate(address))
+        .isEqualTo(InetSocketAddress.createUnresolved("cassandra.com", 19042));
+  }
+
+  @Test
+  public void should_pass_through_not_matched_address() {
+    DefaultDriverContext context = context(ImmutableMap.of());
+    SubnetAddressTranslator translator = new SubnetAddressTranslator(context);
+    InetSocketAddress address = new InetSocketAddress("100.68.0.1", 9042);
+    assertThat(translator.translate(address)).isEqualTo(address);
+  }
+
+  @Test
+  public void should_fail_on_intersecting_subnets_ipv4() {
+    Map<String, String> subnetAddresses =
+        ImmutableMap.of(
+            "\"100.64.0.0/15\"", "cassandra.datacenter1.com:19042",
+            "100.65.0.\"0/16\"", "cassandra.datacenter2.com:19042");
+    DefaultDriverContext context = context(subnetAddresses);
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> new SubnetAddressTranslator(context))
+        .withMessage(
+            "Configured subnets are overlapping: "
+                + String.format(
+                    "SubnetAddress[subnet=[100, 64, 0, 0], address=%s], ",
+                    InetSocketAddress.createUnresolved("cassandra.datacenter1.com", 19042))
+                + String.format(
+                    "SubnetAddress[subnet=[100, 65, 0, 0], address=%s]",
+                    InetSocketAddress.createUnresolved("cassandra.datacenter2.com", 19042)));
+  }
+
+  @Test
+  public void should_fail_on_intersecting_subnets_ipv6() {
+    Map<String, String> subnetAddresses =
+        ImmutableMap.of(
+            "\"::ffff:6440:0/111\"", "cassandra.datacenter1.com:19042",
+            "\"::ffff:6441:0/112\"", "cassandra.datacenter2.com:19042");
+    DefaultDriverContext context = context(subnetAddresses);
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> new SubnetAddressTranslator(context))
+        .withMessage(
+            "Configured subnets are overlapping: "
+                + String.format(
+                    "SubnetAddress[subnet=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 100, 64, 0, 0], address=%s], ",
+                    InetSocketAddress.createUnresolved("cassandra.datacenter1.com", 19042))
+                + String.format(
+                    "SubnetAddress[subnet=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 100, 65, 0, 0], address=%s]",
+                    InetSocketAddress.createUnresolved("cassandra.datacenter2.com", 19042)));
+  }
+
+  @Test
+  public void should_fail_on_subnet_address_without_port() {
+    Map<String, String> subnetAddresses =
+        ImmutableMap.of("\"100.64.0.0/15\"", "cassandra.datacenter1.com");
+    DefaultDriverContext context = context(subnetAddresses);
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> new SubnetAddressTranslator(context))
+        .withMessage("Invalid address cassandra.datacenter1.com (expecting format host:port)");
+  }
+
+  @Test
+  public void should_fail_on_default_address_without_port() {
+    DefaultDriverContext context = context(ImmutableMap.of());
+    when(context
+            .getConfig()
+            .getDefaultProfile()
+            .getString(ADDRESS_TRANSLATOR_DEFAULT_ADDRESS, null))
+        .thenReturn("cassandra.com");
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> new SubnetAddressTranslator(context))
+        .withMessage("Invalid address cassandra.com (expecting format host:port)");
+  }
+
+  private static DefaultDriverContext context(Map<String, String> subnetAddresses) {
+    DriverExecutionProfile profile = mock(DriverExecutionProfile.class);
+    when(profile.getStringMap(ADDRESS_TRANSLATOR_SUBNET_ADDRESSES)).thenReturn(subnetAddresses);
+    return MockedDriverContextFactory.defaultDriverContext(Optional.of(profile));
+  }
+}
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetTest.java
new file mode 100644
index 00000000000..f8ba8929e9e
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetTest.java
@@ -0,0 +1,118 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.addresstranslation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.assertj.core.api.Assertions.assertThatNoException;
+
+import java.net.UnknownHostException;
+import org.junit.Test;
+
+public class SubnetTest {
+  @Test
+  public void should_parse_to_correct_ipv4_subnet() throws UnknownHostException {
+    Subnet subnet = Subnet.parse("100.64.0.0/15");
+    assertThat(subnet.getSubnet()).containsExactly(100, 64, 0, 0);
+    assertThat(subnet.getNetworkMask()).containsExactly(255, 254, 0, 0);
+    assertThat(subnet.getUpper()).containsExactly(100, 65, 255, 255);
+    assertThat(subnet.getLower()).containsExactly(100, 64, 0, 0);
+  }
+
+  @Test
+  public void should_parse_to_correct_ipv6_subnet() throws UnknownHostException {
+    Subnet subnet = Subnet.parse("2001:db8:85a3::8a2e:370:0/111");
+    assertThat(subnet.getSubnet())
+        .containsExactly(32, 1, 13, 184, 133, 163, 0, 0, 0, 0, 138, 46, 3, 112, 0, 0);
+    assertThat(subnet.getNetworkMask())
+        .containsExactly(
+            255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 0, 0);
+    assertThat(subnet.getUpper())
+        .containsExactly(32, 1, 13, 184, 133, 163, 0, 0, 0, 0, 138, 46, 3, 113, 255, 255);
+    assertThat(subnet.getLower())
+        .containsExactly(32, 1, 13, 184, 133, 163, 0, 0, 0, 0, 138, 46, 3, 112, 0, 0);
+  }
+
+  @Test
+  public void should_parse_to_correct_ipv6_subnet_ipv4_convertible() throws UnknownHostException {
+    Subnet subnet = Subnet.parse("::ffff:6440:0/111");
+    assertThat(subnet.getSubnet())
+        .containsExactly(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 100, 64, 0, 0);
+    assertThat(subnet.getNetworkMask())
+        .containsExactly(
+            255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 0, 0);
+    assertThat(subnet.getUpper())
+        .containsExactly(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 100, 65, 255, 255);
+    assertThat(subnet.getLower())
+        .containsExactly(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 100, 64, 0, 0);
+  }
+
+  @Test
+  public void should_fail_on_invalid_cidr_format() {
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> Subnet.parse("invalid"))
+        .withMessage("Invalid subnet: invalid");
+  }
+
+  @Test
+  public void should_parse_bounding_prefix_lengths_correctly() {
+    assertThatNoException().isThrownBy(() -> Subnet.parse("0.0.0.0/0"));
+    assertThatNoException().isThrownBy(() -> Subnet.parse("100.64.0.0/32"));
+  }
+
+  @Test
+  public void should_fail_on_invalid_prefix_length() {
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> Subnet.parse("100.64.0.0/-1"))
+        .withMessage("Prefix length -1 must be within [0; 32]");
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> Subnet.parse("100.64.0.0/33"))
+        .withMessage("Prefix length 33 must be within [0; 32]");
+  }
+
+  @Test
+  public void should_fail_on_not_prefix_block_subnet_ipv4() {
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> Subnet.parse("100.65.0.0/15"))
+        .withMessage("Subnet 100.65.0.0/15 must be represented as a network prefix block");
+  }
+
+  @Test
+  public void should_fail_on_not_prefix_block_subnet_ipv6() {
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> Subnet.parse("::ffff:6441:0/111"))
+        .withMessage("Subnet ::ffff:6441:0/111 must be represented as a network prefix block");
+  }
+
+  @Test
+  public void should_return_true_on_containing_address() throws UnknownHostException {
+    Subnet subnet = Subnet.parse("100.64.0.0/15");
+    assertThat(subnet.contains(new byte[] {100, 64, 0, 0})).isTrue();
+    assertThat(subnet.contains(new byte[] {100, 65, (byte) 255, (byte) 255})).isTrue();
+    assertThat(subnet.contains(new byte[] {100, 65, 100, 100})).isTrue();
+  }
+
+  @Test
+  public void should_return_false_on_not_containing_address() throws UnknownHostException {
+    Subnet subnet = Subnet.parse("100.64.0.0/15");
+    assertThat(subnet.contains(new byte[] {100, 63, (byte) 255, (byte) 255})).isFalse();
+    assertThat(subnet.contains(new byte[] {100, 66, 0, 0})).isFalse();
+    // IPv6 cannot be contained by IPv4 subnet.
+    assertThat(subnet.contains(new byte[16])).isFalse();
+  }
+}
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/config/MockOptions.java b/core/src/test/java/com/datastax/oss/driver/internal/core/config/MockOptions.java
index 25c1e8b26fd..cee57abbfdf 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/config/MockOptions.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/config/MockOptions.java
@@ -24,6 +24,7 @@ public enum MockOptions implements DriverOption {
   INT1("int1"),
   INT2("int2"),
   AUTH_PROVIDER("auth_provider"),
+  SUBNET_ADDRESSES("subnet_addresses"),
   ;
 
   private final String path;
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/config/typesafe/TypesafeDriverConfigTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/config/typesafe/TypesafeDriverConfigTest.java
index 16ccb73da9f..4a78c3ccb03 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/config/typesafe/TypesafeDriverConfigTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/config/typesafe/TypesafeDriverConfigTest.java
@@ -101,7 +101,6 @@ public void should_fetch_string_map() {
         parse(
             "int1 = 42 \n auth_provider { auth_thing_one= one \n auth_thing_two = two \n auth_thing_three = three}");
     DriverExecutionProfile base = config.getDefaultProfile();
-    base.getStringMap(MockOptions.AUTH_PROVIDER);
     Map<String, String> map = base.getStringMap(MockOptions.AUTH_PROVIDER);
     assertThat(map.entrySet().size()).isEqualTo(3);
     assertThat(map.get("auth_thing_one")).isEqualTo("one");
@@ -109,6 +108,19 @@ public void should_fetch_string_map() {
     assertThat(map.get("auth_thing_three")).isEqualTo("three");
   }
 
+  @Test
+  public void should_fetch_string_map_with_forward_slash_in_keys() {
+    TypesafeDriverConfig config =
+        parse(
+            "subnet_addresses { 100.64.0.0/15 = \"cassandra.datacenter1.com:9042\" \n \"100.66.0.0/15\" = \"cassandra.datacenter2.com\" \n \"::ffff:6440:0/111\" = \"cassandra.datacenter3.com:19042\" }");
+    DriverExecutionProfile base = config.getDefaultProfile();
+    Map<String, String> map = base.getStringMap(MockOptions.SUBNET_ADDRESSES);
+    assertThat(map.entrySet().size()).isEqualTo(3);
+    assertThat(map.get("100.64.0.\"0/15\"")).isEqualTo("cassandra.datacenter1.com:9042");
+    assertThat(map.get("\"100.66.0.0/15\"")).isEqualTo("cassandra.datacenter2.com");
+    assertThat(map.get("\"::ffff:6440:0/111\"")).isEqualTo("cassandra.datacenter3.com:19042");
+  }
+
   @Test
   public void should_create_derived_profile_with_string_map() {
     TypesafeDriverConfig config = parse("int1 = 42");
diff --git a/manual/core/address_resolution/README.md b/manual/core/address_resolution/README.md
index 84efb4a796c..5b2536feb18 100644
--- a/manual/core/address_resolution/README.md
+++ b/manual/core/address_resolution/README.md
@@ -118,6 +118,55 @@ datastax-java-driver.advanced.address-translator.class = com.mycompany.MyAddress
 Note: the contact points provided while creating the `CqlSession` are not translated, only addresses
 retrieved from or sent by Cassandra nodes are.
 
+### Fixed proxy hostname
+
+If your client applications access Cassandra through some kind of proxy (eg. with AWS PrivateLink when all Cassandra
+nodes are exposed via one hostname pointing to AWS Endpoint), you can configure driver with
+`FixedHostNameAddressTranslator` to always translate all node addresses to that same proxy hostname, no matter what IP
+address a node has but still using its native transport port.
+
+To use it, specify the following in the [configuration](../configuration):
+
+```
+datastax-java-driver.advanced.address-translator.class = FixedHostNameAddressTranslator
+advertised-hostname = proxyhostname
+```
+
+### Fixed proxy hostname per subnet
+
+When running Cassandra in a private network and accessing it from outside of that private network via some kind of
+proxy, we have an option to use `FixedHostNameAddressTranslator`. But for multi-datacenter Cassandra deployments, we
+want to have more control over routing queries to a specific datacenter (eg. for optimizing latencies), which requires
+setting up a separate proxy per datacenter.
+
+Normally, each Cassandra datacenter nodes are deployed to a different subnet to support internode communications in the
+cluster and avoid IP address collisions. So when Cassandra broadcasts its nodes IP addresses, we can determine which
+datacenter that node belongs to by checking its IP address against the given datacenter subnet.
+
+For such scenarios you can use `SubnetAddressTranslator` to translate node IPs to the datacenter proxy address
+associated with it. 
+
+To use it, specify the following in the [configuration](../configuration):
+```
+datastax-java-driver.advanced.address-translator {
+  class = SubnetAddressTranslator
+  subnet-addresses {
+    "100.64.0.0/15" = "cassandra.datacenter1.com:9042"
+    "100.66.0.0/15" = "cassandra.datacenter2.com:9042"
+    # IPv6 example:
+    # "::ffff:6440:0/111" = "cassandra.datacenter1.com:9042"
+    # "::ffff:6442:0/111" = "cassandra.datacenter2.com:9042"
+  }
+  # Optional. When configured, addresses not matching the configured subnets are translated to this address.
+  default-address = "cassandra.datacenter1.com:9042"
+  # Whether to resolve the addresses once on initialization (if true) or on each node (re-)connection (if false).
+  # If not configured, defaults to false.
+  resolve-addresses = false
+}
+```
+
+Such setup is common for running Cassandra on Kubernetes with [k8ssandra](https://docs.k8ssandra.io/).
+
 ### EC2 multi-region
 
 If you deploy both Cassandra and client applications on Amazon EC2, and your cluster spans multiple regions, you'll have

From 29d3531202895fb9866bdd72720202c78a7eaa9b Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <abe@aber.io>
Date: Tue, 20 May 2025 19:06:14 -0400
Subject: [PATCH 081/126] Fix revapi surious complaints about optional
 dependencies

patch by Abe Ratnofsky; reviewed by Bret McGuire for CASSJAVA-102
---
 Jenkinsfile-datastax       |  2 +-
 core/revapi.json           | 25 +++++++++++++++++++--
 mapper-runtime/revapi.json |  6 ++---
 pom.xml                    | 45 ++++++++++++++++++++++++--------------
 query-builder/revapi.json  |  9 ++++----
 test-infra/revapi.json     |  4 +---
 6 files changed, 61 insertions(+), 30 deletions(-)

diff --git a/Jenkinsfile-datastax b/Jenkinsfile-datastax
index af1aab6e0f4..73b977bdf9f 100644
--- a/Jenkinsfile-datastax
+++ b/Jenkinsfile-datastax
@@ -27,7 +27,7 @@ def initializeEnvironment() {
   env.GITHUB_BRANCH_URL = "${GITHUB_PROJECT_URL}/tree/${env.BRANCH_NAME}"
   env.GITHUB_COMMIT_URL = "${GITHUB_PROJECT_URL}/commit/${env.GIT_COMMIT}"
 
-  env.MAVEN_HOME = "${env.HOME}/.mvn/apache-maven-3.6.3"
+  env.MAVEN_HOME = "${env.HOME}/.mvn/apache-maven-3.8.8"
   env.PATH = "${env.MAVEN_HOME}/bin:${env.PATH}"
 
   /*
diff --git a/core/revapi.json b/core/revapi.json
index 5aa46a3ccad..f39c7d4a7c0 100644
--- a/core/revapi.json
+++ b/core/revapi.json
@@ -1,5 +1,3 @@
-// Configures Revapi (https://revapi.org/getting-started.html) to check API compatibility between
-// successive driver versions.
 {
   "revapi": {
     "java": {
@@ -7386,6 +7384,29 @@
         "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
         "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
         "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+      },
+      {
+        "code": "java.class.nonPublicPartOfAPI",
+        "old": "class com.datastax.oss.driver.internal.core.config.typesafe.TypesafeDriverExecutionProfile.Base",
+        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
+      },
+      {
+        "code": "java.class.nonPublicPartOfAPI",
+        "old": "class com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer",
+        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
+      },
+      {
+        "code": "java.class.nonPublicPartOfAPI",
+        "old": "class org.apache.tinkerpop.shaded.jackson.databind.type.TypeParser.MyTokenizer",
+        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
+      },
+      {
+        "code": "java.class.externalClassExposedInAPI",
+        "justification": "CASSJAVA-102: Migrate revapi config into dedicated config files, ported from pom.xml"
+      },
+      {
+        "code": "java.method.varargOverloadsOnlyDifferInVarargParameter",
+        "justification": "CASSJAVA-102: Migrate revapi config into dedicated config files, ported from pom.xml"
       }
     ]
   }
diff --git a/mapper-runtime/revapi.json b/mapper-runtime/revapi.json
index 18d26a7f7e9..3dc2ea21671 100644
--- a/mapper-runtime/revapi.json
+++ b/mapper-runtime/revapi.json
@@ -1,5 +1,3 @@
-// Configures Revapi (https://revapi.org/getting-started.html) to check API compatibility between
-// successive driver versions.
 {
   "revapi": {
     "java": {
@@ -11,7 +9,7 @@
             "com\\.datastax\\.(oss|dse)\\.driver\\.internal(\\..+)?",
             "com\\.datastax\\.oss\\.driver\\.shaded(\\..+)?",
             "com\\.datastax\\.oss\\.simulacron(\\..+)?",
-            // Don't re-check sibling modules that this module depends on
+            "// Don't re-check sibling modules that this module depends on",
             "com\\.datastax\\.(oss|dse)\\.driver\\.api\\.core(\\..+)?",
             "com\\.datastax\\.(oss|dse)\\.driver\\.api\\.querybuilder(\\..+)?"
           ]
@@ -22,7 +20,7 @@
       {
         "regex": true,
         "code": "java.annotation.attributeValueChanged",
-        "old": "@interface com\.datastax\.oss\.driver\.api\.mapper\.annotations\..*",
+        "old": "@interface com\\.datastax\\.oss\\.driver\\.api\\.mapper\\.annotations\\..*",
         "annotationType": "java.lang.annotation.Retention",
         "attribute": "value",
         "oldValue": "java.lang.annotation.RetentionPolicy.CLASS",
diff --git a/pom.xml b/pom.xml
index e5cfb58f94d..2cfeb65e757 100644
--- a/pom.xml
+++ b/pom.xml
@@ -561,28 +561,23 @@
         <plugin>
           <groupId>org.revapi</groupId>
           <artifactId>revapi-maven-plugin</artifactId>
-          <version>0.10.5</version>
+          <version>0.15.1</version>
           <configuration>
             <outputNonIdentifyingDifferenceInfo>false</outputNonIdentifyingDifferenceInfo>
             <versionFormat>\d+\.\d+\.\d+</versionFormat>
-            <analysisConfiguration>
-              <revapi.ignore>
-                <item>
-                  <!-- We don't consider this a problem -->
-                  <code>java.class.externalClassExposedInAPI</code>
-                </item>
-              </revapi.ignore>
-            </analysisConfiguration>
             <oldArtifacts>
               <!-- The previous release used DataStax groupId, remove this after the next release -->
               <artifact>${project.groupId}:${project.artifactId}:RELEASE</artifact>
             </oldArtifacts>
+            <analysisConfigurationFiles>
+              <file>revapi.json</file>
+            </analysisConfigurationFiles>
           </configuration>
           <dependencies>
             <dependency>
               <groupId>org.revapi</groupId>
               <artifactId>revapi-java</artifactId>
-              <version>0.22.1</version>
+              <version>0.28.4</version>
             </dependency>
           </dependencies>
         </plugin>
@@ -596,9 +591,33 @@
           <artifactId>flatten-maven-plugin</artifactId>
           <version>1.2.1</version>
         </plugin>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-enforcer-plugin</artifactId>
+          <version>3.5.0</version>
+        </plugin>
       </plugins>
     </pluginManagement>
     <plugins>
+      <plugin>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>enforce-maven</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireMavenVersion>
+                  <!-- revapi 0.15.1 requires Maven version 3.8.1 -->
+                  <version>[3.8.1,)</version>
+                </requireMavenVersion>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
       <plugin>
         <artifactId>maven-compiler-plugin</artifactId>
         <configuration>
@@ -901,12 +920,6 @@ limitations under the License.]]></inlineHeader>
             <goals>
               <goal>check</goal>
             </goals>
-            <configuration>
-              <analysisConfigurationFiles>
-                <!-- Present at the root of each module that doesn't skip this goal -->
-                <analysisConfigurationFile>revapi.json</analysisConfigurationFile>
-              </analysisConfigurationFiles>
-            </configuration>
           </execution>
         </executions>
       </plugin>
diff --git a/query-builder/revapi.json b/query-builder/revapi.json
index c4d8aa27212..ed97379332c 100644
--- a/query-builder/revapi.json
+++ b/query-builder/revapi.json
@@ -1,5 +1,3 @@
-// Configures Revapi (https://revapi.org/getting-started.html) to check API compatibility between
-// successive driver versions.
 {
   "revapi": {
     "java": {
@@ -11,7 +9,7 @@
             "com\\.datastax\\.(oss|dse)\\.driver\\.internal(\\..+)?",
             "com\\.datastax\\.oss\\.driver\\.shaded(\\..+)?",
             "org\\.assertj(\\..+)?",
-            // Don't re-check sibling modules that this module depends on
+            "// Don't re-check sibling modules that this module depends on",
             "com\\.datastax\\.(oss|dse)\\.driver\\.api\\.core(\\..+)?"
           ]
         }
@@ -2782,8 +2780,11 @@
         "code": "java.method.addedToInterface",
         "new": "method com.datastax.oss.driver.api.querybuilder.select.Select com.datastax.oss.driver.api.querybuilder.select.Select::orderByAnnOf(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<?>)",
         "justification": "JAVA-3118: Add support for vector data type in Schema Builder, QueryBuilder"
+      },
+      {
+        "code": "java.method.varargOverloadsOnlyDifferInVarargParameter",
+        "justification": "CASSJAVA-102: Suppress newly-supported varargs check"
       }
     ]
   }
 }
-
diff --git a/test-infra/revapi.json b/test-infra/revapi.json
index c75a98cb4af..293d9f4d142 100644
--- a/test-infra/revapi.json
+++ b/test-infra/revapi.json
@@ -1,5 +1,3 @@
-// Configures Revapi (https://revapi.org/getting-started.html) to check API compatibility between
-// successive driver versions.
 {
   "revapi": {
     "java": {
@@ -12,7 +10,7 @@
             "com\\.datastax\\.oss\\.driver\\.shaded(\\..+)?",
             "com\\.datastax\\.oss\\.simulacron(\\..+)?",
             "org\\.assertj(\\..+)?",
-            // Don't re-check sibling modules that this module depends on
+            "// Don't re-check sibling modules that this module depends on",
             "com\\.datastax\\.(oss|dse)\\.driver\\.api\\.core(\\..+)?"
           ]
         }

From f49e19b8c7e3bff6e5e4e8003484427c95bde027 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Mon, 7 Jul 2025 10:05:15 -0500
Subject: [PATCH 082/126] ninja-fix: updating OS label in Jenkinsfile after
 upgrade to Focal for runner

---
 Jenkinsfile-datastax | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Jenkinsfile-datastax b/Jenkinsfile-datastax
index 73b977bdf9f..602f33101ca 100644
--- a/Jenkinsfile-datastax
+++ b/Jenkinsfile-datastax
@@ -402,7 +402,7 @@ pipeline {
   }
 
   environment {
-    OS_VERSION = 'ubuntu/bionic64/java-driver'
+    OS_VERSION = 'ubuntu/focal64/java-driver'
     JABBA_SHELL = '/usr/lib/jabba/jabba.sh'
     CCM_ENVIRONMENT_SHELL = '/usr/local/bin/ccm_environment.sh'
     SERIAL_ITS_ARGUMENT = "-DskipSerialITs=${params.SKIP_SERIAL_ITS}"

From 17ebe6092e2877d8c524e07489c4c3d005cfeea5 Mon Sep 17 00:00:00 2001
From: janehe <jane.he@datastax.com>
Date: Mon, 14 Jul 2025 15:09:25 -0700
Subject: [PATCH 083/126] ninja-fix: openjdk@1.17.0 instead of openjdk@17 for
 ASF CI patch by Jane He; reviewed by Bret McGuire and Alexandre Dutra

---
 Jenkinsfile-asf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Jenkinsfile-asf b/Jenkinsfile-asf
index 24800ba9051..4b5041903c1 100644
--- a/Jenkinsfile-asf
+++ b/Jenkinsfile-asf
@@ -35,7 +35,7 @@ pipeline {
                 axes {
                     axis {
                         name 'TEST_JAVA_VERSION'
-                        values  'openjdk@1.8.0-292', 'openjdk@1.11.0-9', 'openjdk@17', 'openjdk@1.21.0'
+                        values  'openjdk@1.8.0-292', 'openjdk@1.11.0-9', 'openjdk@1.17.0', 'openjdk@1.21.0'
                     }
                     axis {
                         name 'SERVER_VERSION'

From ddd6f03d7107df03e6e96e9fe37f434e4c742a9d Mon Sep 17 00:00:00 2001
From: Jason Koch <jkoch@netflix.com>
Date: Mon, 17 Mar 2025 10:17:06 -0700
Subject: [PATCH 084/126] Remove unnecessary locking in DefaultNettyOptions

This value is initialized at constructor time and marked final, so it
can never change. There is no need to have access to this reference
synchronized.

Patch by Jason Koch; reviewed by Alexandre Dutra, Andy Tolbert and Jane He
---
 .../oss/driver/internal/core/context/DefaultNettyOptions.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultNettyOptions.java b/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultNettyOptions.java
index c5d3b3670f0..763a71f8b12 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultNettyOptions.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultNettyOptions.java
@@ -200,7 +200,7 @@ public Future<Void> onClose() {
   }
 
   @Override
-  public synchronized Timer getTimer() {
+  public Timer getTimer() {
     return timer;
   }
 }

From f32069bd8abfae75f451ff4f47c44c1cca8dbd1e Mon Sep 17 00:00:00 2001
From: Michael Karsten <mkarsten3@gatech.edu>
Date: Fri, 21 Mar 2025 12:09:31 -0700
Subject: [PATCH 085/126] CASSJAVA-89 fix: support schema options that changed
 in Cassandra 5.0

Patch by Michael Karsten; reviewed by Abe Ratnofsky and Andy Tolbert for CASSJAVA-89
---
 .../querybuilder/RelationOptionsIT.java       | 131 ++++++++++++++++++
 .../querybuilder/schema/RelationOptions.java  | 126 ++++++++++++++---
 .../schema/CreateDseTableTest.java            |  65 +++++++++
 .../querybuilder/schema/CreateTableTest.java  |  55 ++++++++
 4 files changed, 355 insertions(+), 22 deletions(-)
 create mode 100644 integration-tests/src/test/java/com/datastax/oss/driver/querybuilder/RelationOptionsIT.java

diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/querybuilder/RelationOptionsIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/querybuilder/RelationOptionsIT.java
new file mode 100644
index 00000000000..fc571ccf44d
--- /dev/null
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/querybuilder/RelationOptionsIT.java
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.querybuilder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata;
+import com.datastax.oss.driver.api.core.type.DataTypes;
+import com.datastax.oss.driver.api.querybuilder.SchemaBuilder;
+import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendRequirement;
+import com.datastax.oss.driver.api.testinfra.requirement.BackendType;
+import com.datastax.oss.driver.api.testinfra.session.SessionRule;
+import com.datastax.oss.driver.categories.ParallelizableTests;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.RuleChain;
+import org.junit.rules.TestName;
+import org.junit.rules.TestRule;
+
+@Category(ParallelizableTests.class)
+public class RelationOptionsIT {
+
+  private CcmRule ccmRule = CcmRule.getInstance();
+
+  private SessionRule<CqlSession> sessionRule = SessionRule.builder(ccmRule).build();
+
+  @Rule public TestRule chain = RuleChain.outerRule(ccmRule).around(sessionRule);
+
+  @Rule public TestName name = new TestName();
+
+  @Test
+  @BackendRequirement(
+      type = BackendType.CASSANDRA,
+      minInclusive = "3.0",
+      description = "CRC check chance was moved to top level table in Cassandra 3.0")
+  public void should_create_table_with_crc_check_chance() {
+    sessionRule
+        .session()
+        .execute(
+            SchemaBuilder.createTable(name.getMethodName())
+                .withPartitionKey("id", DataTypes.INT)
+                .withColumn("name", DataTypes.TEXT)
+                .withColumn("age", DataTypes.INT)
+                .withCRCCheckChance(0.8)
+                .build());
+    KeyspaceMetadata keyspaceMetadata =
+        sessionRule
+            .session()
+            .getMetadata()
+            .getKeyspace(sessionRule.keyspace())
+            .orElseThrow(AssertionError::new);
+    String describeOutput = keyspaceMetadata.describeWithChildren(true).trim();
+
+    assertThat(describeOutput).contains("crc_check_chance = 0.8");
+  }
+
+  @Test
+  @BackendRequirement(
+      type = BackendType.CASSANDRA,
+      minInclusive = "5.0",
+      description = "chunk_length_kb was renamed to chunk_length_in_kb in Cassandra 5.0")
+  public void should_create_table_with_chunk_length_in_kb() {
+    sessionRule
+        .session()
+        .execute(
+            SchemaBuilder.createTable(name.getMethodName())
+                .withPartitionKey("id", DataTypes.INT)
+                .withColumn("name", DataTypes.TEXT)
+                .withColumn("age", DataTypes.INT)
+                .withLZ4Compression(4096)
+                .build());
+    KeyspaceMetadata keyspaceMetadata =
+        sessionRule
+            .session()
+            .getMetadata()
+            .getKeyspace(sessionRule.keyspace())
+            .orElseThrow(AssertionError::new);
+    String describeOutput = keyspaceMetadata.describeWithChildren(true).trim();
+
+    assertThat(describeOutput).contains("'class':'org.apache.cassandra.io.compress.LZ4Compressor'");
+    assertThat(describeOutput).contains("'chunk_length_in_kb':'4096'");
+  }
+
+  @Test
+  @BackendRequirement(
+      type = BackendType.CASSANDRA,
+      minInclusive = "3.0",
+      maxExclusive = "5.0",
+      description =
+          "Deprecated compression options should still work with Cassandra >= 3.0 & < 5.0")
+  public void should_create_table_with_deprecated_options() {
+    sessionRule
+        .session()
+        .execute(
+            SchemaBuilder.createTable(name.getMethodName())
+                .withPartitionKey("id", DataTypes.INT)
+                .withColumn("name", DataTypes.TEXT)
+                .withColumn("age", DataTypes.INT)
+                .withLZ4Compression(4096, 0.8)
+                .build());
+    KeyspaceMetadata keyspaceMetadata =
+        sessionRule
+            .session()
+            .getMetadata()
+            .getKeyspace(sessionRule.keyspace())
+            .orElseThrow(AssertionError::new);
+    String describeOutput = keyspaceMetadata.describeWithChildren(true).trim();
+
+    assertThat(describeOutput).contains("'class':'org.apache.cassandra.io.compress.LZ4Compressor'");
+    assertThat(describeOutput).contains("'chunk_length_in_kb':'4096'");
+    assertThat(describeOutput).contains("crc_check_chance = 0.8");
+  }
+}
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/schema/RelationOptions.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/schema/RelationOptions.java
index 022562def81..49b342acb7f 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/schema/RelationOptions.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/schema/RelationOptions.java
@@ -58,6 +58,18 @@ default SelfT withCDC(boolean enabled) {
     return withOption("cdc", enabled);
   }
 
+  /**
+   * Defines the crc check chance.
+   *
+   * <p>Note that using this option with a version of Apache Cassandra less than 3.0 will raise a
+   * syntax error.
+   */
+  @NonNull
+  @CheckReturnValue
+  default SelfT withCRCCheckChance(double crcCheckChance) {
+    return withOption("crc_check_chance", crcCheckChance);
+  }
+
   /**
    * Defines the caching criteria.
    *
@@ -97,22 +109,32 @@ default SelfT withCompaction(@NonNull CompactionStrategy<?> compactionStrategy)
   }
 
   /**
-   * Configures compression using the LZ4 algorithm with the given chunk length and crc check
-   * chance.
-   *
-   * @see #withCompression(String, int, double)
+   * @deprecated This method only exists for backward compatibility. Will not work with Apache
+   *     Cassandra 5.0 or later. Use {@link #withLZ4Compression(int)} instead.
    */
+  @Deprecated
   @NonNull
   @CheckReturnValue
   default SelfT withLZ4Compression(int chunkLengthKB, double crcCheckChance) {
     return withCompression("LZ4Compressor", chunkLengthKB, crcCheckChance);
   }
 
+  /**
+   * Configures compression using the LZ4 algorithm with the given chunk length.
+   *
+   * @see #withCompression(String, int)
+   */
+  @NonNull
+  @CheckReturnValue
+  default SelfT withLZ4Compression(int chunkLengthKB) {
+    return withCompression("LZ4Compressor", chunkLengthKB);
+  }
+
   /**
    * Configures compression using the LZ4 algorithm using the default configuration (64kb
-   * chunk_length, and 1.0 crc_check_chance).
+   * chunk_length).
    *
-   * @see #withCompression(String, int, double)
+   * @see #withCompression(String, int)
    */
   @NonNull
   @CheckReturnValue
@@ -121,22 +143,57 @@ default SelfT withLZ4Compression() {
   }
 
   /**
-   * Configures compression using the Snappy algorithm with the given chunk length and crc check
-   * chance.
+   * Configures compression using the Zstd algorithm with the given chunk length.
    *
-   * @see #withCompression(String, int, double)
+   * @see #withCompression(String, int)
    */
   @NonNull
   @CheckReturnValue
+  default SelfT withZstdCompression(int chunkLengthKB) {
+    return withCompression("ZstdCompressor", chunkLengthKB);
+  }
+
+  /**
+   * Configures compression using the Zstd algorithm using the default configuration (64kb
+   * chunk_length).
+   *
+   * @see #withCompression(String, int)
+   */
+  @NonNull
+  @CheckReturnValue
+  default SelfT withZstdCompression() {
+    return withCompression("ZstdCompressor");
+  }
+
+  /**
+   * @deprecated This method only exists for backward compatibility. Will not work with Apache
+   *     Cassandra 5.0 or later due to removal of deprecated table properties (<a
+   *     href="https://issues.apache.org/jira/browse/CASSANDRA-18742">CASSANDRA-18742</a>). Use
+   *     {@link #withSnappyCompression(int)} instead.
+   */
+  @Deprecated
+  @NonNull
+  @CheckReturnValue
   default SelfT withSnappyCompression(int chunkLengthKB, double crcCheckChance) {
     return withCompression("SnappyCompressor", chunkLengthKB, crcCheckChance);
   }
 
+  /**
+   * Configures compression using the Snappy algorithm with the given chunk length.
+   *
+   * @see #withCompression(String, int)
+   */
+  @NonNull
+  @CheckReturnValue
+  default SelfT withSnappyCompression(int chunkLengthKB) {
+    return withCompression("SnappyCompressor", chunkLengthKB);
+  }
+
   /**
    * Configures compression using the Snappy algorithm using the default configuration (64kb
-   * chunk_length, and 1.0 crc_check_chance).
+   * chunk_length).
    *
-   * @see #withCompression(String, int, double)
+   * @see #withCompression(String, int)
    */
   @NonNull
   @CheckReturnValue
@@ -145,22 +202,34 @@ default SelfT withSnappyCompression() {
   }
 
   /**
-   * Configures compression using the Deflate algorithm with the given chunk length and crc check
-   * chance.
-   *
-   * @see #withCompression(String, int, double)
+   * @deprecated This method only exists for backward compatibility. Will not work with Apache
+   *     Cassandra 5.0 or later due to removal of deprecated table properties (<a
+   *     href="https://issues.apache.org/jira/browse/CASSANDRA-18742">CASSANDRA-18742</a>). Use
+   *     {@link #withDeflateCompression(int)} instead.
    */
+  @Deprecated
   @NonNull
   @CheckReturnValue
   default SelfT withDeflateCompression(int chunkLengthKB, double crcCheckChance) {
     return withCompression("DeflateCompressor", chunkLengthKB, crcCheckChance);
   }
 
+  /**
+   * Configures compression using the Deflate algorithm with the given chunk length.
+   *
+   * @see #withCompression(String, int)
+   */
+  @NonNull
+  @CheckReturnValue
+  default SelfT withDeflateCompression(int chunkLengthKB) {
+    return withCompression("DeflateCompressor", chunkLengthKB);
+  }
+
   /**
    * Configures compression using the Deflate algorithm using the default configuration (64kb
-   * chunk_length, and 1.0 crc_check_chance).
+   * chunk_length).
    *
-   * @see #withCompression(String, int, double)
+   * @see #withCompression(String, int)
    */
   @NonNull
   @CheckReturnValue
@@ -170,13 +239,13 @@ default SelfT withDeflateCompression() {
 
   /**
    * Configures compression using the given algorithm using the default configuration (64kb
-   * chunk_length, and 1.0 crc_check_chance).
+   * chunk_length).
    *
    * <p>Unless specifying a custom compression algorithm implementation, it is recommended to use
    * {@link #withLZ4Compression()}, {@link #withSnappyCompression()}, or {@link
    * #withDeflateCompression()}.
    *
-   * @see #withCompression(String, int, double)
+   * @see #withCompression(String, int)
    */
   @NonNull
   @CheckReturnValue
@@ -185,7 +254,7 @@ default SelfT withCompression(@NonNull String compressionAlgorithmName) {
   }
 
   /**
-   * Configures compression using the given algorithm, chunk length and crc check chance.
+   * Configures compression using the given algorithm, chunk length.
    *
    * <p>Unless specifying a custom compression algorithm implementation, it is recommended to use
    * {@link #withLZ4Compression()}, {@link #withSnappyCompression()}, or {@link
@@ -193,11 +262,24 @@ default SelfT withCompression(@NonNull String compressionAlgorithmName) {
    *
    * @param compressionAlgorithmName The class name of the compression algorithm.
    * @param chunkLengthKB The chunk length in KB of compression blocks. Defaults to 64.
-   * @param crcCheckChance The probability (0.0 to 1.0) that checksum will be checked on each read.
-   *     Defaults to 1.0.
    */
   @NonNull
   @CheckReturnValue
+  default SelfT withCompression(@NonNull String compressionAlgorithmName, int chunkLengthKB) {
+    return withOption(
+        "compression",
+        ImmutableMap.of("class", compressionAlgorithmName, "chunk_length_in_kb", chunkLengthKB));
+  }
+
+  /**
+   * @deprecated This method only exists for backward compatibility. Will not work with Apache
+   *     Cassandra 5.0 or later due to removal of deprecated table properties (<a
+   *     href="https://issues.apache.org/jira/browse/CASSANDRA-18742">CASSANDRA-18742</a>). Use
+   *     {@link #withCompression(String, int)} instead.
+   */
+  @NonNull
+  @CheckReturnValue
+  @Deprecated
   default SelfT withCompression(
       @NonNull String compressionAlgorithmName, int chunkLengthKB, double crcCheckChance) {
     return withOption(
diff --git a/query-builder/src/test/java/com/datastax/dse/driver/api/querybuilder/schema/CreateDseTableTest.java b/query-builder/src/test/java/com/datastax/dse/driver/api/querybuilder/schema/CreateDseTableTest.java
index 7fec9674628..d8ee1c4e380 100644
--- a/query-builder/src/test/java/com/datastax/dse/driver/api/querybuilder/schema/CreateDseTableTest.java
+++ b/query-builder/src/test/java/com/datastax/dse/driver/api/querybuilder/schema/CreateDseTableTest.java
@@ -195,6 +195,17 @@ public void should_generate_create_table_lz4_compression() {
 
   @Test
   public void should_generate_create_table_lz4_compression_options() {
+    assertThat(
+            createDseTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withLZ4Compression(1024))
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'LZ4Compressor','chunk_length_in_kb':1024}");
+  }
+
+  @Test
+  public void should_generate_create_table_lz4_compression_options_crc() {
     assertThat(
             createDseTable("bar")
                 .withPartitionKey("k", DataTypes.INT)
@@ -204,6 +215,28 @@ public void should_generate_create_table_lz4_compression_options() {
             "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'LZ4Compressor','chunk_length_kb':1024,'crc_check_chance':0.5}");
   }
 
+  @Test
+  public void should_generate_create_table_zstd_compression() {
+    assertThat(
+            createDseTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withZstdCompression())
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'ZstdCompressor'}");
+  }
+
+  @Test
+  public void should_generate_create_table_zstd_compression_options() {
+    assertThat(
+            createDseTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withZstdCompression(1024))
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'ZstdCompressor','chunk_length_in_kb':1024}");
+  }
+
   @Test
   public void should_generate_create_table_snappy_compression() {
     assertThat(
@@ -217,6 +250,17 @@ public void should_generate_create_table_snappy_compression() {
 
   @Test
   public void should_generate_create_table_snappy_compression_options() {
+    assertThat(
+            createDseTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withSnappyCompression(2048))
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'SnappyCompressor','chunk_length_in_kb':2048}");
+  }
+
+  @Test
+  public void should_generate_create_table_snappy_compression_options_crc() {
     assertThat(
             createDseTable("bar")
                 .withPartitionKey("k", DataTypes.INT)
@@ -239,6 +283,17 @@ public void should_generate_create_table_deflate_compression() {
 
   @Test
   public void should_generate_create_table_deflate_compression_options() {
+    assertThat(
+            createDseTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withDeflateCompression(4096))
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'DeflateCompressor','chunk_length_in_kb':4096}");
+  }
+
+  @Test
+  public void should_generate_create_table_deflate_compression_options_crc() {
     assertThat(
             createDseTable("bar")
                 .withPartitionKey("k", DataTypes.INT)
@@ -389,4 +444,14 @@ public void should_generate_create_table_with_named_edge() {
                 + "FROM person(contributor) "
                 + "TO soft((company_name,software_name),software_version)");
   }
+
+  @Test
+  public void should_generate_create_table_crc_check_chance() {
+    assertThat(
+            createDseTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withCRCCheckChance(0.8))
+        .hasCql("CREATE TABLE bar (k int PRIMARY KEY,v text) WITH crc_check_chance=0.8");
+  }
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
index 15cd12c75eb..31efc278472 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/schema/CreateTableTest.java
@@ -199,6 +199,17 @@ public void should_generate_create_table_lz4_compression() {
 
   @Test
   public void should_generate_create_table_lz4_compression_options() {
+    assertThat(
+            createTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withLZ4Compression(1024))
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'LZ4Compressor','chunk_length_in_kb':1024}");
+  }
+
+  @Test
+  public void should_generate_create_table_lz4_compression_options_crc() {
     assertThat(
             createTable("bar")
                 .withPartitionKey("k", DataTypes.INT)
@@ -208,6 +219,28 @@ public void should_generate_create_table_lz4_compression_options() {
             "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'LZ4Compressor','chunk_length_kb':1024,'crc_check_chance':0.5}");
   }
 
+  @Test
+  public void should_generate_create_table_zstd_compression() {
+    assertThat(
+            createTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withZstdCompression())
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'ZstdCompressor'}");
+  }
+
+  @Test
+  public void should_generate_create_table_zstd_compression_options() {
+    assertThat(
+            createTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withZstdCompression(1024))
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'ZstdCompressor','chunk_length_in_kb':1024}");
+  }
+
   @Test
   public void should_generate_create_table_snappy_compression() {
     assertThat(
@@ -221,6 +254,17 @@ public void should_generate_create_table_snappy_compression() {
 
   @Test
   public void should_generate_create_table_snappy_compression_options() {
+    assertThat(
+            createTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withSnappyCompression(2048))
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'SnappyCompressor','chunk_length_in_kb':2048}");
+  }
+
+  @Test
+  public void should_generate_create_table_snappy_compression_options_crc() {
     assertThat(
             createTable("bar")
                 .withPartitionKey("k", DataTypes.INT)
@@ -243,6 +287,17 @@ public void should_generate_create_table_deflate_compression() {
 
   @Test
   public void should_generate_create_table_deflate_compression_options() {
+    assertThat(
+            createTable("bar")
+                .withPartitionKey("k", DataTypes.INT)
+                .withColumn("v", DataTypes.TEXT)
+                .withDeflateCompression(4096))
+        .hasCql(
+            "CREATE TABLE bar (k int PRIMARY KEY,v text) WITH compression={'class':'DeflateCompressor','chunk_length_in_kb':4096}");
+  }
+
+  @Test
+  public void should_generate_create_table_deflate_compression_options_crc() {
     assertThat(
             createTable("bar")
                 .withPartitionKey("k", DataTypes.INT)

From 7e21eb20283f3781a0a748741b768d0adf0fc85b Mon Sep 17 00:00:00 2001
From: Jason Koch <jkoch@netflix.com>
Date: Mon, 3 Feb 2025 13:46:32 -0800
Subject: [PATCH 086/126] Eliminate lock in ConcurrencyLimitingRequestThrottler

Following from 6d3ba47 this changes the throttler to a complete
lock-free implementation. Update the related comments and README now
that it is lock-free.

Patch by Jason Koch; reviewed by Alexandre Dutra and Andy Tolbert
---
 .../session/throttling/RequestThrottler.java  |   8 +-
 .../ConcurrencyLimitingRequestThrottler.java  | 180 ++++++++----------
 manual/core/non_blocking/README.md            |  14 +-
 3 files changed, 90 insertions(+), 112 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.java b/core/src/main/java/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.java
index 7e2b41ebbdb..73d347d533e 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.java
@@ -23,10 +23,10 @@
 /**
  * Limits the number of concurrent requests executed by the driver.
  *
- * <p>Usage in non-blocking applications: beware that all built-in implementations of this interface
- * use locks for internal coordination, and do not qualify as lock-free, with the obvious exception
- * of {@code PassThroughRequestThrottler}. If your application enforces strict lock-freedom, then
- * request throttling should not be enabled.
+ * <p>Usage in non-blocking applications: beware that some implementations of this interface use
+ * locks for internal coordination, and do not qualify as lock-free. If your application enforces
+ * strict lock-freedom, then you should use the {@code PassThroughRequestThrottler} or the {@code
+ * ConcurrencyLimitingRequestThrottler}.
  */
 public interface RequestThrottler extends Closeable {
 
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
index ffe0ffe9650..8146c5b113a 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/session/throttling/ConcurrencyLimitingRequestThrottler.java
@@ -26,10 +26,9 @@
 import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
-import java.util.ArrayDeque;
 import java.util.Deque;
-import java.util.concurrent.locks.ReentrantLock;
-import net.jcip.annotations.GuardedBy;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.atomic.AtomicInteger;
 import net.jcip.annotations.ThreadSafe;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -61,17 +60,12 @@ public class ConcurrencyLimitingRequestThrottler implements RequestThrottler {
   private final String logPrefix;
   private final int maxConcurrentRequests;
   private final int maxQueueSize;
-
-  private final ReentrantLock lock = new ReentrantLock();
-
-  @GuardedBy("lock")
-  private int concurrentRequests;
-
-  @GuardedBy("lock")
-  private final Deque<Throttled> queue = new ArrayDeque<>();
-
-  @GuardedBy("lock")
-  private boolean closed;
+  private final AtomicInteger concurrentRequests = new AtomicInteger(0);
+  // CLQ is not O(1) for size(), as it forces a full iteration of the queue. So, we track
+  // the size of the queue explicitly.
+  private final Deque<Throttled> queue = new ConcurrentLinkedDeque<>();
+  private final AtomicInteger queueSize = new AtomicInteger(0);
+  private volatile boolean closed = false;
 
   public ConcurrencyLimitingRequestThrottler(DriverContext context) {
     this.logPrefix = context.getSessionName();
@@ -88,50 +82,62 @@ public ConcurrencyLimitingRequestThrottler(DriverContext context) {
 
   @Override
   public void register(@NonNull Throttled request) {
-    boolean notifyReadyRequired = false;
+    if (closed) {
+      LOG.trace("[{}] Rejecting request after shutdown", logPrefix);
+      fail(request, "The session is shutting down");
+      return;
+    }
 
-    lock.lock();
-    try {
-      if (closed) {
-        LOG.trace("[{}] Rejecting request after shutdown", logPrefix);
-        fail(request, "The session is shutting down");
-      } else if (queue.isEmpty() && concurrentRequests < maxConcurrentRequests) {
-        // We have capacity for one more concurrent request
+    // Implementation note: Technically the "concurrent requests" or "queue size"
+    // could read transiently over the limit, but the queue itself will never grow
+    // beyond the limit since we always check for that condition and revert if
+    // over-limit. We do this instead of a CAS-loop to avoid the potential loop.
+
+    // If no backlog exists AND we get capacity, we can execute immediately
+    if (queueSize.get() == 0) {
+      // Take a claim first, and then check if we are OK to proceed
+      int newConcurrent = concurrentRequests.incrementAndGet();
+      if (newConcurrent <= maxConcurrentRequests) {
         LOG.trace("[{}] Starting newly registered request", logPrefix);
-        concurrentRequests += 1;
-        notifyReadyRequired = true;
-      } else if (queue.size() < maxQueueSize) {
-        LOG.trace("[{}] Enqueuing request", logPrefix);
-        queue.add(request);
+        request.onThrottleReady(false);
+        return;
       } else {
-        LOG.trace("[{}] Rejecting request because of full queue", logPrefix);
-        fail(
-            request,
-            String.format(
-                "The session has reached its maximum capacity "
-                    + "(concurrent requests: %d, queue size: %d)",
-                maxConcurrentRequests, maxQueueSize));
+        // We exceeded the limit, decrement the count and fall through to the queuing logic
+        concurrentRequests.decrementAndGet();
       }
-    } finally {
-      lock.unlock();
     }
 
-    // no need to hold the lock while allowing the task to progress
-    if (notifyReadyRequired) {
-      request.onThrottleReady(false);
+    // If we have a backlog, or we failed to claim capacity, try to enqueue
+    int newQueueSize = queueSize.incrementAndGet();
+    if (newQueueSize <= maxQueueSize) {
+      LOG.trace("[{}] Enqueuing request", logPrefix);
+      queue.offer(request);
+
+      // Double-check that we were still supposed to be enqueued; it is possible
+      // that the session was closed while we were enqueuing, it's also possible
+      // that it is right now removing the request, so we need to check both
+      if (closed) {
+        if (queue.remove(request)) {
+          queueSize.decrementAndGet();
+          LOG.trace("[{}] Rejecting late request after shutdown", logPrefix);
+          fail(request, "The session is shutting down");
+        }
+      }
+    } else {
+      LOG.trace("[{}] Rejecting request because of full queue", logPrefix);
+      queueSize.decrementAndGet();
+      fail(
+          request,
+          String.format(
+              "The session has reached its maximum capacity "
+                  + "(concurrent requests: %d, queue size: %d)",
+              maxConcurrentRequests, maxQueueSize));
     }
   }
 
   @Override
   public void signalSuccess(@NonNull Throttled request) {
-    Throttled nextRequest = null;
-    lock.lock();
-    try {
-      nextRequest = onRequestDoneAndDequeNext();
-    } finally {
-      lock.unlock();
-    }
-
+    Throttled nextRequest = onRequestDoneAndDequeNext();
     if (nextRequest != null) {
       nextRequest.onThrottleReady(true);
     }
@@ -145,17 +151,13 @@ public void signalError(@NonNull Throttled request, @NonNull Throwable error) {
   @Override
   public void signalTimeout(@NonNull Throttled request) {
     Throttled nextRequest = null;
-    lock.lock();
-    try {
-      if (!closed) {
-        if (queue.remove(request)) { // The request timed out before it was active
-          LOG.trace("[{}] Removing timed out request from the queue", logPrefix);
-        } else {
-          nextRequest = onRequestDoneAndDequeNext();
-        }
+    if (!closed) {
+      if (queue.remove(request)) { // The request timed out before it was active
+        queueSize.decrementAndGet();
+        LOG.trace("[{}] Removing timed out request from the queue", logPrefix);
+      } else {
+        nextRequest = onRequestDoneAndDequeNext();
       }
-    } finally {
-      lock.unlock();
     }
 
     if (nextRequest != null) {
@@ -166,17 +168,13 @@ public void signalTimeout(@NonNull Throttled request) {
   @Override
   public void signalCancel(@NonNull Throttled request) {
     Throttled nextRequest = null;
-    lock.lock();
-    try {
-      if (!closed) {
-        if (queue.remove(request)) { // The request has been cancelled before it was active
-          LOG.trace("[{}] Removing cancelled request from the queue", logPrefix);
-        } else {
-          nextRequest = onRequestDoneAndDequeNext();
-        }
+    if (!closed) {
+      if (queue.remove(request)) { // The request has been cancelled before it was active
+        queueSize.decrementAndGet();
+        LOG.trace("[{}] Removing cancelled request from the queue", logPrefix);
+      } else {
+        nextRequest = onRequestDoneAndDequeNext();
       }
-    } finally {
-      lock.unlock();
     }
 
     if (nextRequest != null) {
@@ -184,17 +182,16 @@ public void signalCancel(@NonNull Throttled request) {
     }
   }
 
-  @SuppressWarnings("GuardedBy") // this method is only called with the lock held
   @Nullable
   private Throttled onRequestDoneAndDequeNext() {
-    assert lock.isHeldByCurrentThread();
     if (!closed) {
-      if (queue.isEmpty()) {
-        concurrentRequests -= 1;
+      Throttled nextRequest = queue.poll();
+      if (nextRequest == null) {
+        concurrentRequests.decrementAndGet();
       } else {
+        queueSize.decrementAndGet();
         LOG.trace("[{}] Starting dequeued request", logPrefix);
-        // don't touch concurrentRequests since we finished one but started another
-        return queue.poll();
+        return nextRequest;
       }
     }
 
@@ -204,45 +201,28 @@ private Throttled onRequestDoneAndDequeNext() {
 
   @Override
   public void close() {
-    lock.lock();
-    try {
-      closed = true;
-      LOG.debug("[{}] Rejecting {} queued requests after shutdown", logPrefix, queue.size());
-      for (Throttled request : queue) {
-        fail(request, "The session is shutting down");
-      }
-    } finally {
-      lock.unlock();
+    closed = true;
+
+    LOG.debug("[{}] Rejecting {} queued requests after shutdown", logPrefix, queueSize.get());
+    Throttled request;
+    while ((request = queue.poll()) != null) {
+      queueSize.decrementAndGet();
+      fail(request, "The session is shutting down");
     }
   }
 
   public int getQueueSize() {
-    lock.lock();
-    try {
-      return queue.size();
-    } finally {
-      lock.unlock();
-    }
+    return queueSize.get();
   }
 
   @VisibleForTesting
   int getConcurrentRequests() {
-    lock.lock();
-    try {
-      return concurrentRequests;
-    } finally {
-      lock.unlock();
-    }
+    return concurrentRequests.get();
   }
 
   @VisibleForTesting
   Deque<Throttled> getQueue() {
-    lock.lock();
-    try {
-      return queue;
-    } finally {
-      lock.unlock();
-    }
+    return queue;
   }
 
   private static void fail(Throttled request, String message) {
diff --git a/manual/core/non_blocking/README.md b/manual/core/non_blocking/README.md
index 7abe9d856a3..f320ffd13d2 100644
--- a/manual/core/non_blocking/README.md
+++ b/manual/core/non_blocking/README.md
@@ -152,15 +152,13 @@ should not be used if strict lock-freedom is enforced.
 
 [`SafeInitNodeStateListener`]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/metadata/SafeInitNodeStateListener.html
 
-The same is valid for both built-in [request throttlers]:
+The `RateLimitingRequestThrottler` is currently blocking. The `ConcurrencyLimitingRequestThrottler`
+is lock-free.
 
-* `ConcurrencyLimitingRequestThrottler`
-* `RateLimitingRequestThrottler`
-
-See the section about [throttling](../throttling) for details about these components. Again, they 
-use locks internally, and depending on how many requests are being executed in parallel, the thread
-contention on these locks can be high: in short, if your application enforces strict lock-freedom, 
-then these components should not be used.
+See the section about [throttling](../throttling) for details about these components. Depending on
+how many requests are being executed in parallel, the thread contention on these locks can be high:
+in short, if your application enforces strict lock-freedom, then you should not use the
+`RateLimitingRequestThrottler`.
 
 [request throttlers]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/session/throttling/RequestThrottler.html
 

From 69eebb939c71dbb709099f7bf04b1a8b7e17012f Mon Sep 17 00:00:00 2001
From: Ivan Sopov <sopov.ivan@gmail.com>
Date: Mon, 28 Jul 2025 11:28:59 +0300
Subject: [PATCH 087/126] Change groupId in README

patch by Ivan Sopov; reviewed by Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/2049
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index b6e1cc337d8..0f6c2bb5a6f 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ and Cassandra Query Language (CQL) v3.
 
 ## Getting the driver
 
-The driver artifacts are published in Maven central, under the group id [com.datastax.oss]; there
+The driver artifacts are published in Maven central, under the group id [org.apache.cassandra]; there
 are multiple modules, all prefixed with `java-driver-`.
 
 ```xml
@@ -48,7 +48,7 @@ dependency if you plan to use it.
 Refer to each module's manual for more details ([core](manual/core/), [query
 builder](manual/query_builder/), [mapper](manual/mapper)).
 
-[com.datastax.oss]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.datastax.oss%22
+[org.apache.cassandra]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.apache.cassandra%22
 
 ## Compatibility
 

From 05e6717253d1c6ae0c5a9ce20fcf5ab448d32ec6 Mon Sep 17 00:00:00 2001
From: Kefu Chai <kefu.chai@scylladb.com>
Date: Fri, 12 Jul 2024 09:37:06 +0800
Subject: [PATCH 088/126] manual: correct the codeblock directive

patch by Kefu Chai; reviewed by Andy Tolbert and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/1940
---
 manual/mapper/daos/getentity/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/manual/mapper/daos/getentity/README.md b/manual/mapper/daos/getentity/README.md
index abb7cb076c8..de9a530b558 100644
--- a/manual/mapper/daos/getentity/README.md
+++ b/manual/mapper/daos/getentity/README.md
@@ -108,7 +108,7 @@ The method can return:
 * a single entity instance. If the argument is a result set type, the generated code will extract
   the first row and convert it, or return `null` if the result set is empty.
 
-    ````java
+    ```java
     @GetEntity
     Product asProduct(Row row);
 

From ff2d7f26c63e7a3ed3a74906771b246949112414 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Mon, 14 Apr 2025 16:40:53 +0200
Subject: [PATCH 089/126] CASSJAVA-92: Local DC provided for nodetool
 clientstats patch by Lukasz Antoniak; reviewed by Bret McGuire and Abe
 Ratnofsky for CASSJAVA-92

---
 .../loadbalancing/LoadBalancingPolicy.java    |   7 +
 .../core/context/DefaultDriverContext.java    |  14 +-
 .../core/context/StartupOptionsBuilder.java   |  28 ++++
 .../BasicLoadBalancingPolicy.java             |  31 ++++-
 .../DefaultLoadBalancingPolicy.java           |  10 ++
 .../helper/OptionalLocalDcHelper.java         |  31 +++--
 .../FixedHostNameAddressTranslatorTest.java   |   3 +-
 .../SubnetAddressTranslatorTest.java          |   3 +-
 .../context/DefaultDriverContextTest.java     |   2 +-
 .../context/MockedDriverContextFactory.java   | 124 +++++++++++++++---
 .../context/StartupOptionsBuilderTest.java    |  45 ++++++-
 11 files changed, 252 insertions(+), 46 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/loadbalancing/LoadBalancingPolicy.java b/core/src/main/java/com/datastax/oss/driver/api/core/loadbalancing/LoadBalancingPolicy.java
index d890ae6c100..de0d9db4ebd 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/loadbalancing/LoadBalancingPolicy.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/loadbalancing/LoadBalancingPolicy.java
@@ -24,6 +24,7 @@
 import com.datastax.oss.driver.api.core.tracker.RequestTracker;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Queue;
@@ -76,6 +77,12 @@ default Optional<RequestTracker> getRequestTracker() {
    */
   void init(@NonNull Map<UUID, Node> nodes, @NonNull DistanceReporter distanceReporter);
 
+  /** Returns map containing details that impact C* node connectivity. */
+  @NonNull
+  default Map<String, ?> getStartupConfiguration() {
+    return Collections.emptyMap();
+  }
+
   /**
    * Returns the coordinators to use for a new query.
    *
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java b/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
index a24b632f640..0d7db27dfbe 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
@@ -216,8 +216,8 @@ public class DefaultDriverContext implements InternalDriverContext {
       new LazyReference<>("metricIdGenerator", this::buildMetricIdGenerator, cycleDetector);
   private final LazyReference<RequestThrottler> requestThrottlerRef =
       new LazyReference<>("requestThrottler", this::buildRequestThrottler, cycleDetector);
-  private final LazyReference<Map<String, String>> startupOptionsRef =
-      new LazyReference<>("startupOptions", this::buildStartupOptions, cycleDetector);
+  private final LazyReference<StartupOptionsBuilder> startupOptionsRef =
+      new LazyReference<>("startupOptionsFactory", this::buildStartupOptionsFactory, cycleDetector);
   private final LazyReference<NodeStateListener> nodeStateListenerRef;
   private final LazyReference<SchemaChangeListener> schemaChangeListenerRef;
   private final LazyReference<RequestTracker> requestTrackerRef;
@@ -335,16 +335,15 @@ public DefaultDriverContext(
   }
 
   /**
-   * Builds a map of options to send in a Startup message.
+   * Returns builder of options to send in a Startup message.
    *
    * @see #getStartupOptions()
    */
-  protected Map<String, String> buildStartupOptions() {
+  protected StartupOptionsBuilder buildStartupOptionsFactory() {
     return new StartupOptionsBuilder(this)
         .withClientId(startupClientId)
         .withApplicationName(startupApplicationName)
-        .withApplicationVersion(startupApplicationVersion)
-        .build();
+        .withApplicationVersion(startupApplicationVersion);
   }
 
   protected Map<String, LoadBalancingPolicy> buildLoadBalancingPolicies() {
@@ -1013,7 +1012,8 @@ public ProtocolVersion getProtocolVersion() {
   @NonNull
   @Override
   public Map<String, String> getStartupOptions() {
-    return startupOptionsRef.get();
+    // startup options are calculated dynamically and may vary per connection
+    return startupOptionsRef.get().build();
   }
 
   protected RequestLogFormatter buildRequestLogFormatter() {
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/context/StartupOptionsBuilder.java b/core/src/main/java/com/datastax/oss/driver/internal/core/context/StartupOptionsBuilder.java
index 684d6b01b9c..89a9266b3ac 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/context/StartupOptionsBuilder.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/context/StartupOptionsBuilder.java
@@ -19,24 +19,34 @@
 
 import com.datastax.dse.driver.api.core.config.DseDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverExecutionProfile;
+import com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy;
 import com.datastax.oss.driver.api.core.session.Session;
 import com.datastax.oss.driver.api.core.uuid.Uuids;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import com.datastax.oss.protocol.internal.request.Startup;
 import com.datastax.oss.protocol.internal.util.collection.NullAllowingImmutableMap;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 import net.jcip.annotations.Immutable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 @Immutable
 public class StartupOptionsBuilder {
 
   public static final String DRIVER_NAME_KEY = "DRIVER_NAME";
   public static final String DRIVER_VERSION_KEY = "DRIVER_VERSION";
+  public static final String DRIVER_BAGGAGE = "DRIVER_BAGGAGE";
   public static final String APPLICATION_NAME_KEY = "APPLICATION_NAME";
   public static final String APPLICATION_VERSION_KEY = "APPLICATION_VERSION";
   public static final String CLIENT_ID_KEY = "CLIENT_ID";
 
+  private static final Logger LOG = LoggerFactory.getLogger(StartupOptionsBuilder.class);
+  private static final ObjectMapper mapper = new ObjectMapper();
+
   protected final InternalDriverContext context;
   private UUID clientId;
   private String applicationName;
@@ -119,6 +129,7 @@ public Map<String, String> build() {
     if (applicationVersion != null) {
       builder.put(APPLICATION_VERSION_KEY, applicationVersion);
     }
+    driverBaggage().ifPresent(s -> builder.put(DRIVER_BAGGAGE, s));
 
     return builder.build();
   }
@@ -142,4 +153,21 @@ protected String getDriverName() {
   protected String getDriverVersion() {
     return Session.OSS_DRIVER_COORDINATES.getVersion().toString();
   }
+
+  private Optional<String> driverBaggage() {
+    ImmutableMap.Builder<String, Object> builder = new ImmutableMap.Builder<>();
+    for (Map.Entry<String, LoadBalancingPolicy> entry :
+        context.getLoadBalancingPolicies().entrySet()) {
+      Map<String, ?> config = entry.getValue().getStartupConfiguration();
+      if (!config.isEmpty()) {
+        builder.put(entry.getKey(), config);
+      }
+    }
+    try {
+      return Optional.of(mapper.writeValueAsString(builder.build()));
+    } catch (Exception e) {
+      LOG.warn("Failed to construct startup driver baggage", e);
+      return Optional.empty();
+    }
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java
index 587ef4183bd..a02a5eb3148 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java
@@ -45,6 +45,7 @@
 import com.datastax.oss.driver.internal.core.util.collection.QueryPlan;
 import com.datastax.oss.driver.internal.core.util.collection.SimpleQueryPlan;
 import com.datastax.oss.driver.shaded.guava.common.base.Predicates;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import com.datastax.oss.driver.shaded.guava.common.collect.Lists;
 import com.datastax.oss.driver.shaded.guava.common.collect.Sets;
 import edu.umd.cs.findbugs.annotations.NonNull;
@@ -155,10 +156,38 @@ public BasicLoadBalancingPolicy(@NonNull DriverContext context, @NonNull String
    * Before initialization, this method always returns null.
    */
   @Nullable
-  protected String getLocalDatacenter() {
+  public String getLocalDatacenter() {
     return localDc;
   }
 
+  @NonNull
+  @Override
+  public Map<String, ?> getStartupConfiguration() {
+    ImmutableMap.Builder<String, Object> builder = new ImmutableMap.Builder<>();
+    if (localDc != null) {
+      builder.put("localDc", localDc);
+    } else {
+      // Local data center may not be discovered prior to connection pool initialization.
+      // In such scenario, return configured local data center name.
+      // Note that when using DC inferring load balancing policy, startup configuration
+      // may not show local DC name, because it will be discovered only once control connection
+      // is established and datacenter of contact points known.
+      Optional<String> configuredDc =
+          new OptionalLocalDcHelper(context, profile, logPrefix).configuredLocalDc();
+      configuredDc.ifPresent(d -> builder.put("localDc", d));
+    }
+    if (!preferredRemoteDcs.isEmpty()) {
+      builder.put("preferredRemoteDcs", preferredRemoteDcs);
+    }
+    if (allowDcFailoverForLocalCl) {
+      builder.put("allowDcFailoverForLocalCl", allowDcFailoverForLocalCl);
+    }
+    if (maxNodesPerRemoteDc > 0) {
+      builder.put("maxNodesPerRemoteDc", maxNodesPerRemoteDc);
+    }
+    return ImmutableMap.of(BasicLoadBalancingPolicy.class.getSimpleName(), builder.build());
+  }
+
   /** @return The nodes currently considered as live. */
   protected NodeSet getLiveNodes() {
     return liveNodes;
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
index 0f03cbb3643..9c31b606f18 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
@@ -34,6 +34,7 @@
 import com.datastax.oss.driver.internal.core.util.collection.QueryPlan;
 import com.datastax.oss.driver.internal.core.util.collection.SimpleQueryPlan;
 import com.datastax.oss.driver.shaded.guava.common.annotations.VisibleForTesting;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import com.datastax.oss.driver.shaded.guava.common.collect.MapMaker;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
@@ -350,4 +351,13 @@ private boolean hasSufficientResponses(long now) {
       return this.oldest - threshold >= 0;
     }
   }
+
+  @NonNull
+  @Override
+  public Map<String, ?> getStartupConfiguration() {
+    Map<String, ?> parent = super.getStartupConfiguration();
+    return ImmutableMap.of(
+        DefaultLoadBalancingPolicy.class.getSimpleName(),
+        parent.get(BasicLoadBalancingPolicy.class.getSimpleName()));
+  }
 }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/helper/OptionalLocalDcHelper.java b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/helper/OptionalLocalDcHelper.java
index d470f96c42c..c6143f3fa16 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/helper/OptionalLocalDcHelper.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/helper/OptionalLocalDcHelper.java
@@ -65,20 +65,14 @@ public OptionalLocalDcHelper(
   @Override
   @NonNull
   public Optional<String> discoverLocalDc(@NonNull Map<UUID, Node> nodes) {
-    String localDc = context.getLocalDatacenter(profile.getName());
-    if (localDc != null) {
-      LOG.debug("[{}] Local DC set programmatically: {}", logPrefix, localDc);
-      checkLocalDatacenterCompatibility(localDc, context.getMetadataManager().getContactPoints());
-      return Optional.of(localDc);
-    } else if (profile.isDefined(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER)) {
-      localDc = profile.getString(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER);
-      LOG.debug("[{}] Local DC set from configuration: {}", logPrefix, localDc);
-      checkLocalDatacenterCompatibility(localDc, context.getMetadataManager().getContactPoints());
-      return Optional.of(localDc);
+    Optional<String> localDc = configuredLocalDc();
+    if (localDc.isPresent()) {
+      checkLocalDatacenterCompatibility(
+          localDc.get(), context.getMetadataManager().getContactPoints());
     } else {
       LOG.debug("[{}] Local DC not set, DC awareness will be disabled", logPrefix);
-      return Optional.empty();
     }
+    return localDc;
   }
 
   /**
@@ -138,4 +132,19 @@ protected String formatDcs(Iterable<? extends Node> nodes) {
     }
     return String.join(", ", new TreeSet<>(l));
   }
+
+  /** @return Local data center set programmatically or from configuration file. */
+  @NonNull
+  public Optional<String> configuredLocalDc() {
+    String localDc = context.getLocalDatacenter(profile.getName());
+    if (localDc != null) {
+      LOG.debug("[{}] Local DC set programmatically: {}", logPrefix, localDc);
+      return Optional.of(localDc);
+    } else if (profile.isDefined(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER)) {
+      localDc = profile.getString(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER);
+      LOG.debug("[{}] Local DC set from configuration: {}", logPrefix, localDc);
+      return Optional.of(localDc);
+    }
+    return Optional.empty();
+  }
 }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslatorTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslatorTest.java
index 92800998056..3bb9c4bc291 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslatorTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/FixedHostNameAddressTranslatorTest.java
@@ -26,7 +26,6 @@
 import com.datastax.oss.driver.internal.core.context.DefaultDriverContext;
 import com.datastax.oss.driver.internal.core.context.MockedDriverContextFactory;
 import java.net.InetSocketAddress;
-import java.util.Optional;
 import org.junit.Test;
 
 public class FixedHostNameAddressTranslatorTest {
@@ -36,7 +35,7 @@ public void should_translate_address() {
     DriverExecutionProfile defaultProfile = mock(DriverExecutionProfile.class);
     when(defaultProfile.getString(ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME)).thenReturn("myaddress");
     DefaultDriverContext defaultDriverContext =
-        MockedDriverContextFactory.defaultDriverContext(Optional.of(defaultProfile));
+        MockedDriverContextFactory.defaultDriverContext(defaultProfile);
 
     FixedHostNameAddressTranslator translator =
         new FixedHostNameAddressTranslator(defaultDriverContext);
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslatorTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslatorTest.java
index 2aa6ae75bc2..420170654dc 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslatorTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/addresstranslation/SubnetAddressTranslatorTest.java
@@ -30,7 +30,6 @@
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import java.net.InetSocketAddress;
 import java.util.Map;
-import java.util.Optional;
 import org.junit.Test;
 
 @SuppressWarnings("resource")
@@ -148,6 +147,6 @@ public void should_fail_on_default_address_without_port() {
   private static DefaultDriverContext context(Map<String, String> subnetAddresses) {
     DriverExecutionProfile profile = mock(DriverExecutionProfile.class);
     when(profile.getStringMap(ADDRESS_TRANSLATOR_SUBNET_ADDRESSES)).thenReturn(subnetAddresses);
-    return MockedDriverContextFactory.defaultDriverContext(Optional.of(profile));
+    return MockedDriverContextFactory.defaultDriverContext(profile);
   }
 }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContextTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContextTest.java
index baf101508d4..6d4585cb4d7 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContextTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContextTest.java
@@ -42,7 +42,7 @@ private DefaultDriverContext buildMockedContext(Optional<String> compressionOpti
     DriverExecutionProfile defaultProfile = mock(DriverExecutionProfile.class);
     when(defaultProfile.getString(DefaultDriverOption.PROTOCOL_COMPRESSION, "none"))
         .thenReturn(compressionOption.orElse("none"));
-    return MockedDriverContextFactory.defaultDriverContext(Optional.of(defaultProfile));
+    return MockedDriverContextFactory.defaultDriverContext(defaultProfile);
   }
 
   private void doCreateCompressorTest(Optional<String> configVal, Class<?> expectedClz) {
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/context/MockedDriverContextFactory.java b/core/src/test/java/com/datastax/oss/driver/internal/core/context/MockedDriverContextFactory.java
index 06817326844..a8b25193f54 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/context/MockedDriverContextFactory.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/context/MockedDriverContextFactory.java
@@ -24,44 +24,45 @@
 import com.datastax.oss.driver.api.core.config.DriverConfig;
 import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
 import com.datastax.oss.driver.api.core.config.DriverExecutionProfile;
+import com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy;
+import com.datastax.oss.driver.api.core.loadbalancing.NodeDistanceEvaluator;
+import com.datastax.oss.driver.api.core.metadata.Node;
 import com.datastax.oss.driver.api.core.metadata.NodeStateListener;
 import com.datastax.oss.driver.api.core.metadata.schema.SchemaChangeListener;
 import com.datastax.oss.driver.api.core.session.ProgrammaticArguments;
 import com.datastax.oss.driver.api.core.tracker.RequestTracker;
+import com.datastax.oss.driver.internal.core.ConsistencyLevelRegistry;
+import com.datastax.oss.driver.internal.core.loadbalancing.DefaultLoadBalancingPolicy;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import com.datastax.oss.driver.shaded.guava.common.collect.Maps;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
 import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.UUID;
 
 public class MockedDriverContextFactory {
 
   public static DefaultDriverContext defaultDriverContext() {
-    return defaultDriverContext(Optional.empty());
+    return defaultDriverContext(MockedDriverContextFactory.defaultProfile("datacenter1"));
   }
 
   public static DefaultDriverContext defaultDriverContext(
-      Optional<DriverExecutionProfile> profileOption) {
-
-    /* If the caller provided a profile use that, otherwise make a new one */
-    final DriverExecutionProfile profile =
-        profileOption.orElseGet(
-            () -> {
-              DriverExecutionProfile blankProfile = mock(DriverExecutionProfile.class);
-              when(blankProfile.getString(DefaultDriverOption.PROTOCOL_COMPRESSION, "none"))
-                  .thenReturn("none");
-              when(blankProfile.getDuration(DefaultDriverOption.METRICS_NODE_EXPIRE_AFTER))
-                  .thenReturn(Duration.ofMinutes(5));
-              when(blankProfile.isDefined(DefaultDriverOption.METRICS_FACTORY_CLASS))
-                  .thenReturn(true);
-              when(blankProfile.getString(DefaultDriverOption.METRICS_FACTORY_CLASS))
-                  .thenReturn("DefaultMetricsFactory");
-              return blankProfile;
-            });
+      DriverExecutionProfile defaultProfile, DriverExecutionProfile... profiles) {
 
     /* Setup machinery to connect the input DriverExecutionProfile to the config loader */
     final DriverConfig driverConfig = mock(DriverConfig.class);
     final DriverConfigLoader configLoader = mock(DriverConfigLoader.class);
     when(configLoader.getInitialConfig()).thenReturn(driverConfig);
-    when(driverConfig.getDefaultProfile()).thenReturn(profile);
+    when(driverConfig.getDefaultProfile()).thenReturn(defaultProfile);
+    when(driverConfig.getProfile(defaultProfile.getName())).thenReturn(defaultProfile);
+
+    for (DriverExecutionProfile profile : profiles) {
+      when(driverConfig.getProfile(profile.getName())).thenReturn(profile);
+    }
 
     ProgrammaticArguments args =
         ProgrammaticArguments.builder()
@@ -71,6 +72,89 @@ public static DefaultDriverContext defaultDriverContext(
             .withLocalDatacenters(Maps.newHashMap())
             .withNodeDistanceEvaluators(Maps.newHashMap())
             .build();
-    return new DefaultDriverContext(configLoader, args);
+
+    return new DefaultDriverContext(configLoader, args) {
+      @NonNull
+      @Override
+      public Map<String, LoadBalancingPolicy> getLoadBalancingPolicies() {
+        ImmutableMap.Builder<String, LoadBalancingPolicy> map = ImmutableMap.builder();
+        map.put(
+            defaultProfile.getName(),
+            mockLoadBalancingPolicy(
+                this,
+                defaultProfile.getName(),
+                defaultProfile.getString(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER)));
+        for (DriverExecutionProfile profile : profiles) {
+          map.put(
+              profile.getName(),
+              mockLoadBalancingPolicy(
+                  this,
+                  profile.getName(),
+                  profile.getString(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER)));
+        }
+        return map.build();
+      }
+
+      @NonNull
+      @Override
+      public ConsistencyLevelRegistry getConsistencyLevelRegistry() {
+        return mock(ConsistencyLevelRegistry.class);
+      }
+    };
+  }
+
+  public static DriverExecutionProfile defaultProfile(String localDc) {
+    return createProfile(DriverExecutionProfile.DEFAULT_NAME, localDc);
+  }
+
+  public static DriverExecutionProfile createProfile(String name, String localDc) {
+    DriverExecutionProfile defaultProfile = mock(DriverExecutionProfile.class);
+    when(defaultProfile.getName()).thenReturn(name);
+    when(defaultProfile.getString(DefaultDriverOption.PROTOCOL_COMPRESSION, "none"))
+        .thenReturn("none");
+    when(defaultProfile.getDuration(DefaultDriverOption.METRICS_NODE_EXPIRE_AFTER))
+        .thenReturn(Duration.ofMinutes(5));
+    when(defaultProfile.isDefined(DefaultDriverOption.METRICS_FACTORY_CLASS)).thenReturn(true);
+    when(defaultProfile.getString(DefaultDriverOption.METRICS_FACTORY_CLASS))
+        .thenReturn("DefaultMetricsFactory");
+    when(defaultProfile.getString(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER))
+        .thenReturn(localDc);
+    return defaultProfile;
+  }
+
+  public static void allowRemoteDcConnectivity(
+      DriverExecutionProfile profile,
+      int maxNodesPerRemoteDc,
+      boolean allowRemoteSatisfyLocalDc,
+      List<String> preferredRemoteDcs) {
+    when(profile.getInt(DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_MAX_NODES_PER_REMOTE_DC))
+        .thenReturn(maxNodesPerRemoteDc);
+    when(profile.getBoolean(
+            DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_ALLOW_FOR_LOCAL_CONSISTENCY_LEVELS))
+        .thenReturn(allowRemoteSatisfyLocalDc);
+    when(profile.getStringList(DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS))
+        .thenReturn(preferredRemoteDcs);
+  }
+
+  private static LoadBalancingPolicy mockLoadBalancingPolicy(
+      DefaultDriverContext driverContext, String profile, String localDc) {
+    LoadBalancingPolicy loadBalancingPolicy =
+        new DefaultLoadBalancingPolicy(driverContext, profile) {
+          @NonNull
+          @Override
+          protected Optional<String> discoverLocalDc(@NonNull Map<UUID, Node> nodes) {
+            return Optional.ofNullable(localDc);
+          }
+
+          @NonNull
+          @Override
+          protected NodeDistanceEvaluator createNodeDistanceEvaluator(
+              @Nullable String localDc, @NonNull Map<UUID, Node> nodes) {
+            return mock(NodeDistanceEvaluator.class);
+          }
+        };
+    loadBalancingPolicy.init(
+        Collections.emptyMap(), mock(LoadBalancingPolicy.DistanceReporter.class));
+    return loadBalancingPolicy;
   }
 }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/context/StartupOptionsBuilderTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/context/StartupOptionsBuilderTest.java
index 33811b2793a..d12e50b7e8e 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/context/StartupOptionsBuilderTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/context/StartupOptionsBuilderTest.java
@@ -26,10 +26,10 @@
 import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverExecutionProfile;
 import com.datastax.oss.driver.api.core.session.Session;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
 import com.datastax.oss.protocol.internal.request.Startup;
 import com.tngtech.java.junit.dataprovider.DataProvider;
 import com.tngtech.java.junit.dataprovider.DataProviderRunner;
-import java.util.Optional;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -41,7 +41,8 @@ private DefaultDriverContext buildMockedContext(String compression) {
     DriverExecutionProfile defaultProfile = mock(DriverExecutionProfile.class);
     when(defaultProfile.getString(DefaultDriverOption.PROTOCOL_COMPRESSION, "none"))
         .thenReturn(compression);
-    return MockedDriverContextFactory.defaultDriverContext(Optional.of(defaultProfile));
+    when(defaultProfile.getName()).thenReturn(DriverExecutionProfile.DEFAULT_NAME);
+    return MockedDriverContextFactory.defaultDriverContext(defaultProfile);
   }
 
   private void assertDefaultStartupOptions(Startup startup) {
@@ -94,4 +95,44 @@ public void should_fail_to_build_startup_options_with_invalid_compression() {
               new Startup(ctx.getStartupOptions());
             });
   }
+
+  @Test
+  public void should_include_all_local_dcs_in_startup_message() {
+
+    DefaultDriverContext ctx =
+        MockedDriverContextFactory.defaultDriverContext(
+            MockedDriverContextFactory.defaultProfile("us-west-2"),
+            MockedDriverContextFactory.createProfile("oltp", "us-east-2"),
+            MockedDriverContextFactory.createProfile("olap", "eu-central-1"));
+    Startup startup = new Startup(ctx.getStartupOptions());
+    assertThat(startup.options)
+        .containsEntry(
+            StartupOptionsBuilder.DRIVER_BAGGAGE,
+            "{\"default\":{\"DefaultLoadBalancingPolicy\":{\"localDc\":\"us-west-2\"}},"
+                + "\"oltp\":{\"DefaultLoadBalancingPolicy\":{\"localDc\":\"us-east-2\"}},"
+                + "\"olap\":{\"DefaultLoadBalancingPolicy\":{\"localDc\":\"eu-central-1\"}}}");
+  }
+
+  @Test
+  public void should_include_all_lbp_details_in_startup_message() {
+
+    DriverExecutionProfile defaultProfile = MockedDriverContextFactory.defaultProfile("dc1");
+    DriverExecutionProfile oltpProfile = MockedDriverContextFactory.createProfile("oltp", "dc1");
+    MockedDriverContextFactory.allowRemoteDcConnectivity(
+        oltpProfile, 2, true, ImmutableList.of("dc2", "dc3"));
+    DefaultDriverContext ctx =
+        MockedDriverContextFactory.defaultDriverContext(defaultProfile, oltpProfile);
+
+    Startup startup = new Startup(ctx.getStartupOptions());
+
+    assertThat(startup.options)
+        .containsEntry(
+            StartupOptionsBuilder.DRIVER_BAGGAGE,
+            "{\"default\":{\"DefaultLoadBalancingPolicy\":{\"localDc\":\"dc1\"}},"
+                + "\"oltp\":{\"DefaultLoadBalancingPolicy\":{"
+                + "\"localDc\":\"dc1\","
+                + "\"preferredRemoteDcs\":[\"dc2\",\"dc3\"],"
+                + "\"allowDcFailoverForLocalCl\":true,"
+                + "\"maxNodesPerRemoteDc\":2}}}");
+  }
 }

From e2c7ad4d11555eeacce6bd436547b403f83eb24f Mon Sep 17 00:00:00 2001
From: janehe <siyaoh4@uci.edu>
Date: Tue, 15 Apr 2025 13:18:34 -0700
Subject: [PATCH 090/126] CASSJAVA-97: Let users inject an ID for each request
 and write to the custom payload

patch by Jane He; reviewed by Abe Ratnofsky and Bret McGuire for CASSJAVA-97
---
 core/revapi.json                              |   5 +
 .../api/core/config/DefaultDriverOption.java  |   6 +
 .../api/core/config/TypedDriverOption.java    |   4 +
 .../api/core/context/DriverContext.java       |   5 +
 .../core/session/ProgrammaticArguments.java   |  17 +++
 .../api/core/session/SessionBuilder.java      |  22 +++
 .../api/core/tracker/RequestIdGenerator.java  |  77 +++++++++++
 .../api/core/tracker/RequestTracker.java      |  41 +++---
 .../core/context/DefaultDriverContext.java    |  24 ++++
 .../internal/core/cql/CqlRequestHandler.java  |  59 +++++++--
 .../DefaultLoadBalancingPolicy.java           |   4 +-
 .../tracker/MultiplexingRequestTracker.java   |  31 +++--
 .../core/tracker/NoopRequestTracker.java      |   8 +-
 .../internal/core/tracker/RequestLogger.java  |  12 +-
 .../core/tracker/UuidRequestIdGenerator.java  |  43 ++++++
 .../tracker/W3CContextRequestIdGenerator.java |  67 ++++++++++
 core/src/main/resources/reference.conf        |   7 +
 .../core/cql/RequestHandlerTestHarness.java   |   3 +
 .../core/tracker/RequestIdGeneratorTest.java  |  80 +++++++++++
 .../core/tracker/RequestIdGeneratorIT.java    | 125 ++++++++++++++++++
 .../tracker/RequestNodeLoggerExample.java     |   8 +-
 manual/core/request_id/README.md              |  48 +++++++
 22 files changed, 637 insertions(+), 59 deletions(-)
 create mode 100644 core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestIdGenerator.java
 create mode 100644 core/src/main/java/com/datastax/oss/driver/internal/core/tracker/UuidRequestIdGenerator.java
 create mode 100644 core/src/main/java/com/datastax/oss/driver/internal/core/tracker/W3CContextRequestIdGenerator.java
 create mode 100644 core/src/test/java/com/datastax/oss/driver/internal/core/tracker/RequestIdGeneratorTest.java
 create mode 100644 integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestIdGeneratorIT.java
 create mode 100644 manual/core/request_id/README.md

diff --git a/core/revapi.json b/core/revapi.json
index f39c7d4a7c0..8c707659c13 100644
--- a/core/revapi.json
+++ b/core/revapi.json
@@ -7407,6 +7407,11 @@
       {
         "code": "java.method.varargOverloadsOnlyDifferInVarargParameter",
         "justification": "CASSJAVA-102: Migrate revapi config into dedicated config files, ported from pom.xml"
+      },
+      {
+        "code": "java.method.addedToInterface",
+        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.tracker.RequestIdGenerator> com.datastax.oss.driver.api.core.context.DriverContext::getRequestIdGenerator()",
+        "justification": "CASSJAVA-97: Let users inject an ID for each request and write to the custom payload"
       }
     ]
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
index 4e45bf7b117..60c44193577 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
@@ -995,6 +995,12 @@ public enum DefaultDriverOption implements DriverOption {
    * <p>Value-type: boolean
    */
   SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN("advanced.ssl-engine-factory.allow-dns-reverse-lookup-san"),
+  /**
+   * The class of session-wide component that generates request IDs.
+   *
+   * <p>Value-type: {@link String}
+   */
+  REQUEST_ID_GENERATOR_CLASS("advanced.request-id.generator.class"),
   /**
    * An address to always translate all node addresses to that same proxy hostname no matter what IP
    * address a node has, but still using its native transport port.
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
index aa4e4af12dc..182753300e7 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
@@ -281,6 +281,10 @@ public String toString() {
       new TypedDriverOption<>(
           DefaultDriverOption.REQUEST_TRACKER_CLASSES, GenericType.listOf(String.class));
 
+  /** The class of a session-wide component that generates request IDs. */
+  public static final TypedDriverOption<String> REQUEST_ID_GENERATOR_CLASS =
+      new TypedDriverOption<>(DefaultDriverOption.REQUEST_ID_GENERATOR_CLASS, GenericType.STRING);
+
   /** Whether to log successful requests. */
   public static final TypedDriverOption<Boolean> REQUEST_LOGGER_SUCCESS_ENABLED =
       new TypedDriverOption<>(
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/context/DriverContext.java b/core/src/main/java/com/datastax/oss/driver/api/core/context/DriverContext.java
index 5b32389e362..6f0afd3df8a 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/context/DriverContext.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/context/DriverContext.java
@@ -33,6 +33,7 @@
 import com.datastax.oss.driver.api.core.specex.SpeculativeExecutionPolicy;
 import com.datastax.oss.driver.api.core.ssl.SslEngineFactory;
 import com.datastax.oss.driver.api.core.time.TimestampGenerator;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
 import com.datastax.oss.driver.api.core.tracker.RequestTracker;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.util.Map;
@@ -139,6 +140,10 @@ default SpeculativeExecutionPolicy getSpeculativeExecutionPolicy(@NonNull String
   @NonNull
   RequestTracker getRequestTracker();
 
+  /** @return The driver's request ID generator; never {@code null}. */
+  @NonNull
+  Optional<RequestIdGenerator> getRequestIdGenerator();
+
   /** @return The driver's request throttler; never {@code null}. */
   @NonNull
   RequestThrottler getRequestThrottler();
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/session/ProgrammaticArguments.java b/core/src/main/java/com/datastax/oss/driver/api/core/session/ProgrammaticArguments.java
index 4e08bd5434c..5e10fb4d915 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/session/ProgrammaticArguments.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/session/ProgrammaticArguments.java
@@ -23,6 +23,7 @@
 import com.datastax.oss.driver.api.core.metadata.NodeStateListener;
 import com.datastax.oss.driver.api.core.metadata.schema.SchemaChangeListener;
 import com.datastax.oss.driver.api.core.ssl.SslEngineFactory;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
 import com.datastax.oss.driver.api.core.tracker.RequestTracker;
 import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
 import com.datastax.oss.driver.api.core.type.codec.registry.MutableCodecRegistry;
@@ -59,6 +60,7 @@ public static Builder builder() {
   private final NodeStateListener nodeStateListener;
   private final SchemaChangeListener schemaChangeListener;
   private final RequestTracker requestTracker;
+  private final RequestIdGenerator requestIdGenerator;
   private final Map<String, String> localDatacenters;
   private final Map<String, Predicate<Node>> nodeFilters;
   private final Map<String, NodeDistanceEvaluator> nodeDistanceEvaluators;
@@ -77,6 +79,7 @@ private ProgrammaticArguments(
       @Nullable NodeStateListener nodeStateListener,
       @Nullable SchemaChangeListener schemaChangeListener,
       @Nullable RequestTracker requestTracker,
+      @Nullable RequestIdGenerator requestIdGenerator,
       @NonNull Map<String, String> localDatacenters,
       @NonNull Map<String, Predicate<Node>> nodeFilters,
       @NonNull Map<String, NodeDistanceEvaluator> nodeDistanceEvaluators,
@@ -94,6 +97,7 @@ private ProgrammaticArguments(
     this.nodeStateListener = nodeStateListener;
     this.schemaChangeListener = schemaChangeListener;
     this.requestTracker = requestTracker;
+    this.requestIdGenerator = requestIdGenerator;
     this.localDatacenters = localDatacenters;
     this.nodeFilters = nodeFilters;
     this.nodeDistanceEvaluators = nodeDistanceEvaluators;
@@ -128,6 +132,11 @@ public RequestTracker getRequestTracker() {
     return requestTracker;
   }
 
+  @Nullable
+  public RequestIdGenerator getRequestIdGenerator() {
+    return requestIdGenerator;
+  }
+
   @NonNull
   public Map<String, String> getLocalDatacenters() {
     return localDatacenters;
@@ -196,6 +205,7 @@ public static class Builder {
     private NodeStateListener nodeStateListener;
     private SchemaChangeListener schemaChangeListener;
     private RequestTracker requestTracker;
+    private RequestIdGenerator requestIdGenerator;
     private ImmutableMap.Builder<String, String> localDatacentersBuilder = ImmutableMap.builder();
     private final ImmutableMap.Builder<String, Predicate<Node>> nodeFiltersBuilder =
         ImmutableMap.builder();
@@ -294,6 +304,12 @@ public Builder addRequestTracker(@NonNull RequestTracker requestTracker) {
       return this;
     }
 
+    @NonNull
+    public Builder withRequestIdGenerator(@Nullable RequestIdGenerator requestIdGenerator) {
+      this.requestIdGenerator = requestIdGenerator;
+      return this;
+    }
+
     @NonNull
     public Builder withLocalDatacenter(
         @NonNull String profileName, @NonNull String localDatacenter) {
@@ -417,6 +433,7 @@ public ProgrammaticArguments build() {
           nodeStateListener,
           schemaChangeListener,
           requestTracker,
+          requestIdGenerator,
           localDatacentersBuilder.build(),
           nodeFiltersBuilder.build(),
           nodeDistanceEvaluatorsBuilder.build(),
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/session/SessionBuilder.java b/core/src/main/java/com/datastax/oss/driver/api/core/session/SessionBuilder.java
index cbf896a0873..25500119047 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/session/SessionBuilder.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/session/SessionBuilder.java
@@ -35,6 +35,7 @@
 import com.datastax.oss.driver.api.core.metadata.schema.SchemaChangeListener;
 import com.datastax.oss.driver.api.core.ssl.ProgrammaticSslEngineFactory;
 import com.datastax.oss.driver.api.core.ssl.SslEngineFactory;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
 import com.datastax.oss.driver.api.core.tracker.RequestTracker;
 import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
 import com.datastax.oss.driver.api.core.type.codec.registry.MutableCodecRegistry;
@@ -47,6 +48,7 @@
 import com.datastax.oss.driver.internal.core.context.InternalDriverContext;
 import com.datastax.oss.driver.internal.core.metadata.DefaultEndPoint;
 import com.datastax.oss.driver.internal.core.session.DefaultSession;
+import com.datastax.oss.driver.internal.core.tracker.W3CContextRequestIdGenerator;
 import com.datastax.oss.driver.internal.core.util.concurrent.BlockingOperation;
 import com.datastax.oss.driver.internal.core.util.concurrent.CompletableFutures;
 import edu.umd.cs.findbugs.annotations.NonNull;
@@ -83,6 +85,8 @@
 @NotThreadSafe
 public abstract class SessionBuilder<SelfT extends SessionBuilder, SessionT> {
 
+  public static final String ASTRA_PAYLOAD_KEY = "traceparent";
+
   private static final Logger LOG = LoggerFactory.getLogger(SessionBuilder.class);
 
   @SuppressWarnings("unchecked")
@@ -318,6 +322,17 @@ public SelfT addRequestTracker(@NonNull RequestTracker requestTracker) {
     return self;
   }
 
+  /**
+   * Registers a request ID generator. The driver will use the generated ID in the logs and
+   * optionally add to the custom payload so that users can correlate logs about the same request
+   * from the Cassandra side.
+   */
+  @NonNull
+  public SelfT withRequestIdGenerator(@NonNull RequestIdGenerator requestIdGenerator) {
+    this.programmaticArgumentsBuilder.withRequestIdGenerator(requestIdGenerator);
+    return self;
+  }
+
   /**
    * Registers an authentication provider to use with the session.
    *
@@ -861,6 +876,13 @@ protected final CompletionStage<CqlSession> buildDefaultSessionAsync() {
       List<String> configContactPoints =
           defaultConfig.getStringList(DefaultDriverOption.CONTACT_POINTS, Collections.emptyList());
       if (cloudConfigInputStream != null) {
+        // override request id generator, unless user has already set it
+        if (programmaticArguments.getRequestIdGenerator() == null) {
+          programmaticArgumentsBuilder.withRequestIdGenerator(
+              new W3CContextRequestIdGenerator(ASTRA_PAYLOAD_KEY));
+          LOG.debug(
+              "A secure connect bundle is provided, using W3CContextRequestIdGenerator as request ID generator.");
+        }
         if (!programmaticContactPoints.isEmpty() || !configContactPoints.isEmpty()) {
           LOG.info(
               "Both a secure connect bundle and contact points were provided. These are mutually exclusive. The contact points from the secure bundle will have priority.");
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestIdGenerator.java b/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestIdGenerator.java
new file mode 100644
index 00000000000..59ac3fdacf7
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestIdGenerator.java
@@ -0,0 +1,77 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.api.core.tracker;
+
+import com.datastax.oss.driver.api.core.cql.Statement;
+import com.datastax.oss.driver.api.core.session.Request;
+import com.datastax.oss.protocol.internal.util.collection.NullAllowingImmutableMap;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+/**
+ * Interface responsible for generating request IDs.
+ *
+ * <p>Note that all request IDs have a parent/child relationship. A "parent ID" can loosely be
+ * thought of as encompassing a sequence of a request + any attendant retries, speculative
+ * executions etc. It's scope is identical to that of a {@link
+ * com.datastax.oss.driver.internal.core.cql.CqlRequestHandler}. A "request ID" represents a single
+ * request within this larger scope. Note that a request corresponding to a request ID may be
+ * retried; in that case the retry count will be appended to the corresponding identifier in the
+ * logs.
+ */
+public interface RequestIdGenerator {
+
+  String DEFAULT_PAYLOAD_KEY = "request-id";
+
+  /**
+   * Generates a unique identifier for the session request. This will be the identifier for the
+   * entire `session.execute()` call. This identifier will be added to logs, and propagated to
+   * request trackers.
+   *
+   * @return a unique identifier for the session request
+   */
+  String getSessionRequestId();
+
+  /**
+   * Generates a unique identifier for the node request. This will be the identifier for the CQL
+   * request against a particular node. There can be one or more node requests for a single session
+   * request, due to retries or speculative executions. This identifier will be added to logs, and
+   * propagated to request trackers.
+   *
+   * @param statement the statement to be executed
+   * @param parentId the session request identifier
+   * @return a unique identifier for the node request
+   */
+  String getNodeRequestId(@NonNull Request statement, @NonNull String parentId);
+
+  default String getCustomPayloadKey() {
+    return DEFAULT_PAYLOAD_KEY;
+  }
+
+  default Statement<?> getDecoratedStatement(
+      @NonNull Statement<?> statement, @NonNull String requestId) {
+    Map<String, ByteBuffer> customPayload =
+        NullAllowingImmutableMap.<String, ByteBuffer>builder()
+            .putAll(statement.getCustomPayload())
+            .put(getCustomPayloadKey(), ByteBuffer.wrap(requestId.getBytes(StandardCharsets.UTF_8)))
+            .build();
+    return statement.setCustomPayload(customPayload);
+  }
+}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestTracker.java b/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestTracker.java
index d29ee48d352..065b41e496a 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestTracker.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestTracker.java
@@ -47,21 +47,22 @@ default void onSuccess(
       @NonNull Node node) {}
 
   /**
-   * Invoked each time a request succeeds.
+   * Invoked each time a session request succeeds. A session request is a `session.execute()` call
    *
    * @param latencyNanos the overall execution time (from the {@link Session#execute(Request,
    *     GenericType) session.execute} call until the result is made available to the client).
    * @param executionProfile the execution profile of this request.
    * @param node the node that returned the successful response.
-   * @param requestLogPrefix the dedicated log prefix for this request
+   * @param sessionRequestLogPrefix the dedicated log prefix for this request
    */
   default void onSuccess(
       @NonNull Request request,
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String requestLogPrefix) {
-    // If client doesn't override onSuccess with requestLogPrefix delegate call to the old method
+      @NonNull String sessionRequestLogPrefix) {
+    // If client doesn't override onSuccess with sessionRequestLogPrefix delegate call to the old
+    // method
     onSuccess(request, latencyNanos, executionProfile, node);
   }
 
@@ -78,13 +79,13 @@ default void onError(
       @Nullable Node node) {}
 
   /**
-   * Invoked each time a request fails.
+   * Invoked each time a session request fails. A session request is a `session.execute()` call
    *
    * @param latencyNanos the overall execution time (from the {@link Session#execute(Request,
    *     GenericType) session.execute} call until the error is propagated to the client).
    * @param executionProfile the execution profile of this request.
    * @param node the node that returned the error response, or {@code null} if the error occurred
-   * @param requestLogPrefix the dedicated log prefix for this request
+   * @param sessionRequestLogPrefix the dedicated log prefix for this request
    */
   default void onError(
       @NonNull Request request,
@@ -92,8 +93,9 @@ default void onError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @Nullable Node node,
-      @NonNull String requestLogPrefix) {
-    // If client doesn't override onError with requestLogPrefix delegate call to the old method
+      @NonNull String sessionRequestLogPrefix) {
+    // If client doesn't override onError with sessionRequestLogPrefix delegate call to the old
+    // method
     onError(request, error, latencyNanos, executionProfile, node);
   }
 
@@ -110,14 +112,15 @@ default void onNodeError(
       @NonNull Node node) {}
 
   /**
-   * Invoked each time a request fails at the node level. Similar to {@link #onError(Request,
-   * Throwable, long, DriverExecutionProfile, Node, String)} but at a per node level.
+   * Invoked each time a node request fails. A node request is a CQL request sent to a particular
+   * node. There can be one or more node requests for a single session request, due to retries or
+   * speculative executions.
    *
    * @param latencyNanos the overall execution time (from the {@link Session#execute(Request,
    *     GenericType) session.execute} call until the error is propagated to the client).
    * @param executionProfile the execution profile of this request.
    * @param node the node that returned the error response.
-   * @param requestLogPrefix the dedicated log prefix for this request
+   * @param nodeRequestLogPrefix the dedicated log prefix for this request
    */
   default void onNodeError(
       @NonNull Request request,
@@ -125,8 +128,9 @@ default void onNodeError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String requestLogPrefix) {
-    // If client doesn't override onNodeError with requestLogPrefix delegate call to the old method
+      @NonNull String nodeRequestLogPrefix) {
+    // If client doesn't override onNodeError with nodeRequestLogPrefix delegate call to the old
+    // method
     onNodeError(request, error, latencyNanos, executionProfile, node);
   }
 
@@ -142,22 +146,23 @@ default void onNodeSuccess(
       @NonNull Node node) {}
 
   /**
-   * Invoked each time a request succeeds at the node level. Similar to {@link #onSuccess(Request,
-   * long, DriverExecutionProfile, Node, String)} but at per node level.
+   * Invoked each time a node request succeeds. A node request is a CQL request sent to a particular
+   * node. There can be one or more node requests for a single session request, due to retries or
+   * speculative executions.
    *
    * @param latencyNanos the overall execution time (from the {@link Session#execute(Request,
    *     GenericType) session.execute} call until the result is made available to the client).
    * @param executionProfile the execution profile of this request.
    * @param node the node that returned the successful response.
-   * @param requestLogPrefix the dedicated log prefix for this request
+   * @param nodeRequestLogPrefix the dedicated log prefix for this request
    */
   default void onNodeSuccess(
       @NonNull Request request,
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String requestLogPrefix) {
-    // If client doesn't override onNodeSuccess with requestLogPrefix delegate call to the old
+      @NonNull String nodeRequestLogPrefix) {
+    // If client doesn't override onNodeSuccess with nodeRequestLogPrefix delegate call to the old
     // method
     onNodeSuccess(request, latencyNanos, executionProfile, node);
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java b/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
index 0d7db27dfbe..3074bda2398 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
@@ -44,6 +44,7 @@
 import com.datastax.oss.driver.api.core.specex.SpeculativeExecutionPolicy;
 import com.datastax.oss.driver.api.core.ssl.SslEngineFactory;
 import com.datastax.oss.driver.api.core.time.TimestampGenerator;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
 import com.datastax.oss.driver.api.core.tracker.RequestTracker;
 import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
 import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
@@ -221,6 +222,7 @@ public class DefaultDriverContext implements InternalDriverContext {
   private final LazyReference<NodeStateListener> nodeStateListenerRef;
   private final LazyReference<SchemaChangeListener> schemaChangeListenerRef;
   private final LazyReference<RequestTracker> requestTrackerRef;
+  private final LazyReference<Optional<RequestIdGenerator>> requestIdGeneratorRef;
   private final LazyReference<Optional<AuthProvider>> authProviderRef;
   private final LazyReference<List<LifecycleListener>> lifecycleListenersRef =
       new LazyReference<>("lifecycleListeners", this::buildLifecycleListeners, cycleDetector);
@@ -282,6 +284,11 @@ public DefaultDriverContext(
     this.requestTrackerRef =
         new LazyReference<>(
             "requestTracker", () -> buildRequestTracker(requestTrackerFromBuilder), cycleDetector);
+    this.requestIdGeneratorRef =
+        new LazyReference<>(
+            "requestIdGenerator",
+            () -> buildRequestIdGenerator(programmaticArguments.getRequestIdGenerator()),
+            cycleDetector);
     this.sslEngineFactoryRef =
         new LazyReference<>(
             "sslEngineFactory",
@@ -708,6 +715,17 @@ protected RequestTracker buildRequestTracker(RequestTracker requestTrackerFromBu
     }
   }
 
+  protected Optional<RequestIdGenerator> buildRequestIdGenerator(
+      RequestIdGenerator requestIdGenerator) {
+    return (requestIdGenerator != null)
+        ? Optional.of(requestIdGenerator)
+        : Reflection.buildFromConfig(
+            this,
+            DefaultDriverOption.REQUEST_ID_GENERATOR_CLASS,
+            RequestIdGenerator.class,
+            "com.datastax.oss.driver.internal.core.tracker");
+  }
+
   protected Optional<AuthProvider> buildAuthProvider(AuthProvider authProviderFromBuilder) {
     return (authProviderFromBuilder != null)
         ? Optional.of(authProviderFromBuilder)
@@ -972,6 +990,12 @@ public RequestTracker getRequestTracker() {
     return requestTrackerRef.get();
   }
 
+  @NonNull
+  @Override
+  public Optional<RequestIdGenerator> getRequestIdGenerator() {
+    return requestIdGeneratorRef.get();
+  }
+
   @Nullable
   @Override
   public String getLocalDatacenter(@NonNull String profileName) {
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
index 0808bdce63f..6842547b11a 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandler.java
@@ -44,6 +44,7 @@
 import com.datastax.oss.driver.api.core.servererrors.WriteTimeoutException;
 import com.datastax.oss.driver.api.core.session.throttling.RequestThrottler;
 import com.datastax.oss.driver.api.core.session.throttling.Throttled;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
 import com.datastax.oss.driver.api.core.tracker.RequestTracker;
 import com.datastax.oss.driver.internal.core.adminrequest.ThrottledAdminRequestHandler;
 import com.datastax.oss.driver.internal.core.adminrequest.UnexpectedResponseException;
@@ -59,6 +60,7 @@
 import com.datastax.oss.driver.internal.core.tracker.RequestLogger;
 import com.datastax.oss.driver.internal.core.util.Loggers;
 import com.datastax.oss.driver.internal.core.util.collection.SimpleQueryPlan;
+import com.datastax.oss.driver.shaded.guava.common.base.Joiner;
 import com.datastax.oss.protocol.internal.Frame;
 import com.datastax.oss.protocol.internal.Message;
 import com.datastax.oss.protocol.internal.ProtocolConstants;
@@ -82,6 +84,7 @@
 import java.util.AbstractMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Queue;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletableFuture;
@@ -100,7 +103,7 @@ public class CqlRequestHandler implements Throttled {
   private static final long NANOTIME_NOT_MEASURED_YET = -1;
 
   private final long startTimeNanos;
-  private final String logPrefix;
+  private final String handlerLogPrefix;
   private final Statement<?> initialStatement;
   private final DefaultSession session;
   private final CqlIdentifier keyspace;
@@ -125,6 +128,7 @@ public class CqlRequestHandler implements Throttled {
   private final List<NodeResponseCallback> inFlightCallbacks;
   private final RequestThrottler throttler;
   private final RequestTracker requestTracker;
+  private final Optional<RequestIdGenerator> requestIdGenerator;
   private final SessionMetricUpdater sessionMetricUpdater;
   private final DriverExecutionProfile executionProfile;
 
@@ -132,15 +136,25 @@ public class CqlRequestHandler implements Throttled {
   // We don't use a map because nodes can appear multiple times.
   private volatile List<Map.Entry<Node, Throwable>> errors;
 
+  private final Joiner logPrefixJoiner = Joiner.on('|');
+  private final String sessionName;
+  private final String sessionRequestId;
+
   protected CqlRequestHandler(
       Statement<?> statement,
       DefaultSession session,
       InternalDriverContext context,
-      String sessionLogPrefix) {
+      String sessionName) {
 
     this.startTimeNanos = System.nanoTime();
-    this.logPrefix = sessionLogPrefix + "|" + this.hashCode();
-    LOG.trace("[{}] Creating new handler for request {}", logPrefix, statement);
+    this.requestIdGenerator = context.getRequestIdGenerator();
+    this.sessionName = sessionName;
+    this.sessionRequestId =
+        this.requestIdGenerator
+            .map(RequestIdGenerator::getSessionRequestId)
+            .orElse(Integer.toString(this.hashCode()));
+    this.handlerLogPrefix = logPrefixJoiner.join(sessionName, sessionRequestId);
+    LOG.trace("[{}] Creating new handler for request {}", handlerLogPrefix, statement);
 
     this.initialStatement = statement;
     this.session = session;
@@ -155,7 +169,7 @@ protected CqlRequestHandler(
               context.getRequestThrottler().signalCancel(this);
             }
           } catch (Throwable t2) {
-            Loggers.warnWithException(LOG, "[{}] Uncaught exception", logPrefix, t2);
+            Loggers.warnWithException(LOG, "[{}] Uncaught exception", handlerLogPrefix, t2);
           }
           return null;
         });
@@ -250,9 +264,9 @@ private void sendRequest(
     }
     Node node = retriedNode;
     DriverChannel channel = null;
-    if (node == null || (channel = session.getChannel(node, logPrefix)) == null) {
+    if (node == null || (channel = session.getChannel(node, handlerLogPrefix)) == null) {
       while (!result.isDone() && (node = queryPlan.poll()) != null) {
-        channel = session.getChannel(node, logPrefix);
+        channel = session.getChannel(node, handlerLogPrefix);
         if (channel != null) {
           break;
         } else {
@@ -267,6 +281,16 @@ private void sendRequest(
         setFinalError(statement, AllNodesFailedException.fromErrors(this.errors), null, -1);
       }
     } else {
+      Statement finalStatement = statement;
+      String nodeRequestId =
+          this.requestIdGenerator
+              .map((g) -> g.getNodeRequestId(finalStatement, sessionRequestId))
+              .orElse(Integer.toString(this.hashCode()));
+      statement =
+          this.requestIdGenerator
+              .map((g) -> g.getDecoratedStatement(finalStatement, nodeRequestId))
+              .orElse(finalStatement);
+
       NodeResponseCallback nodeResponseCallback =
           new NodeResponseCallback(
               statement,
@@ -276,7 +300,7 @@ private void sendRequest(
               currentExecutionIndex,
               retryCount,
               scheduleNextExecution,
-              logPrefix);
+              logPrefixJoiner.join(this.sessionName, nodeRequestId, currentExecutionIndex));
       Message message = Conversions.toMessage(statement, executionProfile, context);
       channel
           .write(message, statement.isTracing(), statement.getCustomPayload(), nodeResponseCallback)
@@ -335,9 +359,17 @@ private void setFinalResult(
           totalLatencyNanos = completionTimeNanos - startTimeNanos;
           long nodeLatencyNanos = completionTimeNanos - callback.nodeStartTimeNanos;
           requestTracker.onNodeSuccess(
-              callback.statement, nodeLatencyNanos, executionProfile, callback.node, logPrefix);
+              callback.statement,
+              nodeLatencyNanos,
+              executionProfile,
+              callback.node,
+              handlerLogPrefix);
           requestTracker.onSuccess(
-              callback.statement, totalLatencyNanos, executionProfile, callback.node, logPrefix);
+              callback.statement,
+              totalLatencyNanos,
+              executionProfile,
+              callback.node,
+              handlerLogPrefix);
         }
         if (sessionMetricUpdater.isEnabled(
             DefaultSessionMetric.CQL_REQUESTS, executionProfile.getName())) {
@@ -439,7 +471,8 @@ private void setFinalError(Statement<?> statement, Throwable error, Node node, i
       cancelScheduledTasks();
       if (!(requestTracker instanceof NoopRequestTracker)) {
         long latencyNanos = System.nanoTime() - startTimeNanos;
-        requestTracker.onError(statement, error, latencyNanos, executionProfile, node, logPrefix);
+        requestTracker.onError(
+            statement, error, latencyNanos, executionProfile, node, handlerLogPrefix);
       }
       if (error instanceof DriverTimeoutException) {
         throttler.signalTimeout(this);
@@ -489,7 +522,7 @@ private NodeResponseCallback(
       this.execution = execution;
       this.retryCount = retryCount;
       this.scheduleNextExecution = scheduleNextExecution;
-      this.logPrefix = logPrefix + "|" + execution;
+      this.logPrefix = logPrefix;
     }
 
     // this gets invoked once the write completes.
@@ -567,7 +600,7 @@ private void scheduleSpeculativeExecution(int index, long delay) {
                   if (!result.isDone()) {
                     LOG.trace(
                         "[{}] Starting speculative execution {}",
-                        CqlRequestHandler.this.logPrefix,
+                        CqlRequestHandler.this.handlerLogPrefix,
                         index);
                     activeExecutionsCount.incrementAndGet();
                     startedSpeculativeExecutionsCount.incrementAndGet();
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
index 9c31b606f18..8e1c1fe5039 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/DefaultLoadBalancingPolicy.java
@@ -246,7 +246,7 @@ public void onNodeSuccess(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     updateResponseTimes(node);
   }
 
@@ -257,7 +257,7 @@ public void onNodeError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     updateResponseTimes(node);
   }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/MultiplexingRequestTracker.java b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/MultiplexingRequestTracker.java
index d4d20f3eb78..6fe2ba059bd 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/MultiplexingRequestTracker.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/MultiplexingRequestTracker.java
@@ -82,10 +82,12 @@ public void onSuccess(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String sessionRequestLogPrefix) {
     invokeTrackers(
-        tracker -> tracker.onSuccess(request, latencyNanos, executionProfile, node, logPrefix),
-        logPrefix,
+        tracker ->
+            tracker.onSuccess(
+                request, latencyNanos, executionProfile, node, sessionRequestLogPrefix),
+        sessionRequestLogPrefix,
         "onSuccess");
   }
 
@@ -96,10 +98,12 @@ public void onError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @Nullable Node node,
-      @NonNull String logPrefix) {
+      @NonNull String sessionRequestLogPrefix) {
     invokeTrackers(
-        tracker -> tracker.onError(request, error, latencyNanos, executionProfile, node, logPrefix),
-        logPrefix,
+        tracker ->
+            tracker.onError(
+                request, error, latencyNanos, executionProfile, node, sessionRequestLogPrefix),
+        sessionRequestLogPrefix,
         "onError");
   }
 
@@ -109,10 +113,12 @@ public void onNodeSuccess(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     invokeTrackers(
-        tracker -> tracker.onNodeSuccess(request, latencyNanos, executionProfile, node, logPrefix),
-        logPrefix,
+        tracker ->
+            tracker.onNodeSuccess(
+                request, latencyNanos, executionProfile, node, nodeRequestLogPrefix),
+        nodeRequestLogPrefix,
         "onNodeSuccess");
   }
 
@@ -123,11 +129,12 @@ public void onNodeError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     invokeTrackers(
         tracker ->
-            tracker.onNodeError(request, error, latencyNanos, executionProfile, node, logPrefix),
-        logPrefix,
+            tracker.onNodeError(
+                request, error, latencyNanos, executionProfile, node, nodeRequestLogPrefix),
+        nodeRequestLogPrefix,
         "onNodeError");
   }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/NoopRequestTracker.java b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/NoopRequestTracker.java
index 09ac27e5e75..3821c6ace2d 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/NoopRequestTracker.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/NoopRequestTracker.java
@@ -42,7 +42,7 @@ public void onSuccess(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String requestPrefix) {
+      @NonNull String sessionRequestLogPrefix) {
     // nothing to do
   }
 
@@ -53,7 +53,7 @@ public void onError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       Node node,
-      @NonNull String requestPrefix) {
+      @NonNull String sessionRequestLogPrefix) {
     // nothing to do
   }
 
@@ -64,7 +64,7 @@ public void onNodeError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String requestPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     // nothing to do
   }
 
@@ -74,7 +74,7 @@ public void onNodeSuccess(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String requestPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     // nothing to do
   }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/RequestLogger.java b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/RequestLogger.java
index 235ef051b40..f242ff89c54 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/RequestLogger.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/RequestLogger.java
@@ -86,7 +86,7 @@ public void onSuccess(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String sessionRequestLogPrefix) {
 
     boolean successEnabled =
         executionProfile.getBoolean(DefaultDriverOption.REQUEST_LOGGER_SUCCESS_ENABLED, false);
@@ -129,7 +129,7 @@ public void onSuccess(
         showValues,
         maxValues,
         maxValueLength,
-        logPrefix);
+        sessionRequestLogPrefix);
   }
 
   @Override
@@ -139,7 +139,7 @@ public void onError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       Node node,
-      @NonNull String logPrefix) {
+      @NonNull String sessionRequestLogPrefix) {
 
     if (!executionProfile.getBoolean(DefaultDriverOption.REQUEST_LOGGER_ERROR_ENABLED, false)) {
       return;
@@ -173,7 +173,7 @@ public void onError(
         maxValues,
         maxValueLength,
         showStackTraces,
-        logPrefix);
+        sessionRequestLogPrefix);
   }
 
   @Override
@@ -183,7 +183,7 @@ public void onNodeError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     // Nothing to do
   }
 
@@ -193,7 +193,7 @@ public void onNodeSuccess(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     // Nothing to do
   }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/UuidRequestIdGenerator.java b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/UuidRequestIdGenerator.java
new file mode 100644
index 00000000000..cc07d6717f4
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/UuidRequestIdGenerator.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.tracker;
+
+import com.datastax.oss.driver.api.core.context.DriverContext;
+import com.datastax.oss.driver.api.core.session.Request;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public class UuidRequestIdGenerator implements RequestIdGenerator {
+  public UuidRequestIdGenerator(DriverContext context) {}
+
+  /** Generates a random v4 UUID. */
+  @Override
+  public String getSessionRequestId() {
+    return Uuids.random().toString();
+  }
+
+  /**
+   * {session-request-id}-{random-uuid} All node requests for a session request will have the same
+   * session request id
+   */
+  @Override
+  public String getNodeRequestId(@NonNull Request statement, @NonNull String parentId) {
+    return parentId + "-" + Uuids.random();
+  }
+}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/W3CContextRequestIdGenerator.java b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/W3CContextRequestIdGenerator.java
new file mode 100644
index 00000000000..fe15b93bc8e
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/tracker/W3CContextRequestIdGenerator.java
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.tracker;
+
+import com.datastax.oss.driver.api.core.context.DriverContext;
+import com.datastax.oss.driver.api.core.session.Request;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
+import com.datastax.oss.driver.shaded.guava.common.io.BaseEncoding;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.security.SecureRandom;
+import java.util.Random;
+
+public class W3CContextRequestIdGenerator implements RequestIdGenerator {
+
+  private final Random random = new SecureRandom();
+  private final BaseEncoding baseEncoding = BaseEncoding.base16().lowerCase();
+  private final String payloadKey;
+
+  public W3CContextRequestIdGenerator(DriverContext context) {
+    payloadKey = RequestIdGenerator.super.getCustomPayloadKey();
+  }
+
+  public W3CContextRequestIdGenerator(String payloadKey) {
+    this.payloadKey = payloadKey;
+  }
+
+  /** Random 16 bytes, e.g. "4bf92f3577b34da6a3ce929d0e0e4736" */
+  @Override
+  public String getSessionRequestId() {
+    byte[] bytes = new byte[16];
+    random.nextBytes(bytes);
+    return baseEncoding.encode(bytes);
+  }
+
+  /**
+   * Following the format of W3C "traceparent" spec,
+   * https://www.w3.org/TR/trace-context/#traceparent-header-field-values e.g.
+   * "00-4bf92f3577b34da6a3ce929d0e0e4736-a3ce929d0e0e4736-01" All node requests in the same session
+   * request share the same "trace-id" field value
+   */
+  @Override
+  public String getNodeRequestId(@NonNull Request statement, @NonNull String parentId) {
+    byte[] bytes = new byte[8];
+    random.nextBytes(bytes);
+    return String.format("00-%s-%s-00", parentId, baseEncoding.encode(bytes));
+  }
+
+  @Override
+  public String getCustomPayloadKey() {
+    return this.payloadKey;
+  }
+}
diff --git a/core/src/main/resources/reference.conf b/core/src/main/resources/reference.conf
index 3c6851a48ee..741b1d97654 100644
--- a/core/src/main/resources/reference.conf
+++ b/core/src/main/resources/reference.conf
@@ -918,6 +918,13 @@ datastax-java-driver {
     }
   }
 
+  advanced.request-id {
+    generator {
+      # The component that generates a unique identifier for each CQL request, and possibly write the id to the custom payload  .
+      // class = W3CContextRequestIdGenerator
+    }
+  }
+
   # A session-wide component that controls the rate at which requests are executed.
   #
   # Implementations vary, but throttlers generally track a metric that represents the level of
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/cql/RequestHandlerTestHarness.java b/core/src/test/java/com/datastax/oss/driver/internal/core/cql/RequestHandlerTestHarness.java
index 9d86302aabf..6ecd6111992 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/cql/RequestHandlerTestHarness.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/cql/RequestHandlerTestHarness.java
@@ -61,6 +61,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Queue;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
@@ -168,6 +169,8 @@ protected RequestHandlerTestHarness(Builder builder) {
     when(context.getRequestThrottler()).thenReturn(new PassThroughRequestThrottler(context));
 
     when(context.getRequestTracker()).thenReturn(new NoopRequestTracker(context));
+
+    when(context.getRequestIdGenerator()).thenReturn(Optional.empty());
   }
 
   public DefaultSession getSession() {
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/tracker/RequestIdGeneratorTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/tracker/RequestIdGeneratorTest.java
new file mode 100644
index 00000000000..fb1883e125f
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/tracker/RequestIdGeneratorTest.java
@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.internal.core.tracker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.datastax.oss.driver.api.core.cql.Statement;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
+import com.datastax.oss.driver.internal.core.context.InternalDriverContext;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.Strict.class)
+public class RequestIdGeneratorTest {
+  @Mock private InternalDriverContext context;
+  @Mock private Statement<?> statement;
+
+  @Test
+  public void uuid_generator_should_generate() {
+    // given
+    UuidRequestIdGenerator generator = new UuidRequestIdGenerator(context);
+    // when
+    String parentId = generator.getSessionRequestId();
+    String requestId = generator.getNodeRequestId(statement, parentId);
+    // then
+    // e.g. "550e8400-e29b-41d4-a716-446655440000", which is 36 characters long
+    assertThat(parentId.length()).isEqualTo(36);
+    // e.g. "550e8400-e29b-41d4-a716-446655440000-550e8400-e29b-41d4-a716-446655440000", which is 73
+    // characters long
+    assertThat(requestId.length()).isEqualTo(73);
+  }
+
+  @Test
+  public void w3c_generator_should_generate() {
+    // given
+    W3CContextRequestIdGenerator generator = new W3CContextRequestIdGenerator(context);
+    // when
+    String parentId = generator.getSessionRequestId();
+    String requestId = generator.getNodeRequestId(statement, parentId);
+    // then
+    // e.g. "4bf92f3577b34da6a3ce929d0e0e4736", which is 32 characters long
+    assertThat(parentId.length()).isEqualTo(32);
+    // According to W3C "traceparent" spec,
+    // https://www.w3.org/TR/trace-context/#traceparent-header-field-values
+    // e.g. "00-4bf92f3577b34da6a3ce929d0e0e4736-a3ce929d0e0e4736-01", which 55 characters long
+    assertThat(requestId.length()).isEqualTo(55);
+  }
+
+  @Test
+  public void w3c_generator_default_payloadkey() {
+    W3CContextRequestIdGenerator w3cGenerator = new W3CContextRequestIdGenerator(context);
+    assertThat(w3cGenerator.getCustomPayloadKey())
+        .isEqualTo(RequestIdGenerator.DEFAULT_PAYLOAD_KEY);
+  }
+
+  @Test
+  public void w3c_generator_provided_payloadkey() {
+    String someString = RandomStringUtils.random(12);
+    W3CContextRequestIdGenerator w3cGenerator = new W3CContextRequestIdGenerator(someString);
+    assertThat(w3cGenerator.getCustomPayloadKey()).isEqualTo(someString);
+  }
+}
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestIdGeneratorIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestIdGeneratorIT.java
new file mode 100644
index 00000000000..2848a8fb629
--- /dev/null
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestIdGeneratorIT.java
@@ -0,0 +1,125 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.core.tracker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
+import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.api.core.cql.ResultSet;
+import com.datastax.oss.driver.api.core.cql.Statement;
+import com.datastax.oss.driver.api.core.session.Request;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
+import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
+import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
+import com.datastax.oss.driver.categories.ParallelizableTests;
+import com.datastax.oss.protocol.internal.util.collection.NullAllowingImmutableMap;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.RuleChain;
+import org.junit.rules.TestRule;
+
+@Category(ParallelizableTests.class)
+public class RequestIdGeneratorIT {
+  private CcmRule ccmRule = CcmRule.getInstance();
+
+  @Rule public TestRule chain = RuleChain.outerRule(ccmRule);
+
+  @Test
+  public void should_write_uuid_to_custom_payload_with_key() {
+    DriverConfigLoader loader =
+        SessionUtils.configLoaderBuilder()
+            .withString(DefaultDriverOption.REQUEST_ID_GENERATOR_CLASS, "UuidRequestIdGenerator")
+            .build();
+    try (CqlSession session = SessionUtils.newSession(ccmRule, loader)) {
+      String query = "SELECT * FROM system.local";
+      ResultSet rs = session.execute(query);
+      ByteBuffer id = rs.getExecutionInfo().getRequest().getCustomPayload().get("request-id");
+      assertThat(id.remaining()).isEqualTo(73);
+    }
+  }
+
+  @Test
+  public void should_write_default_request_id_to_custom_payload_with_key() {
+    DriverConfigLoader loader =
+        SessionUtils.configLoaderBuilder()
+            .withString(
+                DefaultDriverOption.REQUEST_ID_GENERATOR_CLASS, "W3CContextRequestIdGenerator")
+            .build();
+    try (CqlSession session = SessionUtils.newSession(ccmRule, loader)) {
+      String query = "SELECT * FROM system.local";
+      ResultSet rs = session.execute(query);
+      ByteBuffer id = rs.getExecutionInfo().getRequest().getCustomPayload().get("request-id");
+      assertThat(id.remaining()).isEqualTo(55);
+    }
+  }
+
+  @Test
+  public void should_use_customized_request_id_generator() {
+    RequestIdGenerator myRequestIdGenerator =
+        new RequestIdGenerator() {
+          @Override
+          public String getSessionRequestId() {
+            return "123";
+          }
+
+          @Override
+          public String getNodeRequestId(@NonNull Request statement, @NonNull String parentId) {
+            return "456";
+          }
+
+          @Override
+          public Statement<?> getDecoratedStatement(
+              @NonNull Statement<?> statement, @NonNull String requestId) {
+            Map<String, ByteBuffer> customPayload =
+                NullAllowingImmutableMap.<String, ByteBuffer>builder()
+                    .putAll(statement.getCustomPayload())
+                    .put("trace_key", ByteBuffer.wrap(requestId.getBytes(StandardCharsets.UTF_8)))
+                    .build();
+            return statement.setCustomPayload(customPayload);
+          }
+        };
+    try (CqlSession session =
+        (CqlSession)
+            SessionUtils.baseBuilder()
+                .addContactEndPoints(ccmRule.getContactPoints())
+                .withRequestIdGenerator(myRequestIdGenerator)
+                .build()) {
+      String query = "SELECT * FROM system.local";
+      ResultSet rs = session.execute(query);
+      ByteBuffer id = rs.getExecutionInfo().getRequest().getCustomPayload().get("trace_key");
+      assertThat(id).isEqualTo(ByteBuffer.wrap("456".getBytes(StandardCharsets.UTF_8)));
+    }
+  }
+
+  @Test
+  public void should_not_write_id_to_custom_payload_when_key_is_not_set() {
+    DriverConfigLoader loader = SessionUtils.configLoaderBuilder().build();
+    try (CqlSession session = SessionUtils.newSession(ccmRule, loader)) {
+      String query = "SELECT * FROM system.local";
+      ResultSet rs = session.execute(query);
+      assertThat(rs.getExecutionInfo().getRequest().getCustomPayload().get("trace_key")).isNull();
+    }
+  }
+}
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestNodeLoggerExample.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestNodeLoggerExample.java
index eae98339637..8eb2fb80a73 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestNodeLoggerExample.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestNodeLoggerExample.java
@@ -39,7 +39,7 @@ public void onNodeError(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     if (!executionProfile.getBoolean(DefaultDriverOption.REQUEST_LOGGER_ERROR_ENABLED)) {
       return;
     }
@@ -66,7 +66,7 @@ public void onNodeError(
         maxValues,
         maxValueLength,
         showStackTraces,
-        logPrefix);
+        nodeRequestLogPrefix);
   }
 
   @Override
@@ -75,7 +75,7 @@ public void onNodeSuccess(
       long latencyNanos,
       @NonNull DriverExecutionProfile executionProfile,
       @NonNull Node node,
-      @NonNull String logPrefix) {
+      @NonNull String nodeRequestLogPrefix) {
     boolean successEnabled =
         executionProfile.getBoolean(DefaultDriverOption.REQUEST_LOGGER_SUCCESS_ENABLED);
     boolean slowEnabled =
@@ -114,6 +114,6 @@ public void onNodeSuccess(
         showValues,
         maxValues,
         maxValueLength,
-        logPrefix);
+        nodeRequestLogPrefix);
   }
 }
diff --git a/manual/core/request_id/README.md b/manual/core/request_id/README.md
new file mode 100644
index 00000000000..a766a4419af
--- /dev/null
+++ b/manual/core/request_id/README.md
@@ -0,0 +1,48 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you 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.
+-->
+
+## Request Id
+
+### Quick overview
+
+Users can inject an identifier for each individual CQL request, and such ID can be written in to the [custom payload](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v5.spec) to 
+correlate a request across the driver and the Apache Cassandra server.
+
+A request ID generator needs to generate both:
+- Session request ID: an identifier for an entire session.execute() call
+- Node request ID: an identifier for the execution of a CQL statement against a particular node. There can be one or more node requests for a single session request, due to retries or speculative executions.
+
+Usage:
+* Inject ID generator: set the desired `RequestIdGenerator` in `advanced.request-id.generator.class`.
+* Add ID to custom payload: the default behavior of a `RequestIdGenerator` is to add the request ID into the custom payload with the key `request-id`. Override `RequestIdGenerator.getDecoratedStatement` to customize the behavior.
+
+### Request Id Generator Configuration
+
+Request ID generator can be declared in the [configuration](../configuration/) as follows:
+
+```
+datastax-java-driver.advanced.request-id.generator {
+  class = com.example.app.MyGenerator
+}
+```
+
+To register your own request ID generator, specify the name of the class
+that implements `RequestIdGenerator`.
+
+The generated ID will be added to the log message of `CqlRequestHandler`, and propagated to other classes, e.g. the request trackers.
\ No newline at end of file

From 104751c166402274f46135b9d367bee1cfdd124d Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Tue, 14 Oct 2025 15:08:52 -0500
Subject: [PATCH 091/126] Changelog entries for 4.19.1

patch by Bret McGuire; reviewed by Andy Tolbert
---
 changelog/README.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/changelog/README.md b/changelog/README.md
index 08634bcb834..9e223318e65 100644
--- a/changelog/README.md
+++ b/changelog/README.md
@@ -21,6 +21,24 @@ under the License.
 
 <!-- Note: contrary to 3.x, insert new entries *first* in their section -->
 
+### 4.19.1
+
+- [improvement] CASSJAVA-97: Let users inject an ID for each request and write to the custom payload
+- [improvement] CASSJAVA-92: Add Local DC to driver connection info and provide visibility with nodetool clientstats
+- [bug] PR 2025: Eliminate lock in ConcurrencyLimitingRequestThrottler
+- [improvement] CASSJAVA-89: Fix deprecated table configs in Cassandra 5
+- [improvement] PR 2028: Remove unnecessary locking in DefaultNettyOptions
+- [improvement] CASSJAVA-102: Fix revapi spurious complaints about optional dependencies
+- [improvement] PR 2013: Add SubnetAddressTranslator
+- [improvement] CASSJAVA-68: Improve DefaultCodecRegistry.CacheKey#hashCode() to eliminate Object[] allocation
+- [improvement] PR 1989: Bump Jackson version to la(te)st 2.13.x, 2.13.5
+- [improvement] CASSJAVA-76: Make guava an optional dependency of java-driver-guava-shaded
+- [bug] PR 2035: Prevent long overflow in SNI address resolution
+- [improvement] CASSJAVA-77: 4.x: Upgrade Netty to 4.1.119
+- [improvement] CASSJAVA-40: Driver testing against Java 21
+- [improvement] CASSJAVA-90: Update native-protocol
+- [improvement] CASSJAVA-80: Support configuration to disable DNS reverse-lookups for SAN validation
+
 ### 4.19.0
 
 - [bug] JAVA-3055: Prevent PreparedStatement cache to be polluted if a request is cancelled.

From 77b2baebebfa208e2a7a29f6b09b6cb86e3a4b61 Mon Sep 17 00:00:00 2001
From: Andy Tolbert <6889771+tolbertam@users.noreply.github.com>
Date: Tue, 14 Oct 2025 15:32:38 -0500
Subject: [PATCH 092/126] [maven-release-plugin] prepare release 4.19.1

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index f03317edc03..05e9d74dc5c 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.1-SNAPSHOT</version>
+        <version>4.19.1</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 451db1dcd1b..4cc8197b6dd 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index b8d7d5c2d3b..9ed02b81dd7 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index e930f4c0610..5328b4bbd36 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 1c762074673..c4b5eb38026 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 8f7740e148f..4c5f04de515 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 15f082e6864..a473320ea44 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index ed37e861a96..62c1c5fc799 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index b489076c257..16661191427 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 519f1411ce9..d7aaa7f9d67 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 3a767c2a352..af2936a3805 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 091bb5f3e93..3dd89d1737b 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 5163b5366f4..cca6eafc603 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 4b41f790145..e60981f7fc8 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 2cfeb65e757..355449acf0e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.1-SNAPSHOT</version>
+  <version>4.19.1</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1055,7 +1055,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>HEAD</tag>
+    <tag>4.19.1</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 0bc46f9bb91..1860cf65d12 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index b0808757ce4..e61f4f2826b 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1-SNAPSHOT</version>
+    <version>4.19.1</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From f63108175fd22e2db893c57b0975bc518977ab4b Mon Sep 17 00:00:00 2001
From: Andy Tolbert <6889771+tolbertam@users.noreply.github.com>
Date: Tue, 14 Oct 2025 15:32:41 -0500
Subject: [PATCH 093/126] [maven-release-plugin] prepare for next development
 iteration

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 05e9d74dc5c..fab36abad4c 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.1</version>
+        <version>4.19.2-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 4cc8197b6dd..617664eec97 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 9ed02b81dd7..e750b791d3b 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index 5328b4bbd36..27d6d026a4d 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index c4b5eb38026..fbf8cd21076 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 4c5f04de515..498d5dc603a 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index a473320ea44..df1e2b2613b 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 62c1c5fc799..ad581bc0f98 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 16661191427..8360c8a211f 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index d7aaa7f9d67..5368c24c2b6 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index af2936a3805..a21254da908 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 3dd89d1737b..08211d04c2b 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index cca6eafc603..95c1ca9bb42 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index e60981f7fc8..abb54e159f6 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 355449acf0e..4e3d7006169 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.1</version>
+  <version>4.19.2-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1055,7 +1055,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>4.19.1</tag>
+    <tag>HEAD</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 1860cf65d12..e1db8485799 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index e61f4f2826b..1a73cde23cd 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.1</version>
+    <version>4.19.2-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 8f69c24d6cd6db75c6811fc32ee9ab39121ecaa6 Mon Sep 17 00:00:00 2001
From: janehe <jane.he@datastax.com>
Date: Mon, 10 Nov 2025 12:50:59 -0800
Subject: [PATCH 094/126] CASSJAVA-116: Retry or Speculative Execution with
 RequestIdGenerator throws "Duplicate Key" patch by Jane He; reviewed by Andy
 Tolbert and Lukasz Atoniak for CASSJAVA-116

---
 .../api/core/tracker/RequestIdGenerator.java  | 29 +++++----
 .../core/cql/CqlRequestHandlerRetryTest.java  | 63 +++++++++++++++++++
 .../core/cql/RequestHandlerTestHarness.java   | 10 ++-
 .../core/tracker/RequestIdGeneratorIT.java    | 21 ++++++-
 4 files changed, 110 insertions(+), 13 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestIdGenerator.java b/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestIdGenerator.java
index 59ac3fdacf7..21db3793b01 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestIdGenerator.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/tracker/RequestIdGenerator.java
@@ -19,20 +19,21 @@
 
 import com.datastax.oss.driver.api.core.cql.Statement;
 import com.datastax.oss.driver.api.core.session.Request;
-import com.datastax.oss.protocol.internal.util.collection.NullAllowingImmutableMap;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 
 /**
  * Interface responsible for generating request IDs.
  *
- * <p>Note that all request IDs have a parent/child relationship. A "parent ID" can loosely be
- * thought of as encompassing a sequence of a request + any attendant retries, speculative
+ * <p>Note that all request IDs have a parent/child relationship. A "session request ID" can loosely
+ * be thought of as encompassing a sequence of a request + any attendant retries, speculative
  * executions etc. It's scope is identical to that of a {@link
- * com.datastax.oss.driver.internal.core.cql.CqlRequestHandler}. A "request ID" represents a single
- * request within this larger scope. Note that a request corresponding to a request ID may be
+ * com.datastax.oss.driver.internal.core.cql.CqlRequestHandler}. A "node request ID" represents a
+ * single request within this larger scope. Note that a request corresponding to a request ID may be
  * retried; in that case the retry count will be appended to the corresponding identifier in the
  * logs.
  */
@@ -67,11 +68,17 @@ default String getCustomPayloadKey() {
 
   default Statement<?> getDecoratedStatement(
       @NonNull Statement<?> statement, @NonNull String requestId) {
-    Map<String, ByteBuffer> customPayload =
-        NullAllowingImmutableMap.<String, ByteBuffer>builder()
-            .putAll(statement.getCustomPayload())
-            .put(getCustomPayloadKey(), ByteBuffer.wrap(requestId.getBytes(StandardCharsets.UTF_8)))
-            .build();
-    return statement.setCustomPayload(customPayload);
+
+    Map<String, ByteBuffer> existing = new HashMap<>(statement.getCustomPayload());
+    String key = getCustomPayloadKey();
+
+    // Add or overwrite
+    existing.put(key, ByteBuffer.wrap(requestId.getBytes(StandardCharsets.UTF_8)));
+
+    // Allowing null key/values
+    // Wrap a map inside to be immutable without instanciating a new map
+    Map<String, ByteBuffer> unmodifiableMap = Collections.unmodifiableMap(existing);
+
+    return statement.setCustomPayload(unmodifiableMap);
   }
 }
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandlerRetryTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandlerRetryTest.java
index bea52891c18..ccac873c616 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandlerRetryTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/cql/CqlRequestHandlerRetryTest.java
@@ -48,6 +48,8 @@
 import com.datastax.oss.driver.api.core.servererrors.ServerError;
 import com.datastax.oss.driver.api.core.servererrors.UnavailableException;
 import com.datastax.oss.driver.api.core.servererrors.WriteTimeoutException;
+import com.datastax.oss.driver.api.core.session.Request;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
 import com.datastax.oss.protocol.internal.ProtocolConstants;
 import com.datastax.oss.protocol.internal.response.Error;
 import com.datastax.oss.protocol.internal.response.error.ReadTimeout;
@@ -55,9 +57,13 @@
 import com.datastax.oss.protocol.internal.response.error.WriteTimeout;
 import com.tngtech.java.junit.dataprovider.DataProvider;
 import com.tngtech.java.junit.dataprovider.UseDataProvider;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
 import java.util.Iterator;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.junit.Test;
 
 public class CqlRequestHandlerRetryTest extends CqlRequestHandlerTestBase {
@@ -384,6 +390,63 @@ public void should_rethrow_error_if_not_idempotent_and_error_unsafe_or_policy_re
     }
   }
 
+  @Test
+  @UseDataProvider("failureAndIdempotent")
+  public void should_not_fail_with_duplicate_key_when_retrying_with_request_id_generator(
+      FailureScenario failureScenario, boolean defaultIdempotence, Statement<?> statement) {
+
+    // Create a RequestIdGenerator that uses the same key as the statement's custom payload
+    RequestIdGenerator requestIdGenerator =
+        new RequestIdGenerator() {
+          private AtomicInteger counter = new AtomicInteger(0);
+
+          @Override
+          public String getSessionRequestId() {
+            return "session-123";
+          }
+
+          @Override
+          public String getNodeRequestId(@NonNull Request request, @NonNull String parentId) {
+            return parentId + "-" + counter.getAndIncrement();
+          }
+        };
+
+    RequestHandlerTestHarness.Builder harnessBuilder =
+        RequestHandlerTestHarness.builder()
+            .withDefaultIdempotence(defaultIdempotence)
+            .withRequestIdGenerator(requestIdGenerator);
+    failureScenario.mockRequestError(harnessBuilder, node1);
+    harnessBuilder.withResponse(node2, defaultFrameOf(singleRow()));
+
+    try (RequestHandlerTestHarness harness = harnessBuilder.build()) {
+      failureScenario.mockRetryPolicyVerdict(
+          harness.getContext().getRetryPolicy(anyString()), RetryVerdict.RETRY_NEXT);
+
+      CompletionStage<AsyncResultSet> resultSetFuture =
+          new CqlRequestHandler(statement, harness.getSession(), harness.getContext(), "test")
+              .handle();
+
+      // The test should succeed without throwing a duplicate key exception
+      assertThatStage(resultSetFuture)
+          .isSuccess(
+              resultSet -> {
+                Iterator<Row> rows = resultSet.currentPage().iterator();
+                assertThat(rows.hasNext()).isTrue();
+                assertThat(rows.next().getString("message")).isEqualTo("hello, world");
+
+                ExecutionInfo executionInfo = resultSet.getExecutionInfo();
+                assertThat(executionInfo.getCoordinator()).isEqualTo(node2);
+                assertThat(executionInfo.getErrors()).hasSize(1);
+                assertThat(executionInfo.getErrors().get(0).getKey()).isEqualTo(node1);
+
+                // Verify that the custom payload still contains the request ID key
+                // (either the original value or the generated one, depending on implementation)
+                assertThat(executionInfo.getRequest().getCustomPayload().get("request-id"))
+                    .isEqualTo(ByteBuffer.wrap("session-123-1".getBytes(StandardCharsets.UTF_8)));
+              });
+    }
+  }
+
   /**
    * Sets up the mocks to simulate an error from a node, and make the retry policy return a given
    * decision for that error.
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/cql/RequestHandlerTestHarness.java b/core/src/test/java/com/datastax/oss/driver/internal/core/cql/RequestHandlerTestHarness.java
index 6ecd6111992..6a7657d5809 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/cql/RequestHandlerTestHarness.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/cql/RequestHandlerTestHarness.java
@@ -37,6 +37,7 @@
 import com.datastax.oss.driver.api.core.session.Session;
 import com.datastax.oss.driver.api.core.specex.SpeculativeExecutionPolicy;
 import com.datastax.oss.driver.api.core.time.TimestampGenerator;
+import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
 import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
 import com.datastax.oss.driver.internal.core.DefaultConsistencyLevelRegistry;
 import com.datastax.oss.driver.internal.core.ProtocolFeature;
@@ -170,7 +171,8 @@ protected RequestHandlerTestHarness(Builder builder) {
 
     when(context.getRequestTracker()).thenReturn(new NoopRequestTracker(context));
 
-    when(context.getRequestIdGenerator()).thenReturn(Optional.empty());
+    when(context.getRequestIdGenerator())
+        .thenReturn(Optional.ofNullable(builder.requestIdGenerator));
   }
 
   public DefaultSession getSession() {
@@ -203,6 +205,7 @@ public static class Builder {
     private final List<PoolBehavior> poolBehaviors = new ArrayList<>();
     private boolean defaultIdempotence;
     private ProtocolVersion protocolVersion;
+    private RequestIdGenerator requestIdGenerator;
 
     /**
      * Sets the given node as the next one in the query plan; an empty pool will be simulated when
@@ -258,6 +261,11 @@ public Builder withProtocolVersion(ProtocolVersion protocolVersion) {
       return this;
     }
 
+    public Builder withRequestIdGenerator(RequestIdGenerator requestIdGenerator) {
+      this.requestIdGenerator = requestIdGenerator;
+      return this;
+    }
+
     /**
      * Sets the given node as the next one in the query plan; the test code is responsible of
      * calling the methods on the returned object to complete the write and the query.
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestIdGeneratorIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestIdGeneratorIT.java
index 2848a8fb629..516a62bb1f7 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestIdGeneratorIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/tracker/RequestIdGeneratorIT.java
@@ -17,12 +17,14 @@
  */
 package com.datastax.oss.driver.core.tracker;
 
+import static com.datastax.oss.driver.Assertions.assertThatStage;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
 import com.datastax.oss.driver.api.core.cql.ResultSet;
+import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.cql.Statement;
 import com.datastax.oss.driver.api.core.session.Request;
 import com.datastax.oss.driver.api.core.tracker.RequestIdGenerator;
@@ -119,7 +121,24 @@ public void should_not_write_id_to_custom_payload_when_key_is_not_set() {
     try (CqlSession session = SessionUtils.newSession(ccmRule, loader)) {
       String query = "SELECT * FROM system.local";
       ResultSet rs = session.execute(query);
-      assertThat(rs.getExecutionInfo().getRequest().getCustomPayload().get("trace_key")).isNull();
+      assertThat(rs.getExecutionInfo().getRequest().getCustomPayload().get("request-id")).isNull();
+    }
+  }
+
+  @Test
+  public void should_succeed_with_null_value_in_custom_payload() {
+    DriverConfigLoader loader =
+        SessionUtils.configLoaderBuilder()
+            .withString(
+                DefaultDriverOption.REQUEST_ID_GENERATOR_CLASS, "W3CContextRequestIdGenerator")
+            .build();
+    try (CqlSession session = SessionUtils.newSession(ccmRule, loader)) {
+      String query = "SELECT * FROM system.local";
+      Map<String, ByteBuffer> customPayload =
+          new NullAllowingImmutableMap.Builder<String, ByteBuffer>(1).put("my_key", null).build();
+      SimpleStatement statement =
+          SimpleStatement.newInstance(query).setCustomPayload(customPayload);
+      assertThatStage(session.executeAsync(statement)).isSuccess();
     }
   }
 }

From 19c60c08b9eecbcfba3c61564bbe15bf3115089a Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Wed, 12 Nov 2025 18:31:56 -0600
Subject: [PATCH 095/126] Changelog updates for 4.19.2

patch by Bret McGuire; reviewed by Lukasz Antoniak and Andy Tolbert
reference: https://github.com/apache/cassandra-java-driver/pull/2062
---
 changelog/README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/changelog/README.md b/changelog/README.md
index 9e223318e65..b01c3db3bf9 100644
--- a/changelog/README.md
+++ b/changelog/README.md
@@ -21,6 +21,10 @@ under the License.
 
 <!-- Note: contrary to 3.x, insert new entries *first* in their section -->
 
+### 4.19.2
+
+- [bug] CASSJAVA-116: Retry or Speculative Execution with RequestIdGenerator throws "Duplicate Key"
+
 ### 4.19.1
 
 - [improvement] CASSJAVA-97: Let users inject an ID for each request and write to the custom payload

From 30b05bd7991617b212b8089787fe9ca829d00154 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Thu, 13 Nov 2025 12:02:08 -0600
Subject: [PATCH 096/126] [maven-release-plugin] prepare release 4.19.2

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index fab36abad4c..2e6e476d02a 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.2-SNAPSHOT</version>
+        <version>4.19.2</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 617664eec97..b8e56b89b82 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index e750b791d3b..d8a058537f2 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index 27d6d026a4d..71600fbee2c 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index fbf8cd21076..0c2d802266e 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 498d5dc603a..fc8d3ac0f8e 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index df1e2b2613b..29c1aa42001 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index ad581bc0f98..2da3da4024f 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 8360c8a211f..bf122a19e35 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 5368c24c2b6..baa2e42c539 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index a21254da908..5076a146901 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 08211d04c2b..c5eeee518da 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 95c1ca9bb42..1c6359d2cdd 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index abb54e159f6..2fb5f3cb27f 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 4e3d7006169..c37285e5f7c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.2-SNAPSHOT</version>
+  <version>4.19.2</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1055,7 +1055,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>HEAD</tag>
+    <tag>4.19.2</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index e1db8485799..a62c800cbd3 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 1a73cde23cd..0f24f638047 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2-SNAPSHOT</version>
+    <version>4.19.2</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 62eade21bfeb16a12ce71013fbaebf1c19b5ae96 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Thu, 13 Nov 2025 12:02:11 -0600
Subject: [PATCH 097/126] [maven-release-plugin] prepare for next development
 iteration

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 2e6e476d02a..dd76153a9b1 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.2</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index b8e56b89b82..3727ab9422d 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index d8a058537f2..089e15cd933 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index 71600fbee2c..4c1f11e53a8 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 0c2d802266e..9cef313f8a5 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index fc8d3ac0f8e..20b9afc1bcd 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 29c1aa42001..12e42dfdf53 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 2da3da4024f..da2e82e0ab0 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index bf122a19e35..34cb3ef7063 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index baa2e42c539..04d8c98c4f0 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 5076a146901..57fbd5d3432 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index c5eeee518da..37ba8556a53 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 1c6359d2cdd..9893711d340 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 2fb5f3cb27f..bd3a6380d6b 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index c37285e5f7c..6834cdd1882 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.2</version>
+  <version>4.19.3-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1055,7 +1055,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>4.19.2</tag>
+    <tag>HEAD</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index a62c800cbd3..2bfe1bee8f5 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 0f24f638047..5bf2d07f652 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.2</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From a7da99556b6c202eecc6d5cb1c6371492729ab49 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Thu, 4 Dec 2025 12:04:26 -0600
Subject: [PATCH 098/126] Removing interface to Travis CI

Patch by Bret McGuire; reviewed by Andy Tolbert and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/2066
---
 .travis.yml | 39 ---------------------------------------
 1 file changed, 39 deletions(-)
 delete mode 100644 .travis.yml

diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 84d40ce1356..00000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-
-language: java
-dist: trusty
-sudo: false
-# see https://sormuras.github.io/blog/2018-03-20-jdk-matrix.html
-matrix:
-  include:
-    # 8
-    - env: JDK='OpenJDK 8'
-      jdk: openjdk8
-    # 11
-    - env: JDK='OpenJDK 11'
-      # switch to JDK 11 before running tests
-      before_script: . $TRAVIS_BUILD_DIR/ci/install-jdk.sh -F 11 -L GPL
-before_install:
-  # Require JDK8 for compiling
-  - jdk_switcher use openjdk8
-  - ./install-snapshots.sh
-install: mvn install -DskipTests=true -Dmaven.javadoc.skip=true -B -V
-script: mvn test -Djacoco.skip=true -Dmaven.test.failure.ignore=true -Dmaven.javadoc.skip=true -B -V
-cache:
-  directories:
-    - $HOME/.m2

From ded2985f14e9774cb46dd0104b1f045613bc0279 Mon Sep 17 00:00:00 2001
From: "April I. Murphy" <36110273+aimurphy@users.noreply.github.com>
Date: Thu, 20 Nov 2025 08:21:36 -0800
Subject: [PATCH 099/126] Replace outdated link in README

patch by April Murphy; reviewed by Bret McGuire and Lukasz Antoniak
reference: https://github.com/apache/cassandra-java-driver/pull/2064
---
 README.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/README.md b/README.md
index 0f6c2bb5a6f..5994a4be8a1 100644
--- a/README.md
+++ b/README.md
@@ -67,10 +67,6 @@ remain unchanged, and the new API will look very familiar to 2.x and 3.x users.
 
 See the [upgrade guide](upgrade_guide/) for details.
 
-## Error Handling
-
-See the [Cassandra error handling done right blog](https://www.datastax.com/blog/cassandra-error-handling-done-right) for error handling with the Java Driver for Apache Cassandra&trade;.
-
 ## Useful links
 
 * [Manual](manual/)

From e762df872b7ca02b4cd5cf780bd96f77815c9646 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Fri, 19 Dec 2025 13:13:18 +0100
Subject: [PATCH 100/126] ninja-fix: Remove ASF donation message

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index 5994a4be8a1..d8ef01d0964 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,5 @@
 # Java Driver for Apache Cassandra®
 
-:warning: The java-driver has recently been donated by Datastax to The Apache Software Foundation and the Apache Cassandra project.  Bear with us as we move assets and coordinates.
-
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.apache.cassandra/java-driver-core/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.apache.cassandra/java-driver-core)
 

From 595cb29912dc8b55663cc13bafe3f17dc4f91ce6 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <abe@aber.io>
Date: Mon, 22 Dec 2025 22:20:20 -0800
Subject: [PATCH 101/126] Update LZ4 and Netty dependencies for CVE response

The primary goal here is to address CVE-2025-12183. Netty includes a
dependency on vulnerable versions of lz4-java, so update to a fixed
version of Netty as well. On the C* server side, we opted to move to the
new community fork of lz4-java, so match that decision here
(CASSANDRA-21052).

patch by Abe Ratnofsky; reviewed by Francisco Guerrero for CASSJAVA-113
---
 NOTICE_binary.txt                                           | 2 +-
 core-shaded/pom.xml                                         | 2 +-
 core/pom.xml                                                | 2 +-
 core/src/main/resources/reference.conf                      | 2 +-
 .../internal/core/insights/PlatformInfoFinderTest.java      | 2 +-
 core/src/test/resources/insights/test-dependencies.txt      | 2 +-
 integration-tests/pom.xml                                   | 2 +-
 manual/core/compression/README.md                           | 6 +++---
 manual/core/integration/README.md                           | 2 +-
 osgi-tests/pom.xml                                          | 2 +-
 .../oss/driver/internal/osgi/support/BundleOptions.java     | 2 +-
 pom.xml                                                     | 6 +++---
 12 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/NOTICE_binary.txt b/NOTICE_binary.txt
index c60d8ceb245..f6f11c298f6 100644
--- a/NOTICE_binary.txt
+++ b/NOTICE_binary.txt
@@ -100,7 +100,7 @@ and decompression library written by Adrien Grand. It can be obtained at:
   * LICENSE:
     * license/LICENSE.lz4.txt (Apache License 2.0)
   * HOMEPAGE:
-    * https://github.com/jpountz/lz4-java
+    * https://github.com/yawkat/lz4-java
 
 This product optionally depends on 'lzma-java', a LZMA Java compression
 and decompression library, which can be obtained at:
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 3727ab9422d..84cb4b15398 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -74,7 +74,7 @@
       <optional>true</optional>
     </dependency>
     <dependency>
-      <groupId>org.lz4</groupId>
+      <groupId>at.yawk.lz4</groupId>
       <artifactId>lz4-java</artifactId>
       <optional>true</optional>
     </dependency>
diff --git a/core/pom.xml b/core/pom.xml
index 089e15cd933..8758d20d78a 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -73,7 +73,7 @@
       <optional>true</optional>
     </dependency>
     <dependency>
-      <groupId>org.lz4</groupId>
+      <groupId>at.yawk.lz4</groupId>
       <artifactId>lz4-java</artifactId>
       <optional>true</optional>
     </dependency>
diff --git a/core/src/main/resources/reference.conf b/core/src/main/resources/reference.conf
index 741b1d97654..4ae83362e29 100644
--- a/core/src/main/resources/reference.conf
+++ b/core/src/main/resources/reference.conf
@@ -1114,7 +1114,7 @@ datastax-java-driver {
     # The name of the algorithm used to compress protocol frames.
     #
     # The possible values are:
-    # - lz4: requires net.jpountz.lz4:lz4 in the classpath.
+    # - lz4: requires at.yawk.lz4:lz4-java in the classpath.
     # - snappy: requires org.xerial.snappy:snappy-java in the classpath.
     # - the string "none" to indicate no compression (this is functionally equivalent to omitting
     #   the option).
diff --git a/core/src/test/java/com/datastax/dse/driver/internal/core/insights/PlatformInfoFinderTest.java b/core/src/test/java/com/datastax/dse/driver/internal/core/insights/PlatformInfoFinderTest.java
index 80294ea6b7d..2a098363d46 100644
--- a/core/src/test/java/com/datastax/dse/driver/internal/core/insights/PlatformInfoFinderTest.java
+++ b/core/src/test/java/com/datastax/dse/driver/internal/core/insights/PlatformInfoFinderTest.java
@@ -77,7 +77,7 @@ public void should_find_dependencies_from_file() {
         "com.fasterxml.jackson.core:jackson-annotations", withUnverifiedRuntimeVersion("2.8.11"));
     expected.put("com.fasterxml.jackson.core:jackson-core", withUnverifiedRuntimeVersion("2.8.11"));
     expected.put("io.netty:netty-handler", withUnverifiedRuntimeVersion("4.0.56.Final"));
-    expected.put("org.lz4:lz4-java", withUnverifiedRuntimeVersionOptional("1.4.1"));
+    expected.put("at.yawk.lz4:lz4-java", withUnverifiedRuntimeVersionOptional("1.10.1"));
     expected.put("org.hdrhistogram:HdrHistogram", withUnverifiedRuntimeVersionOptional("2.1.10"));
     expected.put("com.github.jnr:jffi", withUnverifiedRuntimeVersion("1.2.16"));
     expected.put("io.netty:netty-buffer", withUnverifiedRuntimeVersion("4.0.56.Final"));
diff --git a/core/src/test/resources/insights/test-dependencies.txt b/core/src/test/resources/insights/test-dependencies.txt
index 6cabe8b257d..e9186a35e6b 100644
--- a/core/src/test/resources/insights/test-dependencies.txt
+++ b/core/src/test/resources/insights/test-dependencies.txt
@@ -17,7 +17,7 @@ The following files have been resolved:
    com.fasterxml.jackson.core:jackson-core:jar:2.8.11:compile
    org.hdrhistogram:HdrHistogram:jar:2.1.10:compile (optional)
    org.ow2.asm:asm-tree:jar:5.0.3:compile
-   org.lz4:lz4-java:jar:1.4.1:compile (optional)
+   at.yawk.lz4:lz4-java:jar:1.10.1:compile (optional)
    io.netty:netty-transport:jar:4.0.56.Final:compile
    io.dropwizard.metrics:metrics-core:jar:3.2.2:compile
    io.netty:netty-common:jar:4.0.56.Final:compile
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 34cb3ef7063..e302e12077f 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -129,7 +129,7 @@
       <scope>test</scope>
     </dependency>
     <dependency>
-      <groupId>org.lz4</groupId>
+      <groupId>at.yawk.lz4</groupId>
       <artifactId>lz4-java</artifactId>
       <scope>test</scope>
     </dependency>
diff --git a/manual/core/compression/README.md b/manual/core/compression/README.md
index 9e84fde917d..9f7ae3c4854 100644
--- a/manual/core/compression/README.md
+++ b/manual/core/compression/README.md
@@ -46,7 +46,7 @@ datastax-java-driver {
 
 Compression must be set before opening a session, it cannot be changed at runtime.
 
-Two algorithms are supported out of the box: [LZ4](https://github.com/jpountz/lz4-java) and
+Two algorithms are supported out of the box: [LZ4](https://github.com/yawkat/lz4-java) and
 [Snappy](http://google.github.io/snappy/). The LZ4 implementation is a good first choice; it offers
 fallback implementations in case native libraries fail to load and
 [benchmarks](http://java-performance.info/performance-general-compression/) suggest that it offers
@@ -63,9 +63,9 @@ Dependency:
 
 ```xml
 <dependency>
-  <groupId>org.lz4</groupId>
+  <groupId>at.yawk.lz4</groupId>
   <artifactId>lz4-java</artifactId>
-  <version>1.4.1</version>
+  <version>1.10.1</version>
 </dependency>
 ```
 
diff --git a/manual/core/integration/README.md b/manual/core/integration/README.md
index f2a96160bce..e2c7bc218ee 100644
--- a/manual/core/integration/README.md
+++ b/manual/core/integration/README.md
@@ -416,7 +416,7 @@ are not available on your platform, you can exclude the following dependency:
 
 #### Compression libraries
 
-The driver supports compression with either [LZ4](https://github.com/jpountz/lz4-java) or
+The driver supports compression with either [LZ4](https://github.com/yawkat/lz4-java) or
 [Snappy](http://google.github.io/snappy/).
 
 These dependencies are optional; you have to add them explicitly in your application in order to
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index bd3a6380d6b..c2cc4d830f1 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -79,7 +79,7 @@
       <artifactId>snappy-java</artifactId>
     </dependency>
     <dependency>
-      <groupId>org.lz4</groupId>
+      <groupId>at.yawk.lz4</groupId>
       <artifactId>lz4-java</artifactId>
     </dependency>
     <dependency>
diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
index 3e6171ca530..378b515aa65 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
@@ -117,7 +117,7 @@ public static CompositeOption jacksonBundles() {
   public static CompositeOption lz4Bundle() {
     return () ->
         options(
-            mavenBundle("org.lz4", "lz4-java").versionAsInProject(),
+            mavenBundle("at.yawk.lz4", "lz4-java").versionAsInProject(),
             systemProperty("cassandra.compression").value("LZ4"));
   }
 
diff --git a/pom.xml b/pom.xml
index 6834cdd1882..eb83459cfb4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -57,7 +57,7 @@
     <!-- when changing version also update version in LICENSE_binary  -->
     <hdrhistogram.version>2.1.12</hdrhistogram.version>
     <metrics.version>4.1.18</metrics.version>
-    <netty.version>4.1.119.Final</netty.version>
+    <netty.version>4.1.130.Final</netty.version>
     <esri.version>1.2.1</esri.version>
     <!--
     When upgrading TinkerPop please upgrade the version matrix in
@@ -73,7 +73,7 @@
     <jackson-databind.version>${jackson.version}</jackson-databind.version>
     <!-- optional dependencies -->
     <snappy.version>1.1.10.1</snappy.version>
-    <lz4.version>1.7.1</lz4.version>
+    <lz4.version>1.10.1</lz4.version>
     <!-- test dependencies -->
     <assertj.version>3.19.0</assertj.version>
     <commons-exec.version>1.3</commons-exec.version>
@@ -137,7 +137,7 @@
         <version>${snappy.version}</version>
       </dependency>
       <dependency>
-        <groupId>org.lz4</groupId>
+        <groupId>at.yawk.lz4</groupId>
         <artifactId>lz4-java</artifactId>
         <version>${lz4.version}</version>
       </dependency>

From ad7a103f9375083024548447cde5e1d2435198a6 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Thu, 14 Aug 2025 16:42:53 -0500
Subject: [PATCH 102/126] Bump logback to most recent Java8-compatible version

patch by Bret McGuire; reviewed by Bret McGuire and Lukasz Antoniak
reference: https://github.com/apache/cassandra-java-driver/pull/2051
---
 .../driver/internal/osgi/support/BundleOptions.java    | 10 ++++++++++
 pom.xml                                                |  4 ++--
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
index 378b515aa65..93cc7718b77 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
@@ -102,6 +102,16 @@ public static CompositeOption logbackBundles() {
         options(
             mavenBundle("ch.qos.logback", "logback-classic").versionAsInProject(),
             mavenBundle("ch.qos.logback", "logback-core").versionAsInProject(),
+
+            // slf4j 2.x requires spifly in order to operate in an OSGi context
+            mavenBundle("org.apache.aries.spifly", "org.apache.aries.spifly.dynamic.bundle")
+                .version("1.3.7"),
+            mavenBundle("org.apache.aries", "org.apache.aries.util").version("1.1.1"),
+            mavenBundle("org.ow2.asm", "asm").version("9.6"),
+            mavenBundle("org.ow2.asm", "asm-commons").version("9.6"),
+            mavenBundle("org.ow2.asm", "asm-util").version("9.6"),
+            mavenBundle("org.ow2.asm", "asm-tree").version("9.6"),
+            mavenBundle("org.ow2.asm", "asm-analysis").version("9.6"),
             systemProperty("logback.configurationFile")
                 .value("file:src/test/resources/logback-test.xml"));
   }
diff --git a/pom.xml b/pom.xml
index eb83459cfb4..511d2eb3098 100644
--- a/pom.xml
+++ b/pom.xml
@@ -65,7 +65,7 @@
     -->
     <tinkerpop.version>3.5.6</tinkerpop.version>
     <!-- when changing version also update version in LICENSE_binary  -->
-    <slf4j.version>1.7.26</slf4j.version>
+    <slf4j.version>2.0.16</slf4j.version>
     <!-- when changing version also update version in LICENSE_binary  -->
     <reactive-streams.version>1.0.3</reactive-streams.version>
     <json.version>20230227</json.version>
@@ -78,7 +78,7 @@
     <assertj.version>3.19.0</assertj.version>
     <commons-exec.version>1.3</commons-exec.version>
     <junit.version>4.13.2</junit.version>
-    <logback.version>1.2.3</logback.version>
+    <logback.version>1.3.15</logback.version>
     <osgi.version>6.0.0</osgi.version>
     <felix.version>7.0.1</felix.version>
     <pax-exam.version>4.13.4</pax-exam.version>

From e317b61ae68516d5ce61dc8ae5aa1d754fdc38b4 Mon Sep 17 00:00:00 2001
From: Mikhail Laptev <mikhail.laptev@gmail.com>
Date: Wed, 7 Jan 2026 14:35:55 +0000
Subject: [PATCH 103/126] ninja-fix - adding an extra space to render the page
 correctly with mkdocs

I've been looking into details on custom codes and noticed that the there is an issue with rendering bullet points on the following page: https://apache.github.io/cassandra-java-driver/4.19.0/core/custom_codecs/
---
 manual/core/custom_codecs/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/manual/core/custom_codecs/README.md b/manual/core/custom_codecs/README.md
index f3b7be1e3d9..ae42a8637ec 100644
--- a/manual/core/custom_codecs/README.md
+++ b/manual/core/custom_codecs/README.md
@@ -33,6 +33,7 @@ Define custom Java to CQL mappings.
         (MutableCodecRegistry) session.getContext().getCodecRegistry();    
     registry.register(myCodec);
     ```
+
 * using a codec:
   * if already registered: `row.get("columnName", MyCustomType.class)`
   * otherwise: `row.get("columnName", myCodec)`

From 855cd0b14d0552c7ab3c19c63deadee15bc9b83f Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Wed, 14 Jan 2026 15:36:58 -0600
Subject: [PATCH 104/126] ninja-fix Updating a few indented lists that were
 observed to not render correctly while working on the previous ninja-fix

---
 manual/core/custom_codecs/README.md |  8 ++++----
 manual/core/graalvm/README.md       | 12 ++++++------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/manual/core/custom_codecs/README.md b/manual/core/custom_codecs/README.md
index ae42a8637ec..3a32164c3a4 100644
--- a/manual/core/custom_codecs/README.md
+++ b/manual/core/custom_codecs/README.md
@@ -25,8 +25,8 @@ Define custom Java to CQL mappings.
 
 * implement the [TypeCodec] interface, or use one of the alternative codecs in `ExtraTypeCodecs`.
 * registering a codec:
-  * at init time: [CqlSession.builder().addTypeCodecs()][SessionBuilder.addTypeCodecs]
-  * at runtime:
+    * at init time: [CqlSession.builder().addTypeCodecs()][SessionBuilder.addTypeCodecs]
+    * at runtime:
   
     ```java
     MutableCodecRegistry registry =
@@ -35,8 +35,8 @@ Define custom Java to CQL mappings.
     ```
 
 * using a codec:
-  * if already registered: `row.get("columnName", MyCustomType.class)`
-  * otherwise: `row.get("columnName", myCodec)`
+    * if already registered: `row.get("columnName", MyCustomType.class)`
+    * otherwise: `row.get("columnName", myCodec)`
 
 -----
 
diff --git a/manual/core/graalvm/README.md b/manual/core/graalvm/README.md
index d20fb739f19..5fcaaff9178 100644
--- a/manual/core/graalvm/README.md
+++ b/manual/core/graalvm/README.md
@@ -24,13 +24,13 @@ under the License.
 * [GraalVM native images](https://www.graalvm.org/reference-manual/native-image/) can be built with 
   no additional configuration starting with driver 4.13.0.
 * But extra configurations are required in a few cases:
-  * When using [reactive programming](../reactive);
-  * When using [Jackson](../integration#Jackson);
-  * When using LZ4 [compression](../compression/);
-  * Depending on the [logging backend](../logging) in use.
+    * When using [reactive programming](../reactive);
+    * When using [Jackson](../integration#Jackson);
+    * When using LZ4 [compression](../compression/);
+    * Depending on the [logging backend](../logging) in use.
 * DSE-specific features:
-  * [Geospatial types](../dse/geotypes) are supported.
-  * [DSE Graph](../dse/graph) is not officially supported, although it may work.
+    * [Geospatial types](../dse/geotypes) are supported.
+    * [DSE Graph](../dse/graph) is not officially supported, although it may work.
 * The [shaded jar](../shaded_jar) is not officially supported, although it may work.
 
 -----

From af0a63a91a3dd1d3585070258e5c711fff50d77b Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Mon, 21 Jul 2025 16:11:32 -0500
Subject: [PATCH 105/126] Re-work ordering clause support in query builder
 behind a single OrderingClause abstraction.  This allows for custom impls to
 define their own logic for managing "ORDER BY" clauses.

patch by Bret McGuire; reviewed by Bret McGuire and Lukasz Antoniak
reference: https://github.com/apache/cassandra-java-driver/pull/2047
---
 .../select/AnnOrderingClause.java             |  50 +++++++
 .../select/ColumnsOrderingClause.java         |  68 +++++++++
 .../querybuilder/select/OrderingClause.java   |  27 ++++
 .../querybuilder/select/DefaultSelect.java    | 133 ++++++------------
 .../select/SelectOrderingTest.java            |  27 +++-
 5 files changed, 208 insertions(+), 97 deletions(-)
 create mode 100644 query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/AnnOrderingClause.java
 create mode 100644 query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/ColumnsOrderingClause.java
 create mode 100644 query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/OrderingClause.java

diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/AnnOrderingClause.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/AnnOrderingClause.java
new file mode 100644
index 00000000000..a2226d88ac6
--- /dev/null
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/AnnOrderingClause.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.api.querybuilder.select;
+
+import com.datastax.oss.driver.api.core.CqlIdentifier;
+import com.datastax.oss.driver.api.core.data.CqlVector;
+import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+/**
+ * Concrete implementation of {@link OrderingClause} which supports ordering by
+ * the adjacent nearest-neighbor (ANN) calculation.  This usage is primarily used
+ * for vector calculations.
+ */
+public class AnnOrderingClause extends OrderingClause {
+
+  private final CqlIdentifier identifier;
+  private final CqlVector<?> vector;
+
+  AnnOrderingClause(CqlIdentifier identifier, CqlVector<?> vector) {
+
+    this.identifier = identifier;
+    this.vector = vector;
+  }
+
+  public static AnnOrderingClause create(CqlIdentifier identifier, CqlVector<?> vector) {
+    return new AnnOrderingClause(identifier, vector);
+  }
+
+  @Override
+  public void appendTo(@NonNull StringBuilder builder) {
+    builder.append(" ORDER BY ").append(this.identifier.asCql(true)).append(" ANN OF ");
+    QueryBuilder.literal(this.vector).appendTo(builder);
+  }
+}
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/ColumnsOrderingClause.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/ColumnsOrderingClause.java
new file mode 100644
index 00000000000..b33a9d8e88d
--- /dev/null
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/ColumnsOrderingClause.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.api.querybuilder.select;
+
+import com.datastax.oss.driver.api.core.CqlIdentifier;
+import com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder;
+import com.datastax.oss.driver.internal.querybuilder.ImmutableCollections;
+import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.util.Map;
+
+/**
+ * Concrete implementation of {@link OrderingClause} which supports ordering by
+ * specified columns.  This usages is the default ORDER BY syntax for Apache Cassandra.
+ */
+public class ColumnsOrderingClause extends OrderingClause {
+
+  private final ImmutableMap<CqlIdentifier, ClusteringOrder> orderings;
+
+  ColumnsOrderingClause(ImmutableMap<CqlIdentifier, ClusteringOrder> orderings) {
+
+    this.orderings = orderings;
+  }
+
+  public static ColumnsOrderingClause create() {
+    return new ColumnsOrderingClause(ImmutableMap.of());
+  }
+
+  public ColumnsOrderingClause add(
+      @NonNull CqlIdentifier identifier, @NonNull ClusteringOrder order) {
+    return new ColumnsOrderingClause(
+        ImmutableCollections.append(this.orderings, identifier, order));
+  }
+
+  public ColumnsOrderingClause add(@NonNull Map<CqlIdentifier, ClusteringOrder> orderMap) {
+    return new ColumnsOrderingClause(ImmutableCollections.concat(this.orderings, orderMap));
+  }
+
+  @Override
+  public void appendTo(@NonNull StringBuilder builder) {
+
+    boolean first = true;
+    for (Map.Entry<CqlIdentifier, ClusteringOrder> entry : orderings.entrySet()) {
+      if (first) {
+        builder.append(" ORDER BY ");
+        first = false;
+      } else {
+        builder.append(",");
+      }
+      builder.append(entry.getKey().asCql(true)).append(" ").append(entry.getValue().name());
+    }
+  }
+}
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/OrderingClause.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/OrderingClause.java
new file mode 100644
index 00000000000..0318d115ae4
--- /dev/null
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/OrderingClause.java
@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.datastax.oss.driver.api.querybuilder.select;
+
+import com.datastax.oss.driver.api.querybuilder.CqlSnippet;
+
+/**
+ * Abstract representation of an ordering clause (i.e. ORDER BY) in a CQL statement.
+ * Alternate implementations may be provided if servers wind up implementing customized
+ * orderings.
+ */
+public abstract class OrderingClause implements CqlSnippet {}
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java b/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
index 5daf252a9eb..e4b98ef6f53 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
@@ -23,8 +23,10 @@
 import com.datastax.oss.driver.api.core.data.CqlVector;
 import com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder;
 import com.datastax.oss.driver.api.querybuilder.BindMarker;
-import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
 import com.datastax.oss.driver.api.querybuilder.relation.Relation;
+import com.datastax.oss.driver.api.querybuilder.select.AnnOrderingClause;
+import com.datastax.oss.driver.api.querybuilder.select.ColumnsOrderingClause;
+import com.datastax.oss.driver.api.querybuilder.select.OrderingClause;
 import com.datastax.oss.driver.api.querybuilder.select.Select;
 import com.datastax.oss.driver.api.querybuilder.select.SelectFrom;
 import com.datastax.oss.driver.api.querybuilder.select.Selector;
@@ -32,10 +34,10 @@
 import com.datastax.oss.driver.internal.querybuilder.ImmutableCollections;
 import com.datastax.oss.driver.shaded.guava.common.base.Preconditions;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
-import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.util.Map;
+import java.util.Optional;
 import net.jcip.annotations.Immutable;
 
 @Immutable
@@ -50,8 +52,7 @@ public class DefaultSelect implements SelectFrom, Select {
   private final ImmutableList<Selector> selectors;
   private final ImmutableList<Relation> relations;
   private final ImmutableList<Selector> groupByClauses;
-  private final ImmutableMap<CqlIdentifier, ClusteringOrder> orderings;
-  private final Ann ann;
+  private final Optional<OrderingClause> orderingClause;
   private final Object limit;
   private final Object perPartitionLimit;
   private final boolean allowsFiltering;
@@ -65,8 +66,7 @@ public DefaultSelect(@Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier ta
         ImmutableList.of(),
         ImmutableList.of(),
         ImmutableList.of(),
-        ImmutableMap.of(),
-        null,
+        Optional.empty(),
         null,
         null,
         false);
@@ -78,8 +78,6 @@ public DefaultSelect(@Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier ta
    * @param selectors if it contains {@link AllSelector#INSTANCE}, that must be the only element.
    *     This isn't re-checked because methods that call this constructor internally already do it,
    *     make sure you do it yourself.
-   * @param ann Approximate nearest neighbor. ANN ordering does not support secondary ordering or
-   *     ASC order.
    */
   public DefaultSelect(
       @Nullable CqlIdentifier keyspace,
@@ -89,21 +87,17 @@ public DefaultSelect(
       @NonNull ImmutableList<Selector> selectors,
       @NonNull ImmutableList<Relation> relations,
       @NonNull ImmutableList<Selector> groupByClauses,
-      @NonNull ImmutableMap<CqlIdentifier, ClusteringOrder> orderings,
-      @Nullable Ann ann,
+      @NonNull Optional<OrderingClause> orderingClause,
       @Nullable Object limit,
       @Nullable Object perPartitionLimit,
       boolean allowsFiltering) {
     this.groupByClauses = groupByClauses;
-    this.orderings = orderings;
+    this.orderingClause = orderingClause;
     Preconditions.checkArgument(
         limit == null
             || (limit instanceof Integer && (Integer) limit > 0)
             || limit instanceof BindMarker,
         "limit must be a strictly positive integer or a bind marker");
-    Preconditions.checkArgument(
-        orderings.isEmpty() || ann == null, "ANN ordering does not support secondary ordering");
-    this.ann = ann;
     this.keyspace = keyspace;
     this.table = table;
     this.isJson = isJson;
@@ -126,8 +120,7 @@ public SelectFrom json() {
         selectors,
         relations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -144,8 +137,7 @@ public SelectFrom distinct() {
         selectors,
         relations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -204,8 +196,7 @@ public Select withSelectors(@NonNull ImmutableList<Selector> newSelectors) {
         newSelectors,
         relations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -233,8 +224,7 @@ public Select withRelations(@NonNull ImmutableList<Relation> newRelations) {
         selectors,
         newRelations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -262,39 +252,54 @@ public Select withGroupByClauses(@NonNull ImmutableList<Selector> newGroupByClau
         selectors,
         relations,
         newGroupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         perPartitionLimit,
         allowsFiltering);
   }
 
+  /**
+   * Retrieve the current {@link OrderingClause} as a {@link ColumnsOrderingClause} if it exists and
+   * is an instance of this class, Otherwise create a new one.
+   *
+   * @return the current OrderingClause if it's a ColumnsOrderingClause or a new one otherwise
+   */
+  private ColumnsOrderingClause getColumnOrderingClause() {
+    return (ColumnsOrderingClause)
+        orderingClause
+            .map(
+                (oc) -> (oc instanceof ColumnsOrderingClause) ? oc : ColumnsOrderingClause.create())
+            .orElseGet(() -> ColumnsOrderingClause.create());
+  }
+
   @NonNull
   @Override
   public Select orderBy(@NonNull CqlIdentifier columnId, @NonNull ClusteringOrder order) {
-    return withOrderings(ImmutableCollections.append(orderings, columnId, order));
+    ColumnsOrderingClause coc = getColumnOrderingClause();
+    return withOrderingClause(coc.add(columnId, order));
   }
 
   @NonNull
   @Override
   public Select orderByAnnOf(@NonNull String columnName, @NonNull CqlVector<?> ann) {
-    return withAnn(new Ann(CqlIdentifier.fromCql(columnName), ann));
+    return withOrderingClause(AnnOrderingClause.create(CqlIdentifier.fromCql(columnName), ann));
   }
 
   @NonNull
   @Override
   public Select orderByAnnOf(@NonNull CqlIdentifier columnId, @NonNull CqlVector<?> ann) {
-    return withAnn(new Ann(columnId, ann));
+    return withOrderingClause(AnnOrderingClause.create(columnId, ann));
   }
 
   @NonNull
   @Override
   public Select orderByIds(@NonNull Map<CqlIdentifier, ClusteringOrder> newOrderings) {
-    return withOrderings(ImmutableCollections.concat(orderings, newOrderings));
+    ColumnsOrderingClause coc = getColumnOrderingClause();
+    return withOrderingClause(coc.add(newOrderings));
   }
 
   @NonNull
-  public Select withOrderings(@NonNull ImmutableMap<CqlIdentifier, ClusteringOrder> newOrderings) {
+  public Select withOrderingClause(@NonNull OrderingClause newOrderingClause) {
     return new DefaultSelect(
         keyspace,
         table,
@@ -303,25 +308,7 @@ public Select withOrderings(@NonNull ImmutableMap<CqlIdentifier, ClusteringOrder
         selectors,
         relations,
         groupByClauses,
-        newOrderings,
-        ann,
-        limit,
-        perPartitionLimit,
-        allowsFiltering);
-  }
-
-  @NonNull
-  Select withAnn(@NonNull Ann ann) {
-    return new DefaultSelect(
-        keyspace,
-        table,
-        isJson,
-        isDistinct,
-        selectors,
-        relations,
-        groupByClauses,
-        orderings,
-        ann,
+        Optional.of(newOrderingClause),
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -339,8 +326,7 @@ public Select limit(int limit) {
         selectors,
         relations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -357,8 +343,7 @@ public Select limit(@Nullable BindMarker bindMarker) {
         selectors,
         relations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         bindMarker,
         perPartitionLimit,
         allowsFiltering);
@@ -377,8 +362,7 @@ public Select perPartitionLimit(int perPartitionLimit) {
         selectors,
         relations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         perPartitionLimit,
         allowsFiltering);
@@ -395,8 +379,7 @@ public Select perPartitionLimit(@Nullable BindMarker bindMarker) {
         selectors,
         relations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         bindMarker,
         allowsFiltering);
@@ -413,8 +396,7 @@ public Select allowFiltering() {
         selectors,
         relations,
         groupByClauses,
-        orderings,
-        ann,
+        orderingClause,
         limit,
         perPartitionLimit,
         true);
@@ -441,21 +423,7 @@ public String asCql() {
     CqlHelper.append(relations, builder, " WHERE ", " AND ", null);
     CqlHelper.append(groupByClauses, builder, " GROUP BY ", ",", null);
 
-    if (ann != null) {
-      builder.append(" ORDER BY ").append(this.ann.columnId.asCql(true)).append(" ANN OF ");
-      QueryBuilder.literal(ann.vector).appendTo(builder);
-    } else {
-      boolean first = true;
-      for (Map.Entry<CqlIdentifier, ClusteringOrder> entry : orderings.entrySet()) {
-        if (first) {
-          builder.append(" ORDER BY ");
-          first = false;
-        } else {
-          builder.append(",");
-        }
-        builder.append(entry.getKey().asCql(true)).append(" ").append(entry.getValue().name());
-      }
-    }
+    orderingClause.ifPresent(c -> c.appendTo(builder));
 
     if (limit != null) {
       builder.append(" LIMIT ");
@@ -545,8 +513,8 @@ public ImmutableList<Selector> getGroupByClauses() {
   }
 
   @NonNull
-  public ImmutableMap<CqlIdentifier, ClusteringOrder> getOrderings() {
-    return orderings;
+  public Optional<OrderingClause> getOrderingClause() {
+    return orderingClause;
   }
 
   @Nullable
@@ -554,11 +522,6 @@ public Object getLimit() {
     return limit;
   }
 
-  @Nullable
-  public Ann getAnn() {
-    return ann;
-  }
-
   @Nullable
   public Object getPerPartitionLimit() {
     return perPartitionLimit;
@@ -572,14 +535,4 @@ public boolean allowsFiltering() {
   public String toString() {
     return asCql();
   }
-
-  public static class Ann {
-    private final CqlVector<?> vector;
-    private final CqlIdentifier columnId;
-
-    private Ann(CqlIdentifier columnId, CqlVector<?> vector) {
-      this.vector = vector;
-      this.columnId = columnId;
-    }
-  }
 }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectOrderingTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectOrderingTest.java
index a9c618e9559..04831bb0f8d 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectOrderingTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectOrderingTest.java
@@ -86,12 +86,25 @@ public void should_generate_ann_clause() {
         .hasCql("SELECT * FROM foo WHERE k=1 ORDER BY c1 ANN OF [0.1, 0.2, 0.3]");
   }
 
-  @Test(expected = IllegalArgumentException.class)
-  public void should_fail_when_provided_ann_with_other_orderings() {
-    selectFrom("foo")
-        .all()
-        .where(Relation.column("k").isEqualTo(literal(1)))
-        .orderBy("c1", ASC)
-        .orderByAnnOf("c2", CqlVector.newInstance(0.1, 0.2, 0.3));
+  @Test
+  public void should_replace_columns_ordering_with_ann() {
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(Relation.column("k").isEqualTo(literal(1)))
+                .orderBy("c1", ASC)
+                .orderByAnnOf("c2", CqlVector.newInstance(0.1, 0.2, 0.3)))
+        .hasCql("SELECT * FROM foo WHERE k=1 ORDER BY c2 ANN OF [0.1, 0.2, 0.3]");
+  }
+
+  @Test
+  public void should_replace_ann_ordering_with_columns() {
+    assertThat(
+            selectFrom("foo")
+                .all()
+                .where(Relation.column("k").isEqualTo(literal(1)))
+                .orderByAnnOf("c1", CqlVector.newInstance(0.1, 0.2, 0.3))
+                .orderBy("c2", ASC))
+        .hasCql("SELECT * FROM foo WHERE k=1 ORDER BY c2 ASC");
   }
 }

From 35bae4f72dea82bb0001d97e7ab1981a6ff68edd Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Thu, 15 Jan 2026 10:04:15 -0600
Subject: [PATCH 106/126] ninja-fix We apparently had some unformatted files
 slip in in the last commit

---
 .../driver/api/querybuilder/select/AnnOrderingClause.java    | 5 ++---
 .../api/querybuilder/select/ColumnsOrderingClause.java       | 4 ++--
 .../oss/driver/api/querybuilder/select/OrderingClause.java   | 5 ++---
 3 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/AnnOrderingClause.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/AnnOrderingClause.java
index a2226d88ac6..f7163a30160 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/AnnOrderingClause.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/AnnOrderingClause.java
@@ -23,9 +23,8 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 
 /**
- * Concrete implementation of {@link OrderingClause} which supports ordering by
- * the adjacent nearest-neighbor (ANN) calculation.  This usage is primarily used
- * for vector calculations.
+ * Concrete implementation of {@link OrderingClause} which supports ordering by the adjacent
+ * nearest-neighbor (ANN) calculation. This usage is primarily used for vector calculations.
  */
 public class AnnOrderingClause extends OrderingClause {
 
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/ColumnsOrderingClause.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/ColumnsOrderingClause.java
index b33a9d8e88d..2f03a979138 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/ColumnsOrderingClause.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/ColumnsOrderingClause.java
@@ -25,8 +25,8 @@
 import java.util.Map;
 
 /**
- * Concrete implementation of {@link OrderingClause} which supports ordering by
- * specified columns.  This usages is the default ORDER BY syntax for Apache Cassandra.
+ * Concrete implementation of {@link OrderingClause} which supports ordering by specified columns.
+ * This usages is the default ORDER BY syntax for Apache Cassandra.
  */
 public class ColumnsOrderingClause extends OrderingClause {
 
diff --git a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/OrderingClause.java b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/OrderingClause.java
index 0318d115ae4..d653d5f4b8f 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/OrderingClause.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/api/querybuilder/select/OrderingClause.java
@@ -20,8 +20,7 @@
 import com.datastax.oss.driver.api.querybuilder.CqlSnippet;
 
 /**
- * Abstract representation of an ordering clause (i.e. ORDER BY) in a CQL statement.
- * Alternate implementations may be provided if servers wind up implementing customized
- * orderings.
+ * Abstract representation of an ordering clause (i.e. ORDER BY) in a CQL statement. Alternate
+ * implementations may be provided if servers wind up implementing customized orderings.
  */
 public abstract class OrderingClause implements CqlSnippet {}

From e84bb1a89d649f9da9c49eca46b8b14686a48ad3 Mon Sep 17 00:00:00 2001
From: Lukasz Antoniak <Lukasz.Antoniak@gmail.com>
Date: Tue, 27 Jan 2026 17:21:52 +0100
Subject: [PATCH 107/126] CASSJAVA-122 Fix OSGi LZ4 test

patch by Lukasz Antoniak; reviewed by Bret McGuire and Lukasz Antoniak
reference: https://github.com/apache/cassandra-java-driver/pull/2075
---
 .../oss/driver/internal/osgi/support/BundleOptions.java        | 3 +++
 pom.xml                                                        | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
index 93cc7718b77..63d11f8ee08 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
@@ -128,6 +128,9 @@ public static CompositeOption lz4Bundle() {
     return () ->
         options(
             mavenBundle("at.yawk.lz4", "lz4-java").versionAsInProject(),
+            // at.yawk.lz4 requires sun.misc package
+            mavenBundle("com.diffplug.osgi", "com.diffplug.osgi.extension.sun.misc")
+                .version("0.0.0"),
             systemProperty("cassandra.compression").value("LZ4"));
   }
 
diff --git a/pom.xml b/pom.xml
index 511d2eb3098..3948997b1ba 100644
--- a/pom.xml
+++ b/pom.xml
@@ -73,7 +73,7 @@
     <jackson-databind.version>${jackson.version}</jackson-databind.version>
     <!-- optional dependencies -->
     <snappy.version>1.1.10.1</snappy.version>
-    <lz4.version>1.10.1</lz4.version>
+    <lz4.version>1.10.2</lz4.version>
     <!-- test dependencies -->
     <assertj.version>3.19.0</assertj.version>
     <commons-exec.version>1.3</commons-exec.version>

From deffb9230cf5067e259a0ddee6434e2432155e47 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Thu, 15 Jan 2026 12:17:55 -0600
Subject: [PATCH 108/126] Bump Jackson to 2.20.1

patch by Bret McGuire: reviewed by Bret McGuire and Lukasz Antoniak
reference: https://github.com/apache/cassandra-java-driver/pull/2076
---
 core/revapi.json           | 7988 +++++-------------------------------
 mapper-runtime/revapi.json |   54 -
 pom.xml                    |    2 +-
 query-builder/revapi.json  | 2765 -------------
 test-infra/revapi.json     |  174 -
 5 files changed, 1070 insertions(+), 9913 deletions(-)

diff --git a/core/revapi.json b/core/revapi.json
index 8c707659c13..d56566bc2b9 100644
--- a/core/revapi.json
+++ b/core/revapi.json
@@ -15,7403 +15,1553 @@
     },
     "ignore": [
       {
-        "code": "java.method.removed",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatementBuilder com.datastax.oss.driver.api.core.cql.BatchStatementBuilder::withKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatementBuilder com.datastax.oss.driver.api.core.cql.BatchStatementBuilder::withKeyspace(java.lang.String)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatementBuilder com.datastax.oss.driver.api.core.cql.SimpleStatementBuilder::withKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "code": "java.class.nonPublicPartOfAPI",
+        "old": "class com.datastax.oss.driver.internal.core.config.typesafe.TypesafeDriverExecutionProfile.Base",
+        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
       },
       {
-        "code": "java.method.removed",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatementBuilder com.datastax.oss.driver.api.core.cql.SimpleStatementBuilder::withKeyspace(java.lang.String)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "code": "java.class.nonPublicPartOfAPI",
+        "old": "class com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer",
+        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
       },
       {
-        "code": "java.method.removed",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatementBuilder com.datastax.oss.driver.api.core.cql.SimpleStatementBuilder::withQuery(java.lang.String)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "code": "java.class.nonPublicPartOfAPI",
+        "old": "class org.apache.tinkerpop.shaded.jackson.databind.type.TypeParser.MyTokenizer",
+        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "code": "java.class.externalClassExposedInAPI",
+        "justification": "CASSJAVA-102: Migrate revapi config into dedicated config files, ported from pom.xml"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "code": "java.method.varargOverloadsOnlyDifferInVarargParameter",
+        "justification": "CASSJAVA-102: Migrate revapi config into dedicated config files, ported from pom.xml"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withExecutionProfileName(java.lang.String)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.serialVersionUIDUnchanged",
+        "old": "field com.fasterxml.jackson.annotation.JacksonInject.Value.serialVersionUID",
+        "new": "field com.fasterxml.jackson.annotation.JacksonInject.Value.serialVersionUID",
+        "serialVersionUID": "1",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withIdempotence(java.lang.Boolean)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.annotation.JacksonInject.Value::<init>(java.lang.Object, java.lang.Boolean)",
+        "new": "method void com.fasterxml.jackson.annotation.JacksonInject.Value::<init>(java.lang.Object, java.lang.Boolean, java.lang.Boolean)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withNode(com.datastax.oss.driver.api.core.metadata.Node)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.serialVersionUIDUnchanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonAutoDetect.Value.serialVersionUID",
+        "new": "field com.fasterxml.jackson.annotation.JsonAutoDetect.Value.serialVersionUID",
+        "serialVersionUID": "1",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withPageSize(int)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.ACCEPT_CASE_INSENSITIVE_VALUES",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.ACCEPT_CASE_INSENSITIVE_VALUES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withPagingState(java.nio.ByteBuffer)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withRoutingKey(java.nio.ByteBuffer)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.WRITE_DATES_WITH_ZONE_ID",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.WRITE_DATES_WITH_ZONE_ID",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withRoutingKeyspace(java.lang.String)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.WRITE_SORTED_MAP_ENTRIES",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Feature.WRITE_SORTED_MAP_ENTRIES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.ANY",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.ANY",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withTimeout(java.time.Duration)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.ARRAY",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.ARRAY",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withTimestamp(long)",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.BINARY",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.BINARY",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT extends com.datastax.oss.driver.api.core.cql.StatementBuilder<SelfT, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>, StatementT>, StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT extends com.datastax.oss.driver.api.core.cql.Statement<StatementT>>>::withTracing()",
-        "justification": "JAVA-2164: Rename statement builder methods to setXxx"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.BOOLEAN",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.BOOLEAN",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter void com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException::<init>(===java.net.SocketAddress===, java.lang.String, java.util.List<com.datastax.oss.driver.api.core.ProtocolVersion>)",
-        "new": "parameter void com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException::<init>(===com.datastax.oss.driver.api.core.metadata.EndPoint===, java.lang.String, java.util.List<com.datastax.oss.driver.api.core.ProtocolVersion>)",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.NATURAL",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.NATURAL",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException::forNegotiation(===java.net.SocketAddress===, java.util.List<com.datastax.oss.driver.api.core.ProtocolVersion>)",
-        "new": "parameter com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException::forNegotiation(===com.datastax.oss.driver.api.core.metadata.EndPoint===, java.util.List<com.datastax.oss.driver.api.core.ProtocolVersion>)",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.NUMBER",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.NUMBER",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException::forSingleAttempt(===java.net.SocketAddress===, com.datastax.oss.driver.api.core.ProtocolVersion)",
-        "new": "parameter com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException::forSingleAttempt(===com.datastax.oss.driver.api.core.metadata.EndPoint===, com.datastax.oss.driver.api.core.ProtocolVersion)",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.NUMBER_FLOAT",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.NUMBER_FLOAT",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method java.net.SocketAddress com.datastax.oss.driver.api.core.UnsupportedProtocolVersionException::getAddress()",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.NUMBER_INT",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.NUMBER_INT",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter com.datastax.oss.driver.api.core.auth.Authenticator com.datastax.oss.driver.api.core.auth.AuthProvider::newAuthenticator(===java.net.SocketAddress===, java.lang.String) throws com.datastax.oss.driver.api.core.auth.AuthenticationException",
-        "new": "parameter com.datastax.oss.driver.api.core.auth.Authenticator com.datastax.oss.driver.api.core.auth.AuthProvider::newAuthenticator(===com.datastax.oss.driver.api.core.metadata.EndPoint===, java.lang.String) throws com.datastax.oss.driver.api.core.auth.AuthenticationException",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.OBJECT",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.OBJECT",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter void com.datastax.oss.driver.api.core.auth.AuthProvider::onMissingChallenge(===java.net.SocketAddress===) throws com.datastax.oss.driver.api.core.auth.AuthenticationException",
-        "new": "parameter void com.datastax.oss.driver.api.core.auth.AuthProvider::onMissingChallenge(===com.datastax.oss.driver.api.core.metadata.EndPoint===) throws com.datastax.oss.driver.api.core.auth.AuthenticationException",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.SCALAR",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.SCALAR",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter void com.datastax.oss.driver.api.core.auth.AuthenticationException::<init>(===java.net.SocketAddress===, java.lang.String)",
-        "new": "parameter void com.datastax.oss.driver.api.core.auth.AuthenticationException::<init>(===com.datastax.oss.driver.api.core.metadata.EndPoint===, java.lang.String)",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.STRING",
+        "new": "field com.fasterxml.jackson.annotation.JsonFormat.Shape.STRING",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter void com.datastax.oss.driver.api.core.auth.AuthenticationException::<init>(===java.net.SocketAddress===, java.lang.String, java.lang.Throwable)",
-        "new": "parameter void com.datastax.oss.driver.api.core.auth.AuthenticationException::<init>(===com.datastax.oss.driver.api.core.metadata.EndPoint===, java.lang.String, java.lang.Throwable)",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.annotation.JsonFormat.Value::<init>(java.lang.String, com.fasterxml.jackson.annotation.JsonFormat.Shape, java.util.Locale, java.util.TimeZone, com.fasterxml.jackson.annotation.JsonFormat.Features)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.method.removed",
-        "old": "method java.net.SocketAddress com.datastax.oss.driver.api.core.auth.AuthenticationException::getAddress()",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "old": "method void com.fasterxml.jackson.annotation.JsonFormat.Value::<init>(java.lang.String, com.fasterxml.jackson.annotation.JsonFormat.Shape, java.util.Locale, java.lang.String, java.util.TimeZone, com.fasterxml.jackson.annotation.JsonFormat.Features)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.numberOfParametersChanged",
-        "old": "method void com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy::init(java.util.Map<java.net.InetSocketAddress, com.datastax.oss.driver.api.core.metadata.Node>, com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy.DistanceReporter, java.util.Set<java.net.InetSocketAddress>)",
-        "new": "method void com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy::init(java.util.Map<java.util.UUID, com.datastax.oss.driver.api.core.metadata.Node>, com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy.DistanceReporter)",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.annotation.JsonFormat.Value::<init>(java.lang.String, com.fasterxml.jackson.annotation.JsonFormat.Shape, java.lang.String, java.lang.String, com.fasterxml.jackson.annotation.JsonFormat.Features)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<java.net.InetSocketAddress, com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.core.metadata.Metadata::getNodes()",
-        "new": "method java.util.Map<java.util.UUID, com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.core.metadata.Metadata::getNodes()",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.PropertyAccessor.ALL",
+        "new": "field com.fasterxml.jackson.annotation.PropertyAccessor.ALL",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.addedToInterface",
-        "new": "method java.util.Optional<java.net.InetSocketAddress> com.datastax.oss.driver.api.core.metadata.Node::getBroadcastRpcAddress()",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.PropertyAccessor.CREATOR",
+        "new": "field com.fasterxml.jackson.annotation.PropertyAccessor.CREATOR",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method java.net.InetSocketAddress com.datastax.oss.driver.api.core.metadata.Node::getConnectAddress()",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.PropertyAccessor.FIELD",
+        "new": "field com.fasterxml.jackson.annotation.PropertyAccessor.FIELD",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.core.metadata.EndPoint com.datastax.oss.driver.api.core.metadata.Node::getEndPoint()",
-        "package": "com.datastax.oss.driver.api.core.metadata",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.PropertyAccessor.IS_GETTER",
+        "new": "field com.fasterxml.jackson.annotation.PropertyAccessor.IS_GETTER",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter javax.net.ssl.SSLEngine com.datastax.oss.driver.api.core.ssl.SslEngineFactory::newSslEngine(===java.net.SocketAddress===)",
-        "new": "parameter javax.net.ssl.SSLEngine com.datastax.oss.driver.api.core.ssl.SslEngineFactory::newSslEngine(===com.datastax.oss.driver.api.core.metadata.EndPoint===)",
-        "justification": "JAVA-2165: Abstract node connection information"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.annotation.PropertyAccessor.NONE",
+        "new": "field com.fasterxml.jackson.annotation.PropertyAccessor.NONE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.addedToInterface",
-        "new": "method long com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::getQueryTimestamp()",
-        "justification": "JAVA-2143: Rename Statement.setTimestamp() to setQueryTimestamp()"
+        "ignore": true,
+        "code": "java.field.serialVersionUIDUnchanged",
+        "old": "field com.fasterxml.jackson.core.JsonFactory.serialVersionUID",
+        "new": "field com.fasterxml.jackson.core.JsonFactory.serialVersionUID",
+        "serialVersionUID": "2",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method long com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::getTimestamp()",
-        "justification": "JAVA-2143: Rename Statement.setTimestamp() to setQueryTimestamp()"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method int com.fasterxml.jackson.core.JsonFactory::getFactoryFeatures()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.addedToInterface",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setQueryTimestamp(long)",
-        "justification": "JAVA-2143: Rename Statement.setTimestamp() to setQueryTimestamp()"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimestamp(long)",
-        "justification": "JAVA-2143: Rename Statement.setTimestamp() to setQueryTimestamp()"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_LEADING_DECIMAL_POINT_FOR_NUMBERS",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_LEADING_DECIMAL_POINT_FOR_NUMBERS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_MISSING_VALUES",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_MISSING_VALUES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_TRAILING_COMMA",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_TRAILING_COMMA",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.IGNORE_UNDEFINED",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.IGNORE_UNDEFINED",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.INCLUDE_SOURCE_IN_LOCATION",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.INCLUDE_SOURCE_IN_LOCATION",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.JsonParser.Feature.STRICT_DUPLICATE_DETECTION",
+        "new": "field com.fasterxml.jackson.core.JsonParser.Feature.STRICT_DUPLICATE_DETECTION",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.core.JsonPointer::<init>(java.lang.String, java.lang.String, com.fasterxml.jackson.core.JsonPointer)",
+        "new": "method void com.fasterxml.jackson.core.JsonPointer::<init>(com.fasterxml.jackson.core.JsonPointer, com.fasterxml.jackson.core.JsonPointer)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.core.JsonPointer::<init>(java.lang.String, java.lang.String, int, com.fasterxml.jackson.core.JsonPointer)",
+        "new": "method void com.fasterxml.jackson.core.JsonPointer::<init>(com.fasterxml.jackson.core.JsonPointer, java.lang.String, int)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.core.JsonPointer com.fasterxml.jackson.core.JsonPointer::_constructHead(int, com.fasterxml.jackson.core.JsonPointer)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[]) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[]) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.core.JsonPointer com.fasterxml.jackson.core.JsonPointer::_parseQuotedTail(java.lang.String, int)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method int com.fasterxml.jackson.core.JsonStreamContext::getNestingDepth()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.StreamReadFeature.IGNORE_UNDEFINED",
+        "new": "field com.fasterxml.jackson.core.StreamReadFeature.IGNORE_UNDEFINED",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION",
+        "new": "field com.fasterxml.jackson.core.StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.StreamReadFeature.STRICT_DUPLICATE_DETECTION",
+        "new": "field com.fasterxml.jackson.core.StreamReadFeature.STRICT_DUPLICATE_DETECTION",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.StreamWriteFeature.AUTO_CLOSE_CONTENT",
+        "new": "field com.fasterxml.jackson.core.StreamWriteFeature.AUTO_CLOSE_CONTENT",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.StreamWriteFeature.AUTO_CLOSE_TARGET",
+        "new": "field com.fasterxml.jackson.core.StreamWriteFeature.AUTO_CLOSE_TARGET",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.StreamWriteFeature.IGNORE_UNKNOWN",
+        "new": "field com.fasterxml.jackson.core.StreamWriteFeature.IGNORE_UNKNOWN",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.StreamWriteFeature.STRICT_DUPLICATE_DETECTION",
+        "new": "field com.fasterxml.jackson.core.StreamWriteFeature.STRICT_DUPLICATE_DETECTION",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.serialVersionUIDUnchanged",
+        "old": "field com.fasterxml.jackson.core.io.ContentReference.serialVersionUID",
+        "new": "field com.fasterxml.jackson.core.io.ContentReference.serialVersionUID",
+        "serialVersionUID": "1",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method int com.fasterxml.jackson.core.io.ContentReference::maxContentSnippetLength()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER",
+        "new": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS",
+        "new": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_MISSING_VALUES",
+        "new": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_MISSING_VALUES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS",
+        "new": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_SINGLE_QUOTES",
+        "new": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_SINGLE_QUOTES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_TRAILING_COMMA",
+        "new": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_TRAILING_COMMA",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[]) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[]) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_UNQUOTED_FIELD_NAMES",
+        "new": "field com.fasterxml.jackson.core.json.JsonReadFeature.ALLOW_UNQUOTED_FIELD_NAMES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonWriteFeature.ESCAPE_NON_ASCII",
+        "new": "field com.fasterxml.jackson.core.json.JsonWriteFeature.ESCAPE_NON_ASCII",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonWriteFeature.QUOTE_FIELD_NAMES",
+        "new": "field com.fasterxml.jackson.core.json.JsonWriteFeature.QUOTE_FIELD_NAMES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonWriteFeature.WRITE_NAN_AS_STRINGS",
+        "new": "field com.fasterxml.jackson.core.json.JsonWriteFeature.WRITE_NAN_AS_STRINGS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.core.json.JsonWriteFeature.WRITE_NUMBERS_AS_STRINGS",
+        "new": "field com.fasterxml.jackson.core.json.JsonWriteFeature.WRITE_NUMBERS_AS_STRINGS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer._intern",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method void com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::_reportTooManyCollisions()",
+        "new": "method void com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::_reportTooManyCollisions() throws com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "exception": "com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method java.lang.String com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::addName(java.lang.String, int)",
+        "new": "method java.lang.String com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::addName(java.lang.String, int) throws com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "exception": "com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method java.lang.String com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::addName(java.lang.String, int, int)",
+        "new": "method java.lang.String com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::addName(java.lang.String, int, int) throws com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "exception": "com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method java.lang.String com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::addName(java.lang.String, int, int, int)",
+        "new": "method java.lang.String com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::addName(java.lang.String, int, int, int) throws com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "exception": "com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method java.lang.String com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::addName(java.lang.String, int[], int)",
+        "new": "method java.lang.String com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer::addName(java.lang.String, int[], int) throws com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "exception": "com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer._flags",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method void com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer::_reportTooManyCollisions(int)",
+        "new": "method void com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer::_reportTooManyCollisions(int) throws com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "exception": "com.fasterxml.jackson.core.exc.StreamConstraintsException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.visibilityIncreased",
+        "old": "method com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer::createRoot(int)",
+        "new": "method com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer::createRoot(int)",
+        "oldVisibility": "protected",
+        "newVisibility": "public",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method java.lang.String com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer::findSymbol(char[], int, int, int)",
+        "new": "method java.lang.String com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer::findSymbol(char[], int, int, int) throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.serialVersionUIDUnchanged",
+        "old": "field com.fasterxml.jackson.core.util.Separators.serialVersionUID",
+        "new": "field com.fasterxml.jackson.core.util.Separators.serialVersionUID",
+        "serialVersionUID": "1",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method void com.fasterxml.jackson.core.util.TextBuffer::append(char)",
+        "new": "method void com.fasterxml.jackson.core.util.TextBuffer::append(char) throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method void com.fasterxml.jackson.core.util.TextBuffer::append(char[], int, int)",
+        "new": "method void com.fasterxml.jackson.core.util.TextBuffer::append(char[], int, int) throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method void com.fasterxml.jackson.core.util.TextBuffer::append(java.lang.String, int, int)",
+        "new": "method void com.fasterxml.jackson.core.util.TextBuffer::append(java.lang.String, int, int) throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method char[] com.fasterxml.jackson.core.util.TextBuffer::contentsAsArray()",
+        "new": "method char[] com.fasterxml.jackson.core.util.TextBuffer::contentsAsArray() throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method java.lang.String com.fasterxml.jackson.core.util.TextBuffer::contentsAsString()",
+        "new": "method java.lang.String com.fasterxml.jackson.core.util.TextBuffer::contentsAsString() throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method char[] com.fasterxml.jackson.core.util.TextBuffer::finishCurrentSegment()",
+        "new": "method char[] com.fasterxml.jackson.core.util.TextBuffer::finishCurrentSegment() throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method char[] com.fasterxml.jackson.core.util.TextBuffer::getTextBuffer()",
+        "new": "method char[] com.fasterxml.jackson.core.util.TextBuffer::getTextBuffer() throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method void com.fasterxml.jackson.core.util.TextBuffer::resetWithCopy(char[], int, int)",
+        "new": "method void com.fasterxml.jackson.core.util.TextBuffer::resetWithCopy(char[], int, int) throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method void com.fasterxml.jackson.core.util.TextBuffer::resetWithCopy(java.lang.String, int, int)",
+        "new": "method void com.fasterxml.jackson.core.util.TextBuffer::resetWithCopy(java.lang.String, int, int) throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method void com.fasterxml.jackson.core.util.TextBuffer::resetWithString(java.lang.String)",
+        "new": "method void com.fasterxml.jackson.core.util.TextBuffer::resetWithString(java.lang.String) throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method java.lang.String com.fasterxml.jackson.core.util.TextBuffer::setCurrentAndReturn(int)",
+        "new": "method java.lang.String com.fasterxml.jackson.core.util.TextBuffer::setCurrentAndReturn(int) throws java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.Class<?> com.fasterxml.jackson.databind.AnnotationIntrospector::findDeserializationContentType(com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.Class<?> com.fasterxml.jackson.databind.AnnotationIntrospector::findDeserializationKeyType(com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.Class<?> com.fasterxml.jackson.databind.AnnotationIntrospector::findDeserializationType(com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.Boolean com.fasterxml.jackson.databind.AnnotationIntrospector::findIgnoreUnknownProperties(com.fasterxml.jackson.databind.introspect.AnnotatedClass)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.String[] com.fasterxml.jackson.databind.AnnotationIntrospector::findPropertiesToIgnore(com.fasterxml.jackson.databind.introspect.Annotated, boolean)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.Class<?> com.fasterxml.jackson.databind.AnnotationIntrospector::findSerializationContentType(com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.annotation.JsonInclude.Include com.fasterxml.jackson.databind.AnnotationIntrospector::findSerializationInclusion(com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.annotation.JsonInclude.Include)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.annotation.JsonInclude.Include com.fasterxml.jackson.databind.AnnotationIntrospector::findSerializationInclusionForContent(com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.annotation.JsonInclude.Include)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.Class<?> com.fasterxml.jackson.databind.AnnotationIntrospector::findSerializationKeyType(com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.Class<?> com.fasterxml.jackson.databind.AnnotationIntrospector::findSerializationType(com.fasterxml.jackson.databind.introspect.Annotated)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.class.defaultSerializationChanged",
+        "old": "class com.fasterxml.jackson.databind.AnnotationIntrospector",
+        "new": "class com.fasterxml.jackson.databind.AnnotationIntrospector",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.type.TypeBindings com.fasterxml.jackson.databind.BeanDescription::bindingsForBeanType()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.introspect.AnnotatedMethod com.fasterxml.jackson.databind.BeanDescription::findAnySetter()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.introspect.AnnotatedMember com.fasterxml.jackson.databind.BeanDescription::findAnySetterField()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.util.Map<java.lang.String, com.fasterxml.jackson.databind.introspect.AnnotatedMember> com.fasterxml.jackson.databind.BeanDescription::findBackReferenceProperties()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method com.fasterxml.jackson.annotation.JsonFormat.Value com.fasterxml.jackson.databind.BeanDescription::findExpectedFormat()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.reflect.Method com.fasterxml.jackson.databind.BeanDescription::findFactoryMethod(java.lang.Class<?>[])",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.introspect.AnnotatedMethod com.fasterxml.jackson.databind.BeanDescription::findJsonValueMethod()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.lang.reflect.Constructor<?> com.fasterxml.jackson.databind.BeanDescription::findSingleArgConstructor(java.lang.Class<?>[])",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method com.fasterxml.jackson.databind.introspect.PotentialCreators com.fasterxml.jackson.databind.BeanDescription::getPotentialCreators()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.JavaType com.fasterxml.jackson.databind.BeanDescription::resolveType(java.lang.reflect.Type)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method com.fasterxml.jackson.databind.cfg.DatatypeFeatures com.fasterxml.jackson.databind.DatabindContext::getDatatypeFeatures()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method boolean com.fasterxml.jackson.databind.DatabindContext::isEnabled(com.fasterxml.jackson.databind.cfg.DatatypeFeature)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method <T> T com.fasterxml.jackson.databind.DatabindContext::reportBadTypeDefinition(com.fasterxml.jackson.databind.BeanDescription, java.lang.String, java.lang.Object[]) throws com.fasterxml.jackson.databind.JsonMappingException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.serialVersionUIDUnchanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationConfig.serialVersionUID",
+        "new": "field com.fasterxml.jackson.databind.DeserializationConfig.serialVersionUID",
+        "serialVersionUID": "2",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.databind.DeserializationConfig::<init>(com.fasterxml.jackson.databind.DeserializationConfig, com.fasterxml.jackson.databind.introspect.SimpleMixInResolver, com.fasterxml.jackson.databind.util.RootNameLookup, com.fasterxml.jackson.databind.cfg.ConfigOverrides)",
+        "new": "method void com.fasterxml.jackson.databind.DeserializationConfig::<init>(com.fasterxml.jackson.databind.DeserializationConfig, com.fasterxml.jackson.databind.cfg.DatatypeFeatures)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.databind.DeserializationConfig::<init>(com.fasterxml.jackson.databind.cfg.BaseSettings, com.fasterxml.jackson.databind.jsontype.SubtypeResolver, com.fasterxml.jackson.databind.introspect.SimpleMixInResolver, com.fasterxml.jackson.databind.util.RootNameLookup, com.fasterxml.jackson.databind.cfg.ConfigOverrides)",
+        "new": "method void com.fasterxml.jackson.databind.DeserializationConfig::<init>(com.fasterxml.jackson.databind.cfg.BaseSettings, com.fasterxml.jackson.databind.jsontype.SubtypeResolver, com.fasterxml.jackson.databind.introspect.SimpleMixInResolver, com.fasterxml.jackson.databind.util.RootNameLookup, com.fasterxml.jackson.databind.cfg.ConfigOverrides, com.fasterxml.jackson.databind.cfg.CoercionConfigs, com.fasterxml.jackson.databind.cfg.DatatypeFeatures)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.DeserializationConfig::<init>(com.fasterxml.jackson.databind.cfg.BaseSettings, com.fasterxml.jackson.databind.jsontype.SubtypeResolver, com.fasterxml.jackson.databind.introspect.SimpleMixInResolver, com.fasterxml.jackson.databind.util.RootNameLookup, com.fasterxml.jackson.databind.cfg.ConfigOverrides, com.fasterxml.jackson.databind.cfg.CoercionConfigs)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.DeserializationConfig::introspectForBuilder(com.fasterxml.jackson.databind.JavaType)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.databind.DeserializationContext::<init>(com.fasterxml.jackson.databind.deser.DeserializerFactory)",
+        "new": "method void com.fasterxml.jackson.databind.DeserializationContext::<init>(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.deser.DeserializerCache)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.JsonMappingException com.fasterxml.jackson.databind.DeserializationContext::endOfInputException(java.lang.Class<?>)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method java.lang.Object com.fasterxml.jackson.databind.DeserializationContext::findInjectableValue(java.lang.Object, com.fasterxml.jackson.databind.BeanProperty, java.lang.Object, java.lang.Boolean, java.lang.Boolean) throws com.fasterxml.jackson.databind.JsonMappingException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method com.fasterxml.jackson.databind.cfg.DatatypeFeatures com.fasterxml.jackson.databind.DeserializationContext::getDatatypeFeatures()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.text.DateFormat com.fasterxml.jackson.databind.DeserializationContext::getDateFormat()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method boolean com.fasterxml.jackson.databind.DeserializationContext::isEnabled(com.fasterxml.jackson.databind.cfg.DatatypeFeature)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.JsonMappingException com.fasterxml.jackson.databind.DeserializationContext::mappingException(java.lang.Class<?>)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.JsonMappingException com.fasterxml.jackson.databind.DeserializationContext::mappingException(java.lang.Class<?>, com.fasterxml.jackson.core.JsonToken)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.JsonMappingException com.fasterxml.jackson.databind.DeserializationContext::mappingException(java.lang.String)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.JsonMappingException com.fasterxml.jackson.databind.DeserializationContext::mappingException(java.lang.String, java.lang.Object[])",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method <T> T com.fasterxml.jackson.databind.DeserializationContext::reportBadMerge(com.fasterxml.jackson.databind.JsonDeserializer<?>) throws com.fasterxml.jackson.databind.JsonMappingException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.DeserializationContext::reportMappingException(java.lang.String, java.lang.Object[]) throws com.fasterxml.jackson.databind.JsonMappingException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.DeserializationContext::reportMissingContent(java.lang.String, java.lang.Object[]) throws com.fasterxml.jackson.databind.JsonMappingException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.DeserializationContext::reportUnknownProperty(java.lang.Object, java.lang.String, com.fasterxml.jackson.databind.JsonDeserializer<?>) throws com.fasterxml.jackson.databind.JsonMappingException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.DeserializationContext::reportWrongTokenException(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.JsonToken, java.lang.String, java.lang.Object[]) throws com.fasterxml.jackson.databind.JsonMappingException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.JsonMappingException com.fasterxml.jackson.databind.DeserializationContext::unknownTypeException(com.fasterxml.jackson.databind.JavaType, java.lang.String, java.lang.String)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.JsonMappingException com.fasterxml.jackson.databind.DeserializationContext::wrongTokenException(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.JsonToken, java.lang.String)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_FLOAT_AS_INT",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_FLOAT_AS_INT",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.EAGER_DESERIALIZER_FETCH",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.EAGER_DESERIALIZER_FETCH",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.READ_ENUMS_USING_TO_STRING",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.READ_ENUMS_USING_TO_STRING",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.UNWRAP_ROOT_VALUE",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.UNWRAP_ROOT_VALUE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.DeserializationFeature.WRAP_EXCEPTIONS",
+        "new": "field com.fasterxml.jackson.databind.DeserializationFeature.WRAP_EXCEPTIONS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method com.fasterxml.jackson.databind.node.ArrayNode com.fasterxml.jackson.databind.JsonNode::withArray(com.fasterxml.jackson.core.JsonPointer)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method com.fasterxml.jackson.databind.node.ObjectNode com.fasterxml.jackson.databind.JsonNode::withObject(com.fasterxml.jackson.core.JsonPointer)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method com.fasterxml.jackson.databind.node.ObjectNode com.fasterxml.jackson.databind.JsonNode::withObject(java.lang.String, com.fasterxml.jackson.databind.JsonNode.OverwriteMode, boolean)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_VALUES",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_VALUES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_COERCION_OF_SCALARS",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_COERCION_OF_SCALARS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_EXPLICIT_PROPERTY_RENAMING",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_EXPLICIT_PROPERTY_RENAMING",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_VOID_VALUED_PROPERTIES",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_VOID_VALUED_PROPERTIES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.APPLY_DEFAULT_VALUES",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.APPLY_DEFAULT_VALUES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.DEFAULT_VIEW_INCLUSION",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.DEFAULT_VIEW_INCLUSION",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.IGNORE_MERGE_FOR_UNMERGEABLE",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.IGNORE_MERGE_FOR_UNMERGEABLE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.INFER_BUILDER_TYPE_BINDINGS",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.INFER_BUILDER_TYPE_BINDINGS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.SORT_CREATOR_PROPERTIES_FIRST",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.SORT_CREATOR_PROPERTIES_FIRST",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[]) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[]) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(int) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT extends com.datastax.oss.driver.api.core.cql.Bindable<SelfT>>>::unset(java.lang.String) @ com.datastax.oss.driver.api.core.cql.BoundStatementBuilder",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[]) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[]) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::copy(java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setCustomPayload(java.util.Map<java.lang.String, java.nio.ByteBuffer>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfile(com.datastax.oss.driver.api.core.config.DriverExecutionProfile)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setExecutionProfileName(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setIdempotent(java.lang.Boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setNode(com.datastax.oss.driver.api.core.metadata.Node)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPageSize(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setPagingState(java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[])",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKey(java.nio.ByteBuffer[])",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingKeyspace(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setRoutingToken(com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setSerialConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTimeout(java.time.Duration)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setTracing(boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>)",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>)",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>)",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>)",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.data.TupleValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::set(com.datastax.oss.driver.api.core.CqlIdentifier, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::set(int, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.codec.TypeCodec<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, com.datastax.oss.driver.api.core.type.reflect.GenericType<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::set(java.lang.String, ValueT, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigDecimal(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigDecimal(int, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigDecimal(java.lang.String, java.math.BigDecimal) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBigInteger(com.datastax.oss.driver.api.core.CqlIdentifier, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBigInteger(int, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBigInteger(java.lang.String, java.math.BigInteger) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBoolean(com.datastax.oss.driver.api.core.CqlIdentifier, boolean) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBoolean(int, boolean) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBoolean(java.lang.String, boolean) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByte(com.datastax.oss.driver.api.core.CqlIdentifier, byte) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByte(int, byte) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByte(java.lang.String, byte) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setByteBuffer(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setByteBuffer(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setByteBuffer(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setBytesUnsafe(com.datastax.oss.driver.api.core.CqlIdentifier, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setBytesUnsafe(int, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setBytesUnsafe(java.lang.String, java.nio.ByteBuffer) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setCqlDuration(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setCqlDuration(int, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setCqlDuration(java.lang.String, com.datastax.oss.driver.api.core.data.CqlDuration) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setDouble(com.datastax.oss.driver.api.core.CqlIdentifier, double) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setDouble(int, double) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setDouble(java.lang.String, double) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setFloat(com.datastax.oss.driver.api.core.CqlIdentifier, float) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setFloat(int, float) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setFloat(java.lang.String, float) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInetAddress(com.datastax.oss.driver.api.core.CqlIdentifier, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInetAddress(int, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInetAddress(java.lang.String, java.net.InetAddress) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInstant(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.Instant) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInstant(int, java.time.Instant) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInstant(java.lang.String, java.time.Instant) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setInt(com.datastax.oss.driver.api.core.CqlIdentifier, int) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setInt(int, int) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setInt(java.lang.String, int) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setList(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setList(int, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setList(java.lang.String, java.util.List<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalDate(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalDate(int, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalDate(java.lang.String, java.time.LocalDate) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLocalTime(com.datastax.oss.driver.api.core.CqlIdentifier, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLocalTime(int, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLocalTime(java.lang.String, java.time.LocalTime) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setLong(com.datastax.oss.driver.api.core.CqlIdentifier, long) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setLong(int, long) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setLong(java.lang.String, long) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setMap(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setMap(int, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <KeyT, ValueT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setMap(java.lang.String, java.util.Map<KeyT, ValueT>, java.lang.Class<KeyT>, java.lang.Class<ValueT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setSet(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setSet(int, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setSet(java.lang.String, java.util.Set<ElementT>, java.lang.Class<ElementT>) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setShort(com.datastax.oss.driver.api.core.CqlIdentifier, short) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setShort(int, short) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setShort(java.lang.String, short) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setString(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.String) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setString(int, java.lang.String) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setString(java.lang.String, java.lang.String) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToNull(com.datastax.oss.driver.api.core.CqlIdentifier) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToNull(int) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToNull(java.lang.String) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setToken(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setToken(int, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setToken(java.lang.String, com.datastax.oss.driver.api.core.metadata.token.Token) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setTupleValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setTupleValue(int, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setTupleValue(java.lang.String, com.datastax.oss.driver.api.core.data.TupleValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUdtValue(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUdtValue(int, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUdtValue(java.lang.String, com.datastax.oss.driver.api.core.data.UdtValue) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>>::setUuid(com.datastax.oss.driver.api.core.CqlIdentifier, java.util.UUID) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>>::setUuid(int, java.util.UUID) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "new": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>>::setUuid(java.lang.String, java.util.UUID) @ com.datastax.oss.driver.api.core.data.UdtValue",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Add missing `@NonNull` annotation to Statement.setConsistencyLevel"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Add missing `@NonNull` annotation to Statement.setConsistencyLevel"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Add missing `@NonNull` annotation to Statement.setConsistencyLevel"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Add missing `@NonNull` annotation to Statement.setConsistencyLevel"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>>::setConsistencyLevel(com.datastax.oss.driver.api.core.ConsistencyLevel)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Add missing `@NonNull` annotation to Statement.setConsistencyLevel"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT>> com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT>::fetchNextPage() throws java.lang.IllegalStateException",
-        "new": "method java.util.concurrent.CompletionStage<SelfT> com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT, SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT extends java.lang.Object, SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT, SelfT>>>::fetchNextPage() throws java.lang.IllegalStateException",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeChangedCovariantly",
-        "old": "method <TargetT> com.datastax.oss.driver.api.core.AsyncPagingIterable<TargetT> com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT>::map(java.util.function.Function<? super ElementT, ? extends TargetT>)",
-        "new": "method <TargetT> com.datastax.oss.driver.api.core.MappedAsyncPagingIterable<TargetT> com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT, SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT extends java.lang.Object, SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT, SelfT>>>::map(java.util.function.Function<? super ElementT, ? extends TargetT>)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.generics.formalTypeParameterAdded",
-        "old": "interface com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT extends java.lang.Object>",
-        "new": "interface com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT extends java.lang.Object, SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT, SelfT>>",
-        "typeParameter": "SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT extends java.lang.Object, SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT, SelfT>>",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.cql.AsyncResultSet> com.datastax.oss.driver.api.core.CqlSession::executeAsync(com.datastax.oss.driver.api.core.cql.Statement<?>)",
-        "new": "method java.util.concurrent.CompletionStage<com.datastax.oss.driver.api.core.cql.AsyncResultSet> com.datastax.oss.driver.api.core.CqlSession::executeAsync(com.datastax.oss.driver.api.core.cql.Statement<?>)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.cql.AsyncResultSet> com.datastax.oss.driver.api.core.CqlSession::executeAsync(java.lang.String)",
-        "new": "method java.util.concurrent.CompletionStage<com.datastax.oss.driver.api.core.cql.AsyncResultSet> com.datastax.oss.driver.api.core.CqlSession::executeAsync(java.lang.String)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.cql.PreparedStatement> com.datastax.oss.driver.api.core.CqlSession::prepareAsync(com.datastax.oss.driver.api.core.cql.PrepareRequest)",
-        "new": "method java.util.concurrent.CompletionStage<com.datastax.oss.driver.api.core.cql.PreparedStatement> com.datastax.oss.driver.api.core.CqlSession::prepareAsync(com.datastax.oss.driver.api.core.cql.PrepareRequest)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.cql.PreparedStatement> com.datastax.oss.driver.api.core.CqlSession::prepareAsync(com.datastax.oss.driver.api.core.cql.SimpleStatement)",
-        "new": "method java.util.concurrent.CompletionStage<com.datastax.oss.driver.api.core.cql.PreparedStatement> com.datastax.oss.driver.api.core.CqlSession::prepareAsync(com.datastax.oss.driver.api.core.cql.SimpleStatement)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.cql.PreparedStatement> com.datastax.oss.driver.api.core.CqlSession::prepareAsync(java.lang.String)",
-        "new": "method java.util.concurrent.CompletionStage<com.datastax.oss.driver.api.core.cql.PreparedStatement> com.datastax.oss.driver.api.core.CqlSession::prepareAsync(java.lang.String)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.cql.AsyncResultSet> com.datastax.oss.driver.api.core.cql.AsyncResultSet::fetchNextPage() throws java.lang.IllegalStateException",
-        "new": "method java.util.concurrent.CompletionStage<SelfT> com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT, SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT extends java.lang.Object, SelfT extends com.datastax.oss.driver.api.core.AsyncPagingIterable<ElementT, SelfT>>>::fetchNextPage() throws java.lang.IllegalStateException @ com.datastax.oss.driver.api.core.cql.AsyncResultSet",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.class.noLongerImplementsInterface",
-        "old": "interface com.datastax.oss.driver.api.core.cql.AsyncResultSet",
-        "new": "interface com.datastax.oss.driver.api.core.cql.AsyncResultSet",
-        "interface": "com.datastax.oss.driver.api.core.AsyncPagingIterable<com.datastax.oss.driver.api.core.cql.Row>",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.class.superTypeTypeParametersChanged",
-        "old": "interface com.datastax.oss.driver.api.core.cql.AsyncResultSet",
-        "new": "interface com.datastax.oss.driver.api.core.cql.AsyncResultSet",
-        "oldSuperType": "com.datastax.oss.driver.api.core.AsyncPagingIterable<com.datastax.oss.driver.api.core.cql.Row>",
-        "newSuperType": "com.datastax.oss.driver.api.core.AsyncPagingIterable<com.datastax.oss.driver.api.core.cql.Row, com.datastax.oss.driver.api.core.cql.AsyncResultSet>",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.metadata.Metadata> com.datastax.oss.driver.api.core.session.Session::refreshSchemaAsync()",
-        "new": "method java.util.concurrent.CompletionStage<com.datastax.oss.driver.api.core.metadata.Metadata> com.datastax.oss.driver.api.core.session.Session::refreshSchemaAsync()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.concurrent.CompletionStage<? extends com.datastax.oss.driver.api.core.metadata.Metadata> com.datastax.oss.driver.api.core.session.Session::setSchemaMetadataEnabled(java.lang.Boolean)",
-        "new": "method java.util.concurrent.CompletionStage<com.datastax.oss.driver.api.core.metadata.Metadata> com.datastax.oss.driver.api.core.session.Session::setSchemaMetadataEnabled(java.lang.Boolean)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metrics.Metrics> com.datastax.oss.driver.api.core.session.Session::getMetrics()",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metrics.Metrics> com.datastax.oss.driver.api.core.session.Session::getMetrics()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata> com.datastax.oss.driver.api.core.metadata.Metadata::getKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata> com.datastax.oss.driver.api.core.metadata.Metadata::getKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata> com.datastax.oss.driver.api.core.metadata.Metadata::getKeyspace(java.lang.String)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata> com.datastax.oss.driver.api.core.metadata.Metadata::getKeyspace(java.lang.String)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, ? extends com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata> com.datastax.oss.driver.api.core.metadata.Metadata::getKeyspaces()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata> com.datastax.oss.driver.api.core.metadata.Metadata::getKeyspaces()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.TokenMap> com.datastax.oss.driver.api.core.metadata.Metadata::getTokenMap()",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.TokenMap> com.datastax.oss.driver.api.core.metadata.Metadata::getTokenMap()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.type.DataType[])",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.type.DataType[])",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Iterable<com.datastax.oss.driver.api.core.type.DataType>)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Iterable<com.datastax.oss.driver.api.core.type.DataType>)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(com.datastax.oss.driver.api.core.metadata.schema.FunctionSignature)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(com.datastax.oss.driver.api.core.metadata.schema.FunctionSignature)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(java.lang.String, com.datastax.oss.driver.api.core.type.DataType[])",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(java.lang.String, com.datastax.oss.driver.api.core.type.DataType[])",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(java.lang.String, java.lang.Iterable<com.datastax.oss.driver.api.core.type.DataType>)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregate(java.lang.String, java.lang.Iterable<com.datastax.oss.driver.api.core.type.DataType>)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.metadata.schema.FunctionSignature, ? extends com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregates()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.metadata.schema.FunctionSignature, com.datastax.oss.driver.api.core.metadata.schema.AggregateMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getAggregates()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.type.DataType[])",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.type.DataType[])",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Iterable<com.datastax.oss.driver.api.core.type.DataType>)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Iterable<com.datastax.oss.driver.api.core.type.DataType>)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(com.datastax.oss.driver.api.core.metadata.schema.FunctionSignature)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(com.datastax.oss.driver.api.core.metadata.schema.FunctionSignature)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(java.lang.String, com.datastax.oss.driver.api.core.type.DataType[])",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(java.lang.String, com.datastax.oss.driver.api.core.type.DataType[])",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(java.lang.String, java.lang.Iterable<com.datastax.oss.driver.api.core.type.DataType>)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunction(java.lang.String, java.lang.Iterable<com.datastax.oss.driver.api.core.type.DataType>)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.metadata.schema.FunctionSignature, ? extends com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunctions()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.metadata.schema.FunctionSignature, com.datastax.oss.driver.api.core.metadata.schema.FunctionMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getFunctions()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.TableMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getTable(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.TableMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getTable(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.TableMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getTable(java.lang.String)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.TableMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getTable(java.lang.String)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, ? extends com.datastax.oss.driver.api.core.metadata.schema.TableMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getTables()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.TableMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getTables()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.type.UserDefinedType> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getUserDefinedType(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.type.UserDefinedType> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getUserDefinedType(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.type.UserDefinedType> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getUserDefinedType(java.lang.String)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.type.UserDefinedType> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getUserDefinedType(java.lang.String)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, ? extends com.datastax.oss.driver.api.core.type.UserDefinedType> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getUserDefinedTypes()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.type.UserDefinedType> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getUserDefinedTypes()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.ViewMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getView(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.ViewMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getView(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.ViewMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getView(java.lang.String)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.ViewMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getView(java.lang.String)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, ? extends com.datastax.oss.driver.api.core.metadata.schema.ViewMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getViews()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ViewMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getViews()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, ? extends com.datastax.oss.driver.api.core.metadata.schema.ViewMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getViewsOnTable(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ViewMetadata> com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata::getViewsOnTable(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<? extends com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getClusteringColumns()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getClusteringColumns()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getColumn(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getColumn(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Optional<? extends com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getColumn(java.lang.String)",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getColumn(java.lang.String)",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, ? extends com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getColumns()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getColumns()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.List<? extends com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getPartitionKey()",
-        "new": "method java.util.List<com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getPartitionKey()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.List<? extends com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getPrimaryKey()",
-        "new": "method java.util.List<com.datastax.oss.driver.api.core.metadata.schema.ColumnMetadata> com.datastax.oss.driver.api.core.metadata.schema.RelationMetadata::getPrimaryKey()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, ? extends com.datastax.oss.driver.api.core.metadata.schema.IndexMetadata> com.datastax.oss.driver.api.core.metadata.schema.TableMetadata::getIndexes()",
-        "new": "method java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.IndexMetadata> com.datastax.oss.driver.api.core.metadata.schema.TableMetadata::getIndexes()",
-        "justification": "JAVA-2192: Don't return generic types with wildcards"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.config.DriverExecutionProfile com.datastax.oss.driver.api.core.config.DriverExecutionProfile::withLong(com.datastax.oss.driver.api.core.config.DriverOption, long)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.config.OngoingConfigOptions<SelfT extends com.datastax.oss.driver.api.core.config.OngoingConfigOptions<SelfT extends com.datastax.oss.driver.api.core.config.OngoingConfigOptions<SelfT>>>::withLong(com.datastax.oss.driver.api.core.config.DriverOption, long) @ com.datastax.oss.driver.api.core.config.DriverExecutionProfile",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Bugfix, the annotation should have been present from the beginning"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method java.lang.String com.datastax.oss.driver.api.core.metadata.EndPoint::asMetricPrefix()",
-        "new": "method java.lang.String com.datastax.oss.driver.api.core.metadata.EndPoint::asMetricPrefix()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "EndPoint.asMetricPrefix() was missing @NonNull"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method java.net.SocketAddress com.datastax.oss.driver.api.core.metadata.EndPoint::resolve()",
-        "new": "method java.net.SocketAddress com.datastax.oss.driver.api.core.metadata.EndPoint::resolve()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "EndPoint.resolve() was missing @NonNull"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method java.util.UUID com.datastax.oss.driver.api.core.metadata.Node::getHostId()",
-        "new": "method java.util.UUID com.datastax.oss.driver.api.core.metadata.Node::getHostId()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Node.getHostId() should have been annotated with @NonNull"
-      },
-      {
-        "code": "java.annotation.removed",
-        "old": "method java.util.UUID com.datastax.oss.driver.api.core.metadata.Node::getHostId()",
-        "new": "method java.util.UUID com.datastax.oss.driver.api.core.metadata.Node::getHostId()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.Nullable",
-        "justification": "Node.getHostId() should have been annotated with @NonNull"
-      },
-      {
-        "code": "java.field.removed",
-        "old": "field com.datastax.oss.driver.api.core.session.SessionBuilder<SelfT extends com.datastax.oss.driver.api.core.session.SessionBuilder, SessionT>.requestTracker",
-        "justification": "JAVA-2315: Improve extensibility of session builder"
-      },
-      {
-        "code": "java.field.removed",
-        "old": "field com.datastax.oss.driver.api.core.session.SessionBuilder<SelfT extends com.datastax.oss.driver.api.core.session.SessionBuilder, SessionT>.typeCodecs",
-        "justification": "JAVA-2315: Improve extensibility of session builder"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <TargetElementT> com.datastax.oss.driver.api.core.PagingIterable<TargetElementT> com.datastax.oss.driver.api.core.PagingIterable<ElementT>::map(java.util.function.Function<? super ElementT, ? extends TargetElementT>)",
-        "new": "method <TargetElementT> com.datastax.oss.driver.api.core.PagingIterable<TargetElementT> com.datastax.oss.driver.api.core.PagingIterable<ElementT>::map(java.util.function.Function<? super ElementT, ? extends TargetElementT>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "PagingIterable.map() should have been annotated with @NonNull"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method <TargetElementT> com.datastax.oss.driver.api.core.PagingIterable<TargetElementT> com.datastax.oss.driver.api.core.PagingIterable<ElementT>::map(java.util.function.Function<? super ElementT, ? extends TargetElementT>) @ com.datastax.oss.driver.api.core.cql.ResultSet",
-        "new": "method <TargetElementT> com.datastax.oss.driver.api.core.PagingIterable<TargetElementT> com.datastax.oss.driver.api.core.PagingIterable<ElementT>::map(java.util.function.Function<? super ElementT, ? extends TargetElementT>) @ com.datastax.oss.driver.api.core.cql.ResultSet",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "PagingIterable.map() should have been annotated with @NonNull"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method java.util.Spliterator<T> java.lang.Iterable<T>::spliterator() @ com.datastax.oss.driver.api.core.PagingIterable<ElementT>",
-        "new": "method java.util.Spliterator<ElementT> com.datastax.oss.driver.api.core.PagingIterable<ElementT>::spliterator()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "JAVA-2247: PagingIterable implementations should implement spliterator()"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method java.util.Spliterator<T> java.lang.Iterable<T>::spliterator() @ com.datastax.oss.driver.api.core.cql.ResultSet",
-        "new": "method java.util.Spliterator<ElementT> com.datastax.oss.driver.api.core.PagingIterable<ElementT>::spliterator() @ com.datastax.oss.driver.api.core.cql.ResultSet",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "JAVA-2247: PagingIterable implementations should implement spliterator()"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method java.lang.String com.datastax.oss.driver.api.core.cql.Row::toString()",
-        "justification": "False positive -- all objects implicitly have toString()"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method java.lang.String com.datastax.oss.driver.api.core.data.TupleValue::toString()",
-        "justification": "False positive -- all objects implicitly have toString()"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method java.lang.String com.datastax.oss.driver.api.core.data.UdtValue::toString()",
-        "justification": "False positive -- all objects implicitly have toString()"
-      },
-      {
-        "regex": true,
-        "code": "java.annotation.added",
-        "old": "field com\\.datastax\\.oss\\.driver\\.api\\.core\\.Version.V.*",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Marking constants as non-null doesn't break existing code"
-      },
-      {
-        "code": "java.annotation.removed",
-        "old": "method java.util.UUID com.datastax.oss.driver.api.core.metadata.Node::getHostId()",
-        "new": "method java.util.UUID com.datastax.oss.driver.api.core.metadata.Node::getHostId()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "JAVA-2505: Annotate Node.getHostId() as nullable"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method java.util.UUID com.datastax.oss.driver.api.core.metadata.Node::getHostId()",
-        "new": "method java.util.UUID com.datastax.oss.driver.api.core.metadata.Node::getHostId()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.Nullable",
-        "justification": "JAVA-2505: Annotate Node.getHostId() as nullable"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "parameter void com.datastax.oss.driver.api.core.ssl.ProgrammaticSslEngineFactory::<init>(===javax.net.ssl.SSLContext===)",
-        "new": "parameter void com.datastax.oss.driver.api.core.ssl.ProgrammaticSslEngineFactory::<init>(===javax.net.ssl.SSLContext===)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "JAVA-2434: added @NonNull to ProgrammaticSslEngineFactory(SSLContext) constructor"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.datastax.oss.driver.api.core.auth.PlainTextAuthProviderBase.PlainTextAuthenticator",
-        "new": "class com.datastax.oss.driver.api.core.auth.PlainTextAuthProviderBase.PlainTextAuthenticator",
-        "superClass": "com.datastax.dse.driver.api.core.auth.BaseDseAuthenticator",
-        "justification": "New parent doesn't add constraints for implementors"
-      },
-      {
-        "code": "java.method.exception.runtimeAdded",
-        "old": "method com.datastax.oss.driver.api.core.auth.Authenticator com.datastax.oss.driver.api.core.auth.PlainTextAuthProviderBase::newAuthenticator(com.datastax.oss.driver.api.core.metadata.EndPoint, java.lang.String)",
-        "new": "method com.datastax.oss.driver.api.core.auth.Authenticator com.datastax.oss.driver.api.core.auth.PlainTextAuthProviderBase::newAuthenticator(com.datastax.oss.driver.api.core.metadata.EndPoint, java.lang.String) throws com.datastax.oss.driver.api.core.auth.AuthenticationException",
-        "exception": "com.datastax.oss.driver.api.core.auth.AuthenticationException",
-        "justification": "New exception is unchecked"
-      },
-      {
-        "code": "java.class.superTypeTypeParametersChanged",
-        "old": "class com.datastax.dse.driver.api.core.DseSessionBuilderBase<SelfT extends com.datastax.oss.driver.api.core.session.SessionBuilder, SessionT extends java.lang.Object>",
-        "new": "class com.datastax.dse.driver.api.core.DseSessionBuilderBase<SelfT extends com.datastax.dse.driver.api.core.DseSessionBuilderBase<SelfT, SessionT extends java.lang.Object>, SessionT>",
-        "oldSuperType": "com.datastax.oss.driver.api.core.session.SessionBuilder<SelfT extends com.datastax.oss.driver.api.core.session.SessionBuilder, SessionT extends java.lang.Object>",
-        "newSuperType": "com.datastax.oss.driver.api.core.session.SessionBuilder<SelfT extends com.datastax.dse.driver.api.core.DseSessionBuilderBase<SelfT, SessionT extends java.lang.Object>, SessionT>",
-        "justification": "JAVA-2411: Type parameters were wrong but it is unlikely that implementors would notice that in subclasses"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method <E> org.apache.tinkerpop.gremlin.process.remote.traversal.RemoteTraversal<?, E> org.apache.tinkerpop.gremlin.process.remote.RemoteConnection::submit(org.apache.tinkerpop.gremlin.process.traversal.Bytecode) throws org.apache.tinkerpop.gremlin.process.remote.RemoteConnectionException",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method <E> java.util.Iterator<org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<E>> org.apache.tinkerpop.gremlin.process.remote.RemoteConnection::submit(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?, E>) throws org.apache.tinkerpop.gremlin.process.remote.RemoteConnectionException",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.noLongerDefault",
-        "old": "method <E> java.util.concurrent.CompletableFuture<org.apache.tinkerpop.gremlin.process.remote.traversal.RemoteTraversal<?, E>> org.apache.tinkerpop.gremlin.process.remote.RemoteConnection::submitAsync(org.apache.tinkerpop.gremlin.process.traversal.Bytecode) throws org.apache.tinkerpop.gremlin.process.remote.RemoteConnectionException",
-        "new": "method <E> java.util.concurrent.CompletableFuture<org.apache.tinkerpop.gremlin.process.remote.traversal.RemoteTraversal<?, E>> org.apache.tinkerpop.gremlin.process.remote.RemoteConnection::submitAsync(org.apache.tinkerpop.gremlin.process.traversal.Bytecode) throws org.apache.tinkerpop.gremlin.process.remote.RemoteConnectionException",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.nowAbstract",
-        "old": "method <E> java.util.concurrent.CompletableFuture<org.apache.tinkerpop.gremlin.process.remote.traversal.RemoteTraversal<?, E>> org.apache.tinkerpop.gremlin.process.remote.RemoteConnection::submitAsync(org.apache.tinkerpop.gremlin.process.traversal.Bytecode) throws org.apache.tinkerpop.gremlin.process.remote.RemoteConnectionException",
-        "new": "method <E> java.util.concurrent.CompletableFuture<org.apache.tinkerpop.gremlin.process.remote.traversal.RemoteTraversal<?, E>> org.apache.tinkerpop.gremlin.process.remote.RemoteConnection::submitAsync(org.apache.tinkerpop.gremlin.process.traversal.Bytecode) throws org.apache.tinkerpop.gremlin.process.remote.RemoteConnectionException",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.field.removedWithConstant",
-        "old": "field org.apache.tinkerpop.gremlin.process.traversal.TraversalSource.GREMLIN_REMOTE",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.field.removedWithConstant",
-        "old": "field org.apache.tinkerpop.gremlin.process.traversal.TraversalSource.GREMLIN_REMOTE_CONNECTION_CLASS",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter java.util.List<org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy<?>> org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies::sortStrategies(===java.util.List<org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy<?>>===)",
-        "new": "parameter java.util.Set<org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy<?>> org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies::sortStrategies(===java.util.Set<org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy<?>>===)",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.returnTypeChanged",
-        "old": "method java.util.List<org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy<?>> org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies::sortStrategies(java.util.List<org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy<?>>)",
-        "new": "method java.util.Set<org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy<?>> org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies::sortStrategies(java.util.Set<org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy<?>>)",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.numberOfParametersChanged",
-        "old": "method void org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<T>::incrLoops(java.lang.String)",
-        "new": "method void org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<T>::incrLoops()",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method void org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<T>::initialiseLoops(java.lang.String, java.lang.String)",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method int org.apache.tinkerpop.gremlin.process.traversal.Traverser<T>::loops(java.lang.String)",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <E2 extends java.lang.Number> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::max()",
-        "new": "method <E2 extends java.lang.Comparable> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::max()",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <E2 extends java.lang.Number> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::max()",
-        "new": "method <E2 extends java.lang.Comparable> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::max()",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <E2 extends java.lang.Number> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::max(org.apache.tinkerpop.gremlin.process.traversal.Scope)",
-        "new": "method <E2 extends java.lang.Comparable> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::max(org.apache.tinkerpop.gremlin.process.traversal.Scope)",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <E2 extends java.lang.Number> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::max(org.apache.tinkerpop.gremlin.process.traversal.Scope)",
-        "new": "method <E2 extends java.lang.Comparable> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::max(org.apache.tinkerpop.gremlin.process.traversal.Scope)",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <E2 extends java.lang.Number> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::min()",
-        "new": "method <E2 extends java.lang.Comparable> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::min()",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <E2 extends java.lang.Number> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::min()",
-        "new": "method <E2 extends java.lang.Comparable> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::min()",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <E2 extends java.lang.Number> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::min(org.apache.tinkerpop.gremlin.process.traversal.Scope)",
-        "new": "method <E2 extends java.lang.Comparable> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::min(org.apache.tinkerpop.gremlin.process.traversal.Scope)",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <E2 extends java.lang.Number> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::min(org.apache.tinkerpop.gremlin.process.traversal.Scope)",
-        "new": "method <E2 extends java.lang.Comparable> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::min(org.apache.tinkerpop.gremlin.process.traversal.Scope)",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, java.util.Map<java.lang.String, E2>> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::valueMap(java.lang.String[])",
-        "new": "method <E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, java.util.Map<java.lang.Object, E2>> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S, E>::valueMap(java.lang.String[])",
-        "justification": "JAVA-2235: GraphBinary support - TinkerPop upgrade from 3.3 to 3.4"
-      },
-      {
-        "code": "java.class.externalClassExposedInAPI",
-        "new": "class org.apache.tinkerpop.gremlin.process.traversal.util.ImmutableExplanation",
-        "justification": "Upgrade to Tinkerpop 3.4.4"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation",
-        "new": "class org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation",
-        "superClass": "org.apache.tinkerpop.gremlin.process.traversal.util.AbstractExplanation",
-        "justification": "Upgrade to Tinkerpop 3.4.4"
-      },
-      {
-        "code": "java.class.defaultSerializationChanged",
-        "old": "class org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation",
-        "new": "class org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation",
-        "justification": "Upgrade to Tinkerpop 3.4.4"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "parameter int com.datastax.oss.driver.api.core.type.UserDefinedType::firstIndexOf(===com.datastax.oss.driver.api.core.CqlIdentifier===)",
-        "new": "parameter int com.datastax.oss.driver.api.core.type.UserDefinedType::firstIndexOf(===com.datastax.oss.driver.api.core.CqlIdentifier===)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Add missing `@NonNull` annotation to UserDefinedType.firstIndexOf"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "parameter int com.datastax.oss.driver.api.core.type.UserDefinedType::firstIndexOf(===java.lang.String===)",
-        "new": "parameter int com.datastax.oss.driver.api.core.type.UserDefinedType::firstIndexOf(===java.lang.String===)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Add missing `@NonNull` annotation to UserDefinedType.firstIndexOf"
-      },
-      {
-        "code": "java.class.nonPublicPartOfAPI",
-        "new": "class com.fasterxml.jackson.databind.introspect.AnnotatedConstructor.Serialization",
-        "justification": "Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonPublicPartOfAPI",
-        "new": "class com.fasterxml.jackson.databind.introspect.AnnotatedField.Serialization",
-        "justification": "Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonPublicPartOfAPI",
-        "new": "class com.fasterxml.jackson.databind.introspect.AnnotatedMethod.Serialization",
-        "justification": "Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonPublicPartOfAPI",
-        "new": "class com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer",
-        "justification": "Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonPublicPartOfAPI",
-        "new": "class com.fasterxml.jackson.databind.util.PrimitiveArrayBuilder.Node<T>",
-        "justification": "Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.annotation.JsonTypeInfo.Id.CUSTOM",
-        "new": "field com.fasterxml.jackson.annotation.JsonTypeInfo.Id.CUSTOM",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.serialVersionUIDUnchanged",
-        "old": "field com.fasterxml.jackson.core.Base64Variant.serialVersionUID",
-        "new": "field com.fasterxml.jackson.core.Base64Variant.serialVersionUID",
-        "serialVersionUID": "1",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.fasterxml.jackson.core.JsonGenerationException",
-        "new": "class com.fasterxml.jackson.core.JsonGenerationException",
-        "superClass": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.fasterxml.jackson.core.JsonParseException",
-        "new": "class com.fasterxml.jackson.core.JsonParseException",
-        "superClass": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "class com.fasterxml.jackson.core.JsonProcessingException",
-        "superClass": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonPublicPartOfAPI",
-        "old": "class com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer.TableInfo",
-        "new": "class com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer.TableInfo",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonPublicPartOfAPI",
-        "old": "class com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer.Bucket",
-        "new": "class com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer.Bucket",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonPublicPartOfAPI",
-        "old": "class com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer.TableInfo",
-        "new": "class com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer.TableInfo",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method java.lang.String[] com.fasterxml.jackson.databind.AnnotationIntrospector::findPropertiesToIgnore(com.fasterxml.jackson.databind.introspect.Annotated)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.defaultSerializationChanged",
-        "old": "class com.fasterxml.jackson.databind.AnnotationIntrospector",
-        "new": "class com.fasterxml.jackson.databind.AnnotationIntrospector",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.serialVersionUIDUnchanged",
-        "old": "field com.fasterxml.jackson.databind.DeserializationConfig.serialVersionUID",
-        "new": "field com.fasterxml.jackson.databind.DeserializationConfig.serialVersionUID",
-        "serialVersionUID": "2",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.returnTypeChanged",
-        "old": "method void com.fasterxml.jackson.databind.DeserializationConfig::initialize(com.fasterxml.jackson.core.JsonParser)",
-        "new": "method com.fasterxml.jackson.core.JsonParser com.fasterxml.jackson.databind.DeserializationConfig::initialize(com.fasterxml.jackson.core.JsonParser)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <T extends com.fasterxml.jackson.databind.BeanDescription> T com.fasterxml.jackson.databind.DeserializationConfig::introspect(com.fasterxml.jackson.databind.JavaType)",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.DeserializationConfig::introspect(com.fasterxml.jackson.databind.JavaType)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.generics.formalTypeParameterRemoved",
-        "old": "method <T extends com.fasterxml.jackson.databind.BeanDescription> T com.fasterxml.jackson.databind.DeserializationConfig::introspect(com.fasterxml.jackson.databind.JavaType)",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.DeserializationConfig::introspect(com.fasterxml.jackson.databind.JavaType)",
-        "typeParameter": "T extends com.fasterxml.jackson.databind.BeanDescription",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <T extends com.fasterxml.jackson.databind.BeanDescription> T com.fasterxml.jackson.databind.DeserializationConfig::introspectForBuilder(com.fasterxml.jackson.databind.JavaType)",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.DeserializationConfig::introspectForBuilder(com.fasterxml.jackson.databind.JavaType)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.generics.formalTypeParameterRemoved",
-        "old": "method <T extends com.fasterxml.jackson.databind.BeanDescription> T com.fasterxml.jackson.databind.DeserializationConfig::introspectForBuilder(com.fasterxml.jackson.databind.JavaType)",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.DeserializationConfig::introspectForBuilder(com.fasterxml.jackson.databind.JavaType)",
-        "typeParameter": "T extends com.fasterxml.jackson.databind.BeanDescription",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <T extends com.fasterxml.jackson.databind.BeanDescription> T com.fasterxml.jackson.databind.DeserializationConfig::introspectForCreation(com.fasterxml.jackson.databind.JavaType)",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.DeserializationConfig::introspectForCreation(com.fasterxml.jackson.databind.JavaType)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.generics.formalTypeParameterRemoved",
-        "old": "method <T extends com.fasterxml.jackson.databind.BeanDescription> T com.fasterxml.jackson.databind.DeserializationConfig::introspectForCreation(com.fasterxml.jackson.databind.JavaType)",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.DeserializationConfig::introspectForCreation(com.fasterxml.jackson.databind.JavaType)",
-        "typeParameter": "T extends com.fasterxml.jackson.databind.BeanDescription",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.serialVersionUIDUnchanged",
-        "old": "field com.fasterxml.jackson.databind.DeserializationContext.serialVersionUID",
-        "new": "field com.fasterxml.jackson.databind.DeserializationContext.serialVersionUID",
-        "serialVersionUID": "1",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.finalMethodAddedToNonFinalClass",
-        "new": "method boolean com.fasterxml.jackson.databind.DeserializationContext::isEnabled(com.fasterxml.jackson.core.StreamReadCapability)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.finalMethodAddedToNonFinalClass",
-        "new": "method boolean com.fasterxml.jackson.databind.JavaType::isRecordType()",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "class com.fasterxml.jackson.databind.JsonMappingException",
-        "superClass": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_VALUES",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_VALUES",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_COERCION_OF_SCALARS",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_COERCION_OF_SCALARS",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_EXPLICIT_PROPERTY_RENAMING",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.ALLOW_EXPLICIT_PROPERTY_RENAMING",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.DEFAULT_VIEW_INCLUSION",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.DEFAULT_VIEW_INCLUSION",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.IGNORE_MERGE_FOR_UNMERGEABLE",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.IGNORE_MERGE_FOR_UNMERGEABLE",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.SORT_PROPERTIES_ALPHABETICALLY",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.SORT_PROPERTIES_ALPHABETICALLY",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.USE_BASE_TYPE_AS_DEFAULT_IMPL",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.USE_BASE_TYPE_AS_DEFAULT_IMPL",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.USE_STATIC_TYPING",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.USE_STATIC_TYPING",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.USE_STD_BEAN_NAMING",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.USE_STD_BEAN_NAMING",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.MapperFeature.USE_WRAPPER_NAME_AS_PROPERTY_NAME",
-        "new": "field com.fasterxml.jackson.databind.MapperFeature.USE_WRAPPER_NAME_AS_PROPERTY_NAME",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.serialVersionUIDUnchanged",
-        "old": "field com.fasterxml.jackson.databind.ObjectMapper.serialVersionUID",
-        "new": "field com.fasterxml.jackson.databind.ObjectMapper.serialVersionUID",
-        "serialVersionUID": "2",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method java.lang.Object com.fasterxml.jackson.databind.ObjectMapper::_unwrapAndDeserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.DeserializationConfig, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object>) throws java.io.IOException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.finalMethodAddedToNonFinalClass",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::_writeValueAndClose(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.exception.runtimeAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::treeToValue(com.fasterxml.jackson.core.TreeNode, java.lang.Class<T>) throws com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::treeToValue(com.fasterxml.jackson.core.TreeNode, java.lang.Class<T>) throws java.lang.IllegalArgumentException, com.fasterxml.jackson.core.JsonProcessingException",
-        "exception": "java.lang.IllegalArgumentException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method java.lang.Object com.fasterxml.jackson.databind.ObjectReader::_unwrapAndDeserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object>) throws java.io.IOException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::_configAndWriteValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.returnTypeChanged",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::_configureGenerator(com.fasterxml.jackson.core.JsonGenerator)",
-        "new": "method com.fasterxml.jackson.core.JsonGenerator com.fasterxml.jackson.databind.ObjectWriter::_configureGenerator(com.fasterxml.jackson.core.JsonGenerator)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.finalMethodAddedToNonFinalClass",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::_writeValueAndClose(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.serialVersionUIDChanged",
-        "new": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.serialVersionUID",
-        "oldSerialVersionUID": "-5237220944964015475",
-        "newSerialVersionUID": "2",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <T extends com.fasterxml.jackson.databind.BeanDescription> T com.fasterxml.jackson.databind.SerializationConfig::introspect(com.fasterxml.jackson.databind.JavaType)",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.SerializationConfig::introspect(com.fasterxml.jackson.databind.JavaType)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.generics.formalTypeParameterRemoved",
-        "old": "method <T extends com.fasterxml.jackson.databind.BeanDescription> T com.fasterxml.jackson.databind.SerializationConfig::introspect(com.fasterxml.jackson.databind.JavaType)",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.SerializationConfig::introspect(com.fasterxml.jackson.databind.JavaType)",
-        "typeParameter": "T extends com.fasterxml.jackson.databind.BeanDescription",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.serialVersionUIDUnchanged",
-        "old": "field com.fasterxml.jackson.databind.cfg.BaseSettings.serialVersionUID",
-        "new": "field com.fasterxml.jackson.databind.cfg.BaseSettings.serialVersionUID",
-        "serialVersionUID": "1",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.numberOfParametersChanged",
-        "old": "method void com.fasterxml.jackson.databind.cfg.BaseSettings::<init>(com.fasterxml.jackson.databind.introspect.ClassIntrospector, com.fasterxml.jackson.databind.AnnotationIntrospector, com.fasterxml.jackson.databind.PropertyNamingStrategy, com.fasterxml.jackson.databind.type.TypeFactory, com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder<?>, java.text.DateFormat, com.fasterxml.jackson.databind.cfg.HandlerInstantiator, java.util.Locale, java.util.TimeZone, com.fasterxml.jackson.core.Base64Variant)",
-        "new": "method void com.fasterxml.jackson.databind.cfg.BaseSettings::<init>(com.fasterxml.jackson.databind.introspect.ClassIntrospector, com.fasterxml.jackson.databind.AnnotationIntrospector, com.fasterxml.jackson.databind.PropertyNamingStrategy, com.fasterxml.jackson.databind.type.TypeFactory, com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder<?>, java.text.DateFormat, com.fasterxml.jackson.databind.cfg.HandlerInstantiator, java.util.Locale, java.util.TimeZone, com.fasterxml.jackson.core.Base64Variant, com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator, com.fasterxml.jackson.databind.introspect.AccessorNamingStrategy.Provider)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.finalMethodAddedToNonFinalClass",
-        "new": "method com.fasterxml.jackson.databind.introspect.AccessorNamingStrategy.Provider com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::getAccessorNaming()",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.abstractMethodAdded",
-        "new": "method com.fasterxml.jackson.annotation.JsonIncludeProperties.Value com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::getDefaultPropertyInclusions(java.lang.Class<?>, com.fasterxml.jackson.databind.introspect.AnnotatedClass)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.serialVersionUIDUnchanged",
-        "old": "field com.fasterxml.jackson.databind.deser.DefaultDeserializationContext.serialVersionUID",
-        "new": "field com.fasterxml.jackson.databind.deser.DefaultDeserializationContext.serialVersionUID",
-        "serialVersionUID": "1",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.abstractMethodAdded",
-        "new": "method com.fasterxml.jackson.databind.deser.DefaultDeserializationContext com.fasterxml.jackson.databind.deser.DefaultDeserializationContext::createDummyInstance(com.fasterxml.jackson.databind.DeserializationConfig)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.fasterxml.jackson.databind.deser.UnresolvedForwardReference",
-        "new": "class com.fasterxml.jackson.databind.deser.UnresolvedForwardReference",
-        "superClass": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method com.fasterxml.jackson.databind.introspect.AnnotatedParameter com.fasterxml.jackson.databind.deser.ValueInstantiator::getIncompleteParameter()",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method void com.fasterxml.jackson.databind.deser.impl.BeanPropertyMap::<init>(boolean, java.util.Collection<com.fasterxml.jackson.databind.deser.SettableBeanProperty>)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.numberOfParametersChanged",
-        "old": "method com.fasterxml.jackson.databind.deser.impl.BeanPropertyMap com.fasterxml.jackson.databind.deser.impl.BeanPropertyMap::construct(java.util.Collection<com.fasterxml.jackson.databind.deser.SettableBeanProperty>, boolean)",
-        "new": "method com.fasterxml.jackson.databind.deser.impl.BeanPropertyMap com.fasterxml.jackson.databind.deser.impl.BeanPropertyMap::construct(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, java.util.Collection<com.fasterxml.jackson.databind.deser.SettableBeanProperty>, java.util.Map<java.lang.String, java.util.List<com.fasterxml.jackson.databind.PropertyName>>, boolean)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method void com.fasterxml.jackson.databind.deser.impl.BeanPropertyMap::replace(com.fasterxml.jackson.databind.deser.SettableBeanProperty)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.abstractMethodAdded",
-        "new": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.introspect.ClassIntrospector::forDeserializationWithBuilder(com.fasterxml.jackson.databind.DeserializationConfig, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver, com.fasterxml.jackson.databind.BeanDescription)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.numberOfParametersChanged",
-        "old": "method void com.fasterxml.jackson.databind.ser.BeanSerializer::<init>(com.fasterxml.jackson.databind.ser.std.BeanSerializerBase, java.util.Set<java.lang.String>)",
-        "new": "method void com.fasterxml.jackson.databind.ser.BeanSerializer::<init>(com.fasterxml.jackson.databind.ser.std.BeanSerializerBase, java.util.Set<java.lang.String>, java.util.Set<java.lang.String>)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method com.fasterxml.jackson.databind.ser.impl.PropertySerializerMap com.fasterxml.jackson.databind.ser.impl.PropertySerializerMap::emptyMap()",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.visibilityReduced",
-        "old": "method void com.fasterxml.jackson.databind.ser.std.BeanSerializerBase::<init>(com.fasterxml.jackson.databind.ser.std.BeanSerializerBase, com.fasterxml.jackson.databind.ser.BeanPropertyWriter[], com.fasterxml.jackson.databind.ser.BeanPropertyWriter[])",
-        "new": "method void com.fasterxml.jackson.databind.ser.std.BeanSerializerBase::<init>(com.fasterxml.jackson.databind.ser.std.BeanSerializerBase, com.fasterxml.jackson.databind.ser.BeanPropertyWriter[], com.fasterxml.jackson.databind.ser.BeanPropertyWriter[])",
-        "oldVisibility": "public",
-        "newVisibility": "protected",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.abstractMethodAdded",
-        "new": "method com.fasterxml.jackson.databind.ser.std.BeanSerializerBase com.fasterxml.jackson.databind.ser.std.BeanSerializerBase::withByNameInclusion(java.util.Set<java.lang.String>, java.util.Set<java.lang.String>)",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.method.abstractMethodAdded",
-        "new": "method com.fasterxml.jackson.databind.ser.std.BeanSerializerBase com.fasterxml.jackson.databind.ser.std.BeanSerializerBase::withProperties(com.fasterxml.jackson.databind.ser.BeanPropertyWriter[], com.fasterxml.jackson.databind.ser.BeanPropertyWriter[])",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.typeChanged",
-        "old": "field com.fasterxml.jackson.databind.type.TypeFactory._typeCache",
-        "new": "field com.fasterxml.jackson.databind.type.TypeFactory._typeCache",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.field.serialVersionUIDUnchanged",
-        "old": "field com.fasterxml.jackson.databind.type.TypeFactory.serialVersionUID",
-        "new": "field com.fasterxml.jackson.databind.type.TypeFactory.serialVersionUID",
-        "serialVersionUID": "1",
-        "justification": "JAVA-2904: Jackson upgraded to 2.12.0. Caused by the exposure of ObjectMapper as a parameter in ExtraTypeCodecs.json()"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.remote.RemoteConnection",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.traversal.P",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.traversal.Path",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.structure.Edge",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.structure.Property",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.structure.Vertex",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class org.apache.tinkerpop.gremlin.structure.VertexProperty",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.process.remote.RemoteConnection",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.remote.RemoteConnection",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.process.traversal.P",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.traversal.P",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.process.traversal.Path",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.traversal.Path",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource",
-        "new": "missing-class org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.structure.Edge",
-        "new": "missing-class org.apache.tinkerpop.gremlin.structure.Edge",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.structure.Property",
-        "new": "missing-class org.apache.tinkerpop.gremlin.structure.Property",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.structure.Vertex",
-        "new": "missing-class org.apache.tinkerpop.gremlin.structure.Vertex",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class org.apache.tinkerpop.gremlin.structure.VertexProperty",
-        "new": "missing-class org.apache.tinkerpop.gremlin.structure.VertexProperty",
-        "justification": "JAVA-2907: switched Tinkerpop dependency to optional"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.fasterxml.jackson.core.JsonGenerationException",
-        "new": "class com.fasterxml.jackson.core.JsonGenerationException",
-        "superClass": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.field.serialVersionUIDChanged",
-        "old": "field com.fasterxml.jackson.core.JsonLocation.serialVersionUID",
-        "new": "field com.fasterxml.jackson.core.JsonLocation.serialVersionUID",
-        "oldSerialVersionUID": "1",
-        "newSerialVersionUID": "2",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method java.lang.StringBuilder com.fasterxml.jackson.core.JsonLocation::_appendSourceDesc(java.lang.StringBuilder)",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.visibilityReduced",
-        "old": "method void com.fasterxml.jackson.core.exc.StreamReadException::<init>(com.fasterxml.jackson.core.JsonParser, java.lang.String)",
-        "new": "method void com.fasterxml.jackson.core.exc.StreamReadException::<init>(com.fasterxml.jackson.core.JsonParser, java.lang.String)",
-        "oldVisibility": "public",
-        "newVisibility": "protected",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.visibilityReduced",
-        "old": "method void com.fasterxml.jackson.core.exc.StreamReadException::<init>(com.fasterxml.jackson.core.JsonParser, java.lang.String, com.fasterxml.jackson.core.JsonLocation)",
-        "new": "method void com.fasterxml.jackson.core.exc.StreamReadException::<init>(com.fasterxml.jackson.core.JsonParser, java.lang.String, com.fasterxml.jackson.core.JsonLocation)",
-        "oldVisibility": "public",
-        "newVisibility": "protected",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.visibilityReduced",
-        "old": "method void com.fasterxml.jackson.core.exc.StreamReadException::<init>(com.fasterxml.jackson.core.JsonParser, java.lang.String, java.lang.Throwable)",
-        "new": "method void com.fasterxml.jackson.core.exc.StreamReadException::<init>(com.fasterxml.jackson.core.JsonParser, java.lang.String, java.lang.Throwable)",
-        "oldVisibility": "public",
-        "newVisibility": "protected",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.field.nowFinal",
-        "old": "field com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer._intern",
-        "new": "field com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer._intern",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method void com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer::reportTooManyCollisions(int)",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.abstractMethodAdded",
-        "new": "method java.util.List<com.fasterxml.jackson.databind.introspect.AnnotatedAndMetadata<com.fasterxml.jackson.databind.introspect.AnnotatedConstructor, com.fasterxml.jackson.annotation.JsonCreator.Mode>> com.fasterxml.jackson.databind.BeanDescription::getConstructorsWithMode()",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.abstractMethodAdded",
-        "new": "method java.util.List<com.fasterxml.jackson.databind.introspect.AnnotatedAndMetadata<com.fasterxml.jackson.databind.introspect.AnnotatedMethod, com.fasterxml.jackson.annotation.JsonCreator.Mode>> com.fasterxml.jackson.databind.BeanDescription::getFactoryMethodsWithMode()",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter com.fasterxml.jackson.databind.DeserializationConfig com.fasterxml.jackson.databind.DeserializationConfig::_withMapperFeatures(===int===)",
-        "new": "parameter com.fasterxml.jackson.databind.DeserializationConfig com.fasterxml.jackson.databind.DeserializationConfig::_withMapperFeatures(===long===)",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.finalMethodAddedToNonFinalClass",
-        "new": "method com.fasterxml.jackson.databind.util.TokenBuffer com.fasterxml.jackson.databind.DeserializationContext::bufferForInputBuffering()",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method T com.fasterxml.jackson.databind.JsonDeserializer<T>::deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method T com.fasterxml.jackson.databind.JsonDeserializer<T>::deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext) throws java.io.IOException, com.fasterxml.jackson.core.JacksonException",
-        "exception": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method T com.fasterxml.jackson.databind.JsonDeserializer<T>::deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method T com.fasterxml.jackson.databind.JsonDeserializer<T>::deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext) throws java.io.IOException, com.fasterxml.jackson.core.JacksonException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method T com.fasterxml.jackson.databind.JsonDeserializer<T>::deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, T) throws java.io.IOException",
-        "new": "method T com.fasterxml.jackson.databind.JsonDeserializer<T>::deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, T) throws java.io.IOException, com.fasterxml.jackson.core.JacksonException",
-        "exception": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method java.lang.Object com.fasterxml.jackson.databind.JsonDeserializer<T>::deserializeWithType(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.jsontype.TypeDeserializer) throws java.io.IOException",
-        "new": "method java.lang.Object com.fasterxml.jackson.databind.JsonDeserializer<T>::deserializeWithType(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.jsontype.TypeDeserializer) throws java.io.IOException, com.fasterxml.jackson.core.JacksonException",
-        "exception": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method java.lang.Object com.fasterxml.jackson.databind.JsonDeserializer<T>::deserializeWithType(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.jsontype.TypeDeserializer, T) throws java.io.IOException",
-        "new": "method java.lang.Object com.fasterxml.jackson.databind.JsonDeserializer<T>::deserializeWithType(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.jsontype.TypeDeserializer, T) throws java.io.IOException, com.fasterxml.jackson.core.JacksonException",
-        "exception": "com.fasterxml.jackson.core.JacksonException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "class com.fasterxml.jackson.databind.JsonMappingException",
-        "superClass": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectMapper::_findRootDeserializer(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.JavaType) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectMapper::_findRootDeserializer(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.JavaType) throws com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectMapper::_findRootDeserializer(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.JavaType) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectMapper::_findRootDeserializer(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.JavaType) throws com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method com.fasterxml.jackson.core.JsonToken com.fasterxml.jackson.databind.ObjectMapper::_initForReading(com.fasterxml.jackson.core.JsonParser) throws java.io.IOException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T extends com.fasterxml.jackson.core.TreeNode> T com.fasterxml.jackson.databind.ObjectMapper::readTree(com.fasterxml.jackson.core.JsonParser) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method <T extends com.fasterxml.jackson.core.TreeNode> T com.fasterxml.jackson.databind.ObjectMapper::readTree(com.fasterxml.jackson.core.JsonParser) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method com.fasterxml.jackson.databind.JsonNode com.fasterxml.jackson.databind.ObjectMapper::readTree(java.io.File) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method com.fasterxml.jackson.databind.JsonNode com.fasterxml.jackson.databind.ObjectMapper::readTree(java.io.File) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], int, int, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(byte[], java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.File, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.InputStream, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.io.Reader, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonParseException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method <T> T com.fasterxml.jackson.databind.ObjectMapper::readValue(java.net.URL, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamReadException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> com.fasterxml.jackson.databind.MappingIterator<T> com.fasterxml.jackson.databind.ObjectMapper::readValues(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method <T> com.fasterxml.jackson.databind.MappingIterator<T> com.fasterxml.jackson.databind.ObjectMapper::readValues(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.ResolvedType) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> com.fasterxml.jackson.databind.MappingIterator<T> com.fasterxml.jackson.databind.ObjectMapper::readValues(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method <T> com.fasterxml.jackson.databind.MappingIterator<T> com.fasterxml.jackson.databind.ObjectMapper::readValues(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.core.type.TypeReference<T>) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> com.fasterxml.jackson.databind.MappingIterator<T> com.fasterxml.jackson.databind.ObjectMapper::readValues(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method <T> com.fasterxml.jackson.databind.MappingIterator<T> com.fasterxml.jackson.databind.ObjectMapper::readValues(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JavaType) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method <T> com.fasterxml.jackson.databind.MappingIterator<T> com.fasterxml.jackson.databind.ObjectMapper::readValues(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method <T> com.fasterxml.jackson.databind.MappingIterator<T> com.fasterxml.jackson.databind.ObjectMapper::readValues(com.fasterxml.jackson.core.JsonParser, java.lang.Class<T>) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeTree(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.core.TreeNode) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeTree(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.core.TreeNode) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeTree(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.JsonNode) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeTree(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.JsonNode) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonGenerationException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(com.fasterxml.jackson.core.JsonGenerator, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonGenerationException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonGenerationException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonGenerationException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectMapper::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectReader::_findRootDeserializer(com.fasterxml.jackson.databind.DeserializationContext) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectReader::_findRootDeserializer(com.fasterxml.jackson.databind.DeserializationContext) throws com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectReader::_findRootDeserializer(com.fasterxml.jackson.databind.DeserializationContext) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectReader::_findRootDeserializer(com.fasterxml.jackson.databind.DeserializationContext) throws com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectReader::_findTreeDeserializer(com.fasterxml.jackson.databind.DeserializationContext) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectReader::_findTreeDeserializer(com.fasterxml.jackson.databind.DeserializationContext) throws com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectReader::_findTreeDeserializer(com.fasterxml.jackson.databind.DeserializationContext) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object> com.fasterxml.jackson.databind.ObjectReader::_findTreeDeserializer(com.fasterxml.jackson.databind.DeserializationContext) throws com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectReader::_reportUndetectableSource(java.lang.Object) throws com.fasterxml.jackson.core.JsonParseException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectReader::_reportUndetectableSource(java.lang.Object) throws com.fasterxml.jackson.core.exc.StreamReadException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamReadException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectReader::_reportUndetectableSource(java.lang.Object) throws com.fasterxml.jackson.core.JsonParseException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectReader::_reportUndetectableSource(java.lang.Object) throws com.fasterxml.jackson.core.exc.StreamReadException",
-        "exception": "com.fasterxml.jackson.core.JsonParseException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectReader::_reportUnkownFormat(com.fasterxml.jackson.databind.deser.DataFormatReaders, com.fasterxml.jackson.databind.deser.DataFormatReaders.Match) throws com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectReader::_reportUnkownFormat(com.fasterxml.jackson.databind.deser.DataFormatReaders, com.fasterxml.jackson.databind.deser.DataFormatReaders.Match) throws java.io.IOException",
-        "exception": "java.io.IOException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectReader::_reportUnkownFormat(com.fasterxml.jackson.databind.deser.DataFormatReaders, com.fasterxml.jackson.databind.deser.DataFormatReaders.Match) throws com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectReader::_reportUnkownFormat(com.fasterxml.jackson.databind.deser.DataFormatReaders, com.fasterxml.jackson.databind.deser.DataFormatReaders.Match) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.DataOutput, java.lang.Object) throws java.io.IOException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.DataOutput, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.SORT_PROPERTIES_ALPHABETICALLY",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.SORT_PROPERTIES_ALPHABETICALLY",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.DataOutput, java.lang.Object) throws java.io.IOException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.DataOutput, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.USE_BASE_TYPE_AS_DEFAULT_IMPL",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.USE_BASE_TYPE_AS_DEFAULT_IMPL",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.USE_STATIC_TYPING",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.USE_STATIC_TYPING",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.USE_STD_BEAN_NAMING",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.USE_STD_BEAN_NAMING",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonGenerationException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.MapperFeature.USE_WRAPPER_NAME_AS_PROPERTY_NAME",
+        "new": "field com.fasterxml.jackson.databind.MapperFeature.USE_WRAPPER_NAME_AS_PROPERTY_NAME",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.File, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.enumConstantOrderChanged",
+        "old": "field com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping.EVERYTHING",
+        "new": "field com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping.EVERYTHING",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.KEBAB_CASE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonGenerationException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.LOWER_CAMEL_CASE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.OutputStream, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.LOWER_CASE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.exc.StreamWriteException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.LOWER_DOT_CASE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.PASCAL_CASE_TO_CAMEL_CASE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.core.JsonGenerationException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.SNAKE_CASE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException, com.fasterxml.jackson.databind.JsonMappingException",
-        "new": "method void com.fasterxml.jackson.databind.ObjectWriter::writeValue(java.io.Writer, java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.exc.StreamWriteException, com.fasterxml.jackson.databind.DatabindException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.PropertyNamingStrategy.UPPER_CAMEL_CASE",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.field.serialVersionUIDUnchanged",
         "old": "field com.fasterxml.jackson.databind.SerializationConfig.serialVersionUID",
         "new": "field com.fasterxml.jackson.databind.SerializationConfig.serialVersionUID",
         "serialVersionUID": "1",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter com.fasterxml.jackson.databind.SerializationConfig com.fasterxml.jackson.databind.SerializationConfig::_withMapperFeatures(===int===)",
-        "new": "parameter com.fasterxml.jackson.databind.SerializationConfig com.fasterxml.jackson.databind.SerializationConfig::_withMapperFeatures(===long===)",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.databind.SerializationConfig::<init>(com.fasterxml.jackson.databind.SerializationConfig, com.fasterxml.jackson.databind.introspect.SimpleMixInResolver, com.fasterxml.jackson.databind.util.RootNameLookup, com.fasterxml.jackson.databind.cfg.ConfigOverrides)",
+        "new": "method void com.fasterxml.jackson.databind.SerializationConfig::<init>(com.fasterxml.jackson.databind.SerializationConfig, com.fasterxml.jackson.databind.cfg.ConstructorDetector)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.field.enumConstantOrderChanged",
         "old": "field com.fasterxml.jackson.databind.SerializationFeature.EAGER_SERIALIZER_FETCH",
         "new": "field com.fasterxml.jackson.databind.SerializationFeature.EAGER_SERIALIZER_FETCH",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.field.enumConstantOrderChanged",
         "old": "field com.fasterxml.jackson.databind.SerializationFeature.USE_EQUALITY_FOR_OBJECT_ID",
         "new": "field com.fasterxml.jackson.databind.SerializationFeature.USE_EQUALITY_FOR_OBJECT_ID",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method com.fasterxml.jackson.databind.cfg.DatatypeFeatures com.fasterxml.jackson.databind.SerializerProvider::getDatatypeFeatures()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_EMPTY_JSON_ARRAYS",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_EMPTY_JSON_ARRAYS",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method boolean com.fasterxml.jackson.databind.SerializerProvider::isEnabled(com.fasterxml.jackson.databind.cfg.DatatypeFeature)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_ENUMS_USING_INDEX",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_ENUMS_USING_INDEX",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.field.serialVersionUIDUnchanged",
+        "old": "field com.fasterxml.jackson.databind.cfg.BaseSettings.serialVersionUID",
+        "new": "field com.fasterxml.jackson.databind.cfg.BaseSettings.serialVersionUID",
+        "serialVersionUID": "1",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_ENUMS_USING_TO_STRING",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_ENUMS_USING_TO_STRING",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.databind.cfg.BaseSettings::<init>(com.fasterxml.jackson.databind.introspect.ClassIntrospector, com.fasterxml.jackson.databind.AnnotationIntrospector, com.fasterxml.jackson.databind.PropertyNamingStrategy, com.fasterxml.jackson.databind.type.TypeFactory, com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder<?>, java.text.DateFormat, com.fasterxml.jackson.databind.cfg.HandlerInstantiator, java.util.Locale, java.util.TimeZone, com.fasterxml.jackson.core.Base64Variant, com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator)",
+        "new": "method void com.fasterxml.jackson.databind.cfg.BaseSettings::<init>(com.fasterxml.jackson.databind.introspect.ClassIntrospector, com.fasterxml.jackson.databind.AnnotationIntrospector, com.fasterxml.jackson.databind.PropertyNamingStrategy, com.fasterxml.jackson.databind.type.TypeFactory, com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder<?>, java.text.DateFormat, com.fasterxml.jackson.databind.cfg.HandlerInstantiator, java.util.Locale, java.util.TimeZone, com.fasterxml.jackson.core.Base64Variant, com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator, com.fasterxml.jackson.databind.introspect.AccessorNamingStrategy.Provider, com.fasterxml.jackson.databind.cfg.CacheProvider)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method com.fasterxml.jackson.databind.cfg.ConstructorDetector com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::getConstructorDetector()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_NULL_MAP_VALUES",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_NULL_MAP_VALUES",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method com.fasterxml.jackson.databind.cfg.DatatypeFeatures com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::getDatatypeFeatures()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.field.enumConstantOrderChanged",
-        "old": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED",
-        "new": "field com.fasterxml.jackson.databind.SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method com.fasterxml.jackson.databind.EnumNamingStrategy com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::getEnumNamingStrategy()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.finalMethodAddedToNonFinalClass",
-        "new": "method com.fasterxml.jackson.databind.util.TokenBuffer com.fasterxml.jackson.databind.SerializerProvider::bufferForValueConversion()",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method boolean com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::isEnabled(com.fasterxml.jackson.databind.cfg.DatatypeFeature)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.removed",
-        "old": "method java.lang.Class<?> com.fasterxml.jackson.databind.SerializerProvider::getSerializationView()",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method com.fasterxml.jackson.databind.deser.DefaultDeserializationContext com.fasterxml.jackson.databind.deser.DefaultDeserializationContext::withCaches(com.fasterxml.jackson.databind.cfg.CacheProvider)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.field.typeChanged",
-        "old": "field com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>._mapperFeatures",
-        "new": "field com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>._mapperFeatures",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "old": "field com.fasterxml.jackson.databind.deser.DeserializerCache._cachedDeserializers",
+        "new": "field com.fasterxml.jackson.databind.deser.DeserializerCache._cachedDeserializers",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.field.serialVersionUIDUnchanged",
-        "old": "field com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>.serialVersionUID",
-        "new": "field com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>.serialVersionUID",
-        "serialVersionUID": "2",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "old": "field com.fasterxml.jackson.databind.deser.DeserializerCache.serialVersionUID",
+        "new": "field com.fasterxml.jackson.databind.deser.DeserializerCache.serialVersionUID",
+        "serialVersionUID": "1",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter void com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::<init>(com.fasterxml.jackson.databind.cfg.BaseSettings, ===int===)",
-        "new": "parameter void com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::<init>(com.fasterxml.jackson.databind.cfg.BaseSettings, ===long===)",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.deser.SettableAnyProperty::<init>(com.fasterxml.jackson.databind.BeanProperty, com.fasterxml.jackson.databind.introspect.AnnotatedMember, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object>, com.fasterxml.jackson.databind.jsontype.TypeDeserializer)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter void com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::<init>(com.fasterxml.jackson.databind.cfg.MapperConfig<T>, ===int===)",
-        "new": "parameter void com.fasterxml.jackson.databind.cfg.MapperConfig<T extends com.fasterxml.jackson.databind.cfg.MapperConfig<T>>::<init>(com.fasterxml.jackson.databind.cfg.MapperConfig<T>, ===long===)",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method void com.fasterxml.jackson.databind.deser.SettableAnyProperty::_set(java.lang.Object, java.lang.Object, java.lang.Object) throws java.lang.Exception",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder::_fixAccess(java.util.Collection<com.fasterxml.jackson.databind.deser.SettableBeanProperty>)",
-        "new": "method void com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder::_fixAccess(java.util.Collection<com.fasterxml.jackson.databind.deser.SettableBeanProperty>) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.nowAbstract",
+        "old": "method com.fasterxml.jackson.databind.deser.SettableAnyProperty com.fasterxml.jackson.databind.deser.SettableAnyProperty::withValueDeserializer(com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object>)",
+        "new": "method com.fasterxml.jackson.databind.deser.SettableAnyProperty com.fasterxml.jackson.databind.deser.SettableAnyProperty::withValueDeserializer(com.fasterxml.jackson.databind.JsonDeserializer<java.lang.Object>)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder::addBackReferenceProperty(java.lang.String, com.fasterxml.jackson.databind.deser.SettableBeanProperty)",
-        "new": "method void com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder::addBackReferenceProperty(java.lang.String, com.fasterxml.jackson.databind.deser.SettableBeanProperty) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.class.nowAbstract",
+        "old": "class com.fasterxml.jackson.databind.deser.SettableAnyProperty",
+        "new": "class com.fasterxml.jackson.databind.deser.SettableAnyProperty",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method void com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder::addInjectable(com.fasterxml.jackson.databind.PropertyName, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.util.Annotations, com.fasterxml.jackson.databind.introspect.AnnotatedMember, java.lang.Object)",
-        "new": "method void com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder::addInjectable(com.fasterxml.jackson.databind.PropertyName, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.util.Annotations, com.fasterxml.jackson.databind.introspect.AnnotatedMember, java.lang.Object) throws com.fasterxml.jackson.databind.JsonMappingException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.class.defaultSerializationChanged",
+        "old": "class com.fasterxml.jackson.databind.deser.SettableBeanProperty",
+        "new": "class com.fasterxml.jackson.databind.deser.SettableBeanProperty",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedAdded",
-        "old": "method com.fasterxml.jackson.databind.JsonDeserializer<?> com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder::build()",
-        "new": "method com.fasterxml.jackson.databind.JsonDeserializer<?> com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder::build() throws com.fasterxml.jackson.databind.JsonMappingException",
-        "exception": "com.fasterxml.jackson.databind.JsonMappingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.deser.UnresolvedForwardReference::<init>(java.lang.String)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.fasterxml.jackson.databind.deser.UnresolvedForwardReference",
-        "new": "class com.fasterxml.jackson.databind.deser.UnresolvedForwardReference",
-        "superClass": "com.fasterxml.jackson.databind.DatabindException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.deser.UnresolvedForwardReference::<init>(java.lang.String, com.fasterxml.jackson.core.JsonLocation, com.fasterxml.jackson.databind.deser.impl.ReadableObjectId)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.deser.impl.PropertyValue::assign(java.lang.Object) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
+        "ignore": true,
+        "code": "java.method.nowFinal",
+        "old": "method void com.fasterxml.jackson.databind.deser.impl.PropertyValue::assign(java.lang.Object) throws java.io.IOException",
         "new": "method void com.fasterxml.jackson.databind.deser.impl.PropertyValue::assign(java.lang.Object) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.node.BinaryNode::serialize(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method void com.fasterxml.jackson.databind.node.BinaryNode::serialize(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.node.BaseJsonNode::serialize(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException @ com.fasterxml.jackson.databind.node.NumericNode",
-        "new": "method void com.fasterxml.jackson.databind.node.BaseJsonNode::serialize(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException @ com.fasterxml.jackson.databind.node.NumericNode",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.node.BaseJsonNode::serialize(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException @ com.fasterxml.jackson.databind.node.ValueNode",
-        "new": "method void com.fasterxml.jackson.databind.node.BaseJsonNode::serialize(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException @ com.fasterxml.jackson.databind.node.ValueNode",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.ser.std.BeanSerializerBase::serializeFieldsFiltered(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException, com.fasterxml.jackson.core.JsonGenerationException",
-        "new": "method void com.fasterxml.jackson.databind.ser.std.BeanSerializerBase::serializeFieldsFiltered(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonGenerationException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
-      },
-      {
-        "code": "java.method.exception.checkedRemoved",
-        "old": "method void com.fasterxml.jackson.databind.type.TypeBase::serialize(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException, com.fasterxml.jackson.core.JsonProcessingException",
-        "new": "method void com.fasterxml.jackson.databind.type.TypeBase::serialize(com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) throws java.io.IOException",
-        "exception": "com.fasterxml.jackson.core.JsonProcessingException",
-        "justification": "Upgrade deps around JAVA-2977 to address outstanding CVEs"
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.class.nonFinalClassInheritsFromNewClass",
-        "old": "class com.datastax.oss.driver.api.core.type.codec.CodecNotFoundException",
-        "new": "class com.datastax.oss.driver.api.core.type.codec.CodecNotFoundException",
-        "superClass": "com.datastax.oss.driver.api.core.DriverException",
-        "justification": "Make CodecNotFoundException to extend DriverException as all other driver exceptions do"
+        "ignore": true,
+        "code": "java.method.exception.checkedAdded",
+        "old": "method java.lang.Object[] com.fasterxml.jackson.databind.deser.impl.PropertyValueBuffer::getParameters(com.fasterxml.jackson.databind.deser.SettableBeanProperty[]) throws com.fasterxml.jackson.databind.JsonMappingException",
+        "new": "method java.lang.Object[] com.fasterxml.jackson.databind.deser.impl.PropertyValueBuffer::getParameters(com.fasterxml.jackson.databind.deser.SettableBeanProperty[]) throws com.fasterxml.jackson.databind.JsonMappingException, java.io.IOException",
+        "exception": "java.io.IOException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.class.removed",
-        "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
-        "justification": "Refactoring in JAVA-3061"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method void com.fasterxml.jackson.databind.deser.impl.ValueInjector::<init>(com.fasterxml.jackson.databind.PropertyName, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.util.Annotations, com.fasterxml.jackson.databind.introspect.AnnotatedMember, java.lang.Object)",
+        "new": "method void com.fasterxml.jackson.databind.deser.impl.ValueInjector::<init>(com.fasterxml.jackson.databind.PropertyName, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.introspect.AnnotatedMember, java.lang.Object, java.lang.Boolean, java.lang.Boolean)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.method.removed",
-        "old": "method com.datastax.oss.driver.api.core.data.CqlVector<?> com.datastax.oss.driver.api.core.data.GettableById::getCqlVector(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.removed",
-       "old": "method com.datastax.oss.driver.api.core.data.CqlVector<?> com.datastax.oss.driver.api.core.data.GettableByIndex::getCqlVector(int)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.removed",
-       "old": "method com.datastax.oss.driver.api.core.data.CqlVector<?> com.datastax.oss.driver.api.core.data.GettableByName::getCqlVector(java.lang.String)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.removed",
-       "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setCqlVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<?>)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.removed",
-       "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setCqlVector(int, com.datastax.oss.driver.api.core.data.CqlVector<?>)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.removed",
-       "old": "method SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setCqlVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<?>)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.class.removed",
-       "old": "class com.datastax.oss.driver.api.core.type.CqlVectorType",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.returnTypeChanged",
-       "old": "method com.datastax.oss.driver.api.core.type.CqlVectorType com.datastax.oss.driver.api.core.type.DataTypes::vectorOf(com.datastax.oss.driver.api.core.type.DataType, int)",
-       "new": "method com.datastax.oss.driver.api.core.type.VectorType com.datastax.oss.driver.api.core.type.DataTypes::vectorOf(com.datastax.oss.driver.api.core.type.DataType, int)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.parameterTypeChanged",
-       "old": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(===com.datastax.oss.driver.api.core.type.CqlVectorType===, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-       "new": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<java.util.List<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(===com.datastax.oss.driver.api.core.type.VectorType===, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.returnTypeTypeParametersChanged",
-       "old": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.CqlVectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-       "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<java.util.List<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-     {
-       "code": "java.method.removed",
-       "old": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-       "justification": "Refactoring in JAVA-3061"
-     },
-      {
-        "code": "java.class.removed",
-        "old": "class com.datastax.oss.driver.api.core.data.CqlVector.Builder<T>",
-        "justification": "Refactorings in PR 1666"
+        "old": "method com.fasterxml.jackson.databind.introspect.AnnotatedClass com.fasterxml.jackson.databind.introspect.AnnotatedClass::construct(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.cfg.MapperConfig<?>)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.method.removed",
-        "old": "method com.datastax.oss.driver.api.core.data.CqlVector.Builder com.datastax.oss.driver.api.core.data.CqlVector<T>::builder()",
-        "justification": "Refactorings in PR 1666"
+        "old": "method com.fasterxml.jackson.databind.introspect.AnnotatedClass com.fasterxml.jackson.databind.introspect.AnnotatedClass::construct(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.method.removed",
-        "old": "method java.lang.Iterable<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::getValues()",
-        "justification": "Refactorings in PR 1666"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
-        "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
-        "justification": "Refactorings in PR 1666"
-      },
-      {
-        "code": "java.method.parameterTypeChanged",
-        "old": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(===com.datastax.oss.driver.api.core.type.CqlVectorType===, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "new": "parameter <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(===com.datastax.oss.driver.api.core.type.VectorType===, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "justification": "Refactorings in PR 1666"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.CqlVectorType, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
-        "new": "parameter <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
-        "justification": "Refactorings in PR 1666"
+        "old": "method com.fasterxml.jackson.databind.introspect.AnnotatedClass com.fasterxml.jackson.databind.introspect.AnnotatedClass::constructWithoutSuperTypes(java.lang.Class<?>, com.fasterxml.jackson.databind.cfg.MapperConfig<?>)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.CqlVectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "new": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "justification": "Refactorings in PR 1666"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.CqlVectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "new": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "justification": "Refactorings in PR 1666"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===com.datastax.oss.driver.api.core.type.reflect.GenericType<T>===)",
-        "new": "parameter <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===com.datastax.oss.driver.api.core.type.reflect.GenericType<T>===)",
-        "justification": "Refactorings in PR 1666"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.introspect.AnnotatedClass com.fasterxml.jackson.databind.introspect.AnnotatedClass::constructWithoutSuperTypes(java.lang.Class<?>, com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-        "new": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-        "justification": "Refactorings in PR 1666"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method java.util.List<com.fasterxml.jackson.databind.introspect.AnnotatedMethod> com.fasterxml.jackson.databind.introspect.AnnotatedClass::getStaticMethods()",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-        "new": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-        "justification": "Refactorings in PR 1666"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method com.fasterxml.jackson.databind.BeanDescription com.fasterxml.jackson.databind.introspect.ClassIntrospector::forDeserializationWithBuilder(com.fasterxml.jackson.databind.DeserializationConfig, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.method.returnTypeChangedCovariantly",
-        "old": "method java.lang.Throwable java.lang.Throwable::fillInStackTrace() @ com.fasterxml.jackson.databind.deser.UnresolvedForwardReference",
-        "new": "method com.fasterxml.jackson.databind.deser.UnresolvedForwardReference com.fasterxml.jackson.databind.deser.UnresolvedForwardReference::fillInStackTrace()",
-        "justification": "Upgrade jackson-databind to 2.13.4.1 to address CVEs, API change cause: https://github.com/FasterXML/jackson-databind/issues/3419"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT extends com.datastax.oss.driver.api.core.cql.BatchableStatement<SelfT>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.BoundStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int) @ com.datastax.oss.driver.api.core.cql.SimpleStatement",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.core.cql.Statement<SelfT extends com.datastax.oss.driver.api.core.cql.Statement<SelfT>>::setNowInSeconds(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::add(com.datastax.oss.driver.api.core.cql.BatchableStatement<?>)",
-        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::add(com.datastax.oss.driver.api.core.cql.BatchableStatement<?>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::addAll(com.datastax.oss.driver.api.core.cql.BatchableStatement<?>[])",
-        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::addAll(com.datastax.oss.driver.api.core.cql.BatchableStatement<?>[])",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::addAll(java.lang.Iterable<? extends com.datastax.oss.driver.api.core.cql.BatchableStatement<?>>)",
-        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::addAll(java.lang.Iterable<? extends com.datastax.oss.driver.api.core.cql.BatchableStatement<?>>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::clear()",
-        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::clear()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setBatchType(com.datastax.oss.driver.api.core.cql.BatchType)",
-        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setBatchType(com.datastax.oss.driver.api.core.cql.BatchType)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setKeyspace(java.lang.String)",
-        "new": "method com.datastax.oss.driver.api.core.cql.BatchStatement com.datastax.oss.driver.api.core.cql.BatchStatement::setKeyspace(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setQuery(java.lang.String)",
-        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setQuery(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setKeyspace(com.datastax.oss.driver.api.core.CqlIdentifier)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setKeyspace(java.lang.String)",
-        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setKeyspace(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setPositionalValues(java.util.List<java.lang.Object>)",
-        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setPositionalValues(java.util.List<java.lang.Object>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValuesWithIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Object>)",
-        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValuesWithIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Object>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValues(java.util.Map<java.lang.String, java.lang.Object>)",
-        "new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValues(java.util.Map<java.lang.String, java.lang.Object>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>===)",
-        "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "old": "method <T extends com.fasterxml.jackson.databind.JsonNode> T com.fasterxml.jackson.databind.JsonNode::with(java.lang.String) @ com.fasterxml.jackson.databind.node.ArrayNode",
+        "new": "method com.fasterxml.jackson.databind.node.ObjectNode com.fasterxml.jackson.databind.node.ArrayNode::with(java.lang.String)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
-        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "ignore": true,
+        "code": "java.generics.formalTypeParameterRemoved",
+        "old": "method <T extends com.fasterxml.jackson.databind.JsonNode> T com.fasterxml.jackson.databind.JsonNode::with(java.lang.String) @ com.fasterxml.jackson.databind.node.ArrayNode",
+        "new": "method com.fasterxml.jackson.databind.node.ObjectNode com.fasterxml.jackson.databind.node.ArrayNode::with(java.lang.String)",
+        "typeParameter": "T extends com.fasterxml.jackson.databind.JsonNode",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
-        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "ignore": true,
+        "code": "java.method.finalMethodAddedToNonFinalClass",
+        "new": "method com.fasterxml.jackson.annotation.JsonFormat.Value com.fasterxml.jackson.databind.introspect.ConcreteBeanPropertyBase::findFormatOverrides(com.fasterxml.jackson.databind.AnnotationIntrospector) @ com.fasterxml.jackson.databind.ser.AnyGetterWriter",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.returnTypeChanged",
-        "old": "method T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::get(int)",
-        "new": "method T com.datastax.oss.driver.api.core.data.CqlVector<T>::get(int)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "ignore": true,
+        "code": "java.class.nonFinalClassInheritsFromNewClass",
+        "old": "class com.fasterxml.jackson.databind.ser.AnyGetterWriter",
+        "new": "class com.fasterxml.jackson.databind.ser.AnyGetterWriter",
+        "superClass": "com.fasterxml.jackson.databind.introspect.ConcreteBeanPropertyBase",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Iterator<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::iterator()",
-        "new": "method java.util.Iterator<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::iterator()",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "ignore": true,
+        "code": "java.method.abstractMethodAdded",
+        "new": "method com.fasterxml.jackson.databind.ser.DefaultSerializerProvider com.fasterxml.jackson.databind.ser.DefaultSerializerProvider::withCaches(com.fasterxml.jackson.databind.cfg.CacheProvider)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.method.parameterTypeChanged",
-        "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(===V[]===)",
-        "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(===V[]===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(V[])",
-        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(V[])",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(V[])",
-        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(V[])",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(===java.util.List<V>===)",
-        "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(===java.util.List<V>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(java.util.List<V>)",
-        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(java.util.List<V>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(java.util.List<V>)",
-        "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(java.util.List<V>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "old": "parameter void com.fasterxml.jackson.databind.ser.impl.ReadOnlyClassToSerializerMap::<init>(===java.util.Map<com.fasterxml.jackson.databind.util.TypeKey, com.fasterxml.jackson.databind.JsonSerializer<java.lang.Object>>===)",
+        "new": "parameter void com.fasterxml.jackson.databind.ser.impl.ReadOnlyClassToSerializerMap::<init>(===com.fasterxml.jackson.databind.util.LookupCache<com.fasterxml.jackson.databind.util.TypeKey, com.fasterxml.jackson.databind.JsonSerializer<java.lang.Object>>===)",
+        "parameterIndex": "0",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
+        "ignore": true,
         "code": "java.method.parameterTypeChanged",
-        "old": "parameter T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::set(int, ===T===)",
-        "new": "parameter T com.datastax.oss.driver.api.core.data.CqlVector<T>::set(int, ===T===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeChanged",
-        "old": "method T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::set(int, T)",
-        "new": "method T com.datastax.oss.driver.api.core.data.CqlVector<T>::set(int, T)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Spliterator<T> java.lang.Iterable<T>::spliterator() @ com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
-        "new": "method java.util.Spliterator<T> java.lang.Iterable<T>::spliterator() @ com.datastax.oss.driver.api.core.data.CqlVector<T>",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.stream.Stream<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::stream()",
-        "new": "method java.util.stream.Stream<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::stream()",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method com.datastax.oss.driver.api.core.data.CqlVector<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::subVector(int, int)",
-        "new": "method com.datastax.oss.driver.api.core.data.CqlVector<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::subVector(int, int)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.class.noLongerImplementsInterface",
-        "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
-        "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
-        "interface": "java.lang.Iterable<T extends java.lang.Number>",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
-        "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.class.superTypeTypeParametersChanged",
-        "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
-        "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
-        "oldSuperType": "java.lang.Iterable<T extends java.lang.Number>",
-        "newSuperType": "java.lang.Iterable<T>",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===java.lang.Class<ElementT>===)",
-        "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===java.lang.Class<ElementT>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, ===java.lang.Class<ElementT>===)",
-        "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, ===java.lang.Class<ElementT>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, ===java.lang.Class<ElementT>===)",
-        "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, ===java.lang.Class<ElementT>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
-        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
-        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
-        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
-        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
-        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
-        "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
-        "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
-        "new": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
-        "new": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===com.datastax.oss.driver.api.core.type.reflect.GenericType<T>===)",
-        "new": "parameter <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===com.datastax.oss.driver.api.core.type.reflect.GenericType<T>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-        "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "old": "parameter com.fasterxml.jackson.databind.ser.impl.ReadOnlyClassToSerializerMap com.fasterxml.jackson.databind.ser.impl.ReadOnlyClassToSerializerMap::from(===java.util.HashMap<com.fasterxml.jackson.databind.util.TypeKey, com.fasterxml.jackson.databind.JsonSerializer<java.lang.Object>>===)",
+        "new": "parameter com.fasterxml.jackson.databind.ser.impl.ReadOnlyClassToSerializerMap com.fasterxml.jackson.databind.ser.impl.ReadOnlyClassToSerializerMap::from(===com.fasterxml.jackson.databind.util.LookupCache<com.fasterxml.jackson.databind.util.TypeKey, com.fasterxml.jackson.databind.JsonSerializer<java.lang.Object>>===)",
+        "parameterIndex": "0",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-        "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.ser.std.BeanSerializerBase._anyGetterWriter",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===java.lang.Class<T>===)",
-        "new": "parameter <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===java.lang.Class<T>===)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "ignore": true,
+        "code": "java.class.nonFinalClassInheritsFromNewClass",
+        "old": "class com.fasterxml.jackson.databind.type.ResolvedRecursiveType",
+        "new": "class com.fasterxml.jackson.databind.type.ResolvedRecursiveType",
+        "superClass": "com.fasterxml.jackson.databind.type.IdentityEqualityType",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
-        "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.type.TypeFactory.CORE_TYPE_CLASS",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.generics.formalTypeParameterChanged",
-        "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
-        "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
-        "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.type.TypeFactory::<init>(com.fasterxml.jackson.databind.util.LRUMap<java.lang.Object, com.fasterxml.jackson.databind.JavaType>, com.fasterxml.jackson.databind.type.TypeParser, com.fasterxml.jackson.databind.type.TypeModifier[], java.lang.ClassLoader)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.class.nonPublicPartOfAPI",
-        "old": "class com.datastax.oss.driver.internal.core.config.typesafe.TypesafeDriverExecutionProfile.Base",
-        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
+        "ignore": true,
+        "code": "java.method.removed",
+        "old": "method void com.fasterxml.jackson.databind.type.TypeFactory::<init>(com.fasterxml.jackson.databind.util.LRUMap<java.lang.Object, com.fasterxml.jackson.databind.JavaType>)",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.class.nonPublicPartOfAPI",
-        "old": "class com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer",
-        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method com.fasterxml.jackson.databind.JavaType com.fasterxml.jackson.databind.type.TypeParser::parseType(com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer) throws java.lang.IllegalArgumentException",
+        "new": "method com.fasterxml.jackson.databind.JavaType com.fasterxml.jackson.databind.type.TypeParser::parseType(com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer, int) throws java.lang.IllegalArgumentException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.class.nonPublicPartOfAPI",
-        "old": "class org.apache.tinkerpop.shaded.jackson.databind.type.TypeParser.MyTokenizer",
-        "justification": "CASSJAVA-102: Fix spurious complaints about optional dependencies"
+        "ignore": true,
+        "code": "java.method.numberOfParametersChanged",
+        "old": "method java.util.List<com.fasterxml.jackson.databind.JavaType> com.fasterxml.jackson.databind.type.TypeParser::parseTypes(com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer) throws java.lang.IllegalArgumentException",
+        "new": "method java.util.List<com.fasterxml.jackson.databind.JavaType> com.fasterxml.jackson.databind.type.TypeParser::parseTypes(com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer, int) throws java.lang.IllegalArgumentException",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.class.externalClassExposedInAPI",
-        "justification": "CASSJAVA-102: Migrate revapi config into dedicated config files, ported from pom.xml"
+        "ignore": true,
+        "code": "java.field.removed",
+        "old": "field com.fasterxml.jackson.databind.util.LRUMap<K, V>._jdkSerializeMaxEntries",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.varargOverloadsOnlyDifferInVarargParameter",
-        "justification": "CASSJAVA-102: Migrate revapi config into dedicated config files, ported from pom.xml"
+        "ignore": true,
+        "code": "java.field.typeChanged",
+        "old": "field com.fasterxml.jackson.databind.util.LRUMap<K, V>._map",
+        "new": "field com.fasterxml.jackson.databind.util.LRUMap<K, V>._map",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       },
       {
-        "code": "java.method.addedToInterface",
-        "new": "method java.util.Optional<com.datastax.oss.driver.api.core.tracker.RequestIdGenerator> com.datastax.oss.driver.api.core.context.DriverContext::getRequestIdGenerator()",
-        "justification": "CASSJAVA-97: Let users inject an ID for each request and write to the custom payload"
+        "ignore": true,
+        "code": "java.field.serialVersionUIDChanged",
+        "old": "field com.fasterxml.jackson.databind.util.LRUMap<K, V>.serialVersionUID",
+        "new": "field com.fasterxml.jackson.databind.util.LRUMap<K, V>.serialVersionUID",
+        "oldSerialVersionUID": "1",
+        "newSerialVersionUID": "2",
+        "justification": "ADD YOUR EXPLANATION FOR THE NECESSITY OF THIS CHANGE"
       }
     ]
   }
diff --git a/mapper-runtime/revapi.json b/mapper-runtime/revapi.json
index 3dc2ea21671..5e6fca667bd 100644
--- a/mapper-runtime/revapi.json
+++ b/mapper-runtime/revapi.json
@@ -17,60 +17,6 @@
       }
     },
     "ignore": [
-      {
-        "regex": true,
-        "code": "java.annotation.attributeValueChanged",
-        "old": "@interface com\\.datastax\\.oss\\.driver\\.api\\.mapper\\.annotations\\..*",
-        "annotationType": "java.lang.annotation.Retention",
-        "attribute": "value",
-        "oldValue": "java.lang.annotation.RetentionPolicy.CLASS",
-        "newValue": "java.lang.annotation.RetentionPolicy.RUNTIME",
-        "justification": "JAVA-2369: Change mapper annotations retention to runtime"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "@interface com.datastax.oss.driver.api.mapper.annotations.Computed",
-        "new": "@interface com.datastax.oss.driver.api.mapper.annotations.Computed",
-        "annotation": "@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)",
-        "justification": "Oversight, should have been annotated this way from the start"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "@interface com.datastax.oss.driver.api.mapper.annotations.Computed",
-        "new": "@interface com.datastax.oss.driver.api.mapper.annotations.Computed",
-        "annotation": "@java.lang.annotation.Target({java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD})",
-        "justification": "Oversight, should have been annotated this way from the start"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "@interface com.datastax.oss.driver.api.mapper.annotations.TransientProperties",
-        "new": "@interface com.datastax.oss.driver.api.mapper.annotations.TransientProperties",
-        "annotation": "@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)",
-        "justification": "Oversight, should have been annotated this way from the start"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "@interface com.datastax.oss.driver.api.mapper.annotations.TransientProperties",
-        "new": "@interface com.datastax.oss.driver.api.mapper.annotations.TransientProperties",
-        "annotation": "@java.lang.annotation.Target({java.lang.annotation.ElementType.TYPE})",
-        "justification": "Oversight, should have been annotated this way from the start"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method java.lang.String com.datastax.oss.driver.api.mapper.MapperContext::getExecutionProfileName()",
-        "justification": "JAVA-2633: Add execution profile argument to DAO factory method (accept API break -- it's unlikely that MapperContext will be implemented outside of the driver)"
-
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.core.config.DriverExecutionProfile com.datastax.oss.driver.api.mapper.MapperContext::getExecutionProfile()",
-        "justification": "JAVA-2633: Add execution profile argument to DAO factory method (accept API break -- it's unlikely that MapperContext will be implemented outside of the driver)"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.mapper.result.MapperResultProducer com.datastax.oss.driver.api.mapper.MapperContext::getResultProducer(com.datastax.oss.driver.api.core.type.reflect.GenericType<?>)",
-        "justification": "JAVA-2792: Allow custom results in the mapper (accept API break -- it's unlikely that MapperContext will be implemented outside of the driver)"
-      }
     ]
   }
 }
diff --git a/pom.xml b/pom.xml
index 3948997b1ba..467373ae7d1 100644
--- a/pom.xml
+++ b/pom.xml
@@ -69,7 +69,7 @@
     <!-- when changing version also update version in LICENSE_binary  -->
     <reactive-streams.version>1.0.3</reactive-streams.version>
     <json.version>20230227</json.version>
-    <jackson.version>2.13.5</jackson.version>
+    <jackson.version>2.20.1</jackson.version>
     <jackson-databind.version>${jackson.version}</jackson-databind.version>
     <!-- optional dependencies -->
     <snappy.version>1.1.10.1</snappy.version>
diff --git a/query-builder/revapi.json b/query-builder/revapi.json
index ed97379332c..870924ba474 100644
--- a/query-builder/revapi.json
+++ b/query-builder/revapi.json
@@ -16,2771 +16,6 @@
       }
     },
     "ignore": [
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method <T> com.datastax.oss.driver.api.querybuilder.insert.JsonInsert com.datastax.oss.driver.api.querybuilder.insert.InsertInto::json(T, com.datastax.oss.driver.api.core.type.codec.TypeCodec<T>)",
-        "justification": "JAVA-2182: Add insertInto().json() variant that takes an object in QueryBuilder"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifExists()",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifExists()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifRaw(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifRaw(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition[])",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition[])",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.condition.Condition>)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.condition.Condition>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifExists() @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifExists() @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition[]) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition[]) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.condition.Condition>) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.condition.Condition>) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.delete.Delete",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.delete.DeleteSelection",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[])",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[])",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>::withDurableWrites(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterKeyspace",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>::withDurableWrites(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterKeyspace",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterKeyspace",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterKeyspace",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>::withDurableWrites(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterKeyspaceStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>::withDurableWrites(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterKeyspaceStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterKeyspaceStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterKeyspaceStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterMaterializedViewStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.AlterTableWithOptionsEnd",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateIndex",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateIndex",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>::withDurableWrites(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateKeyspace",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>::withDurableWrites(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateKeyspace",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateKeyspace",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateKeyspace",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedView",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewPrimaryKey",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewSelectionWithColumns",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhere",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateMaterializedViewWhereStart",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTable",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.CreateTableWithOptions",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>::withDurableWrites(boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>::withDurableWrites(boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.KeyspaceOptions<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression()",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression()",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression()",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression()",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression()",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withBloomFilterFpChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCDC(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCaching(boolean, com.datastax.oss.driver.api.querybuilder.SchemaBuilder.RowsPerPartition) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrder(java.util.Map<java.lang.String, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>::withClusteringOrderByIds(java.util.Map<com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.metadata.schema.ClusteringOrder>)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withComment(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompaction(com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<?>) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withCompression(java.lang.String, int, double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDcLocalReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDefaultTimeToLiveSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression() @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withDeflateCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withGcGraceSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression() @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withLZ4Compression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMaxIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMemtableFlushPeriodInMs(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withMinIndexInterval(int) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withNoCompression() @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withReadRepairChance(double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression() @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSnappyCompression(int, double) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationOptions<SelfT>>>::withSpeculativeRetry(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.RelationStructure<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withEnabled(boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withEnabled(boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneCompactionIntervalInSeconds(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneCompactionIntervalInSeconds(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneThreshold(double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneThreshold(double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withUncheckedTombstoneCompaction(boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withUncheckedTombstoneCompaction(boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withEnabled(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withEnabled(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>::withSSTableSizeInMB(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>::withSSTableSizeInMB(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneCompactionIntervalInSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneCompactionIntervalInSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneThreshold(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneThreshold(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withUncheckedTombstoneCompaction(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withUncheckedTombstoneCompaction(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.LeveledCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withBucketHigh(double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withBucketHigh(double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withBucketLow(double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withBucketLow(double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withColdReadsToOmit(double)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withColdReadsToOmit(double)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withEnabled(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withEnabled(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMaxThreshold(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMaxThreshold(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMinSSTableSizeInBytes(long)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMinSSTableSizeInBytes(long)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMinThreshold(int)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMinThreshold(int)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withOnlyPurgeRepairedTombstones(boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withOnlyPurgeRepairedTombstones(boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneCompactionIntervalInSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneCompactionIntervalInSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneThreshold(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneThreshold(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withUncheckedTombstoneCompaction(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withUncheckedTombstoneCompaction(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withBucketHigh(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withBucketHigh(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withBucketLow(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withBucketLow(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withColdReadsToOmit(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withColdReadsToOmit(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>::withCompactionWindow(long, com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy.CompactionWindowUnit)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>::withCompactionWindow(long, com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy.CompactionWindowUnit)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withEnabled(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withEnabled(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMaxThreshold(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMaxThreshold(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMinSSTableSizeInBytes(long) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMinSSTableSizeInBytes(long) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMinThreshold(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withMinThreshold(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withOnlyPurgeRepairedTombstones(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.SizeTieredCompactionStrategy<SelfT>>>::withOnlyPurgeRepairedTombstones(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.OptionProvider<SelfT>>>::withOption(java.lang.String, java.lang.Object) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>::withTimestampResolution(com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy.TimestampResolution)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>::withTimestampResolution(com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy.TimestampResolution)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneCompactionIntervalInSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneCompactionIntervalInSeconds(int) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneThreshold(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withTombstoneThreshold(double) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withUncheckedTombstoneCompaction(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.CompactionStrategy<SelfT>>>::withUncheckedTombstoneCompaction(boolean) @ com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>::withUnsafeAggressiveSSTableExpiration(boolean)",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT extends com.datastax.oss.driver.api.querybuilder.schema.compaction.TimeWindowCompactionStrategy<SelfT>>>::withUnsafeAggressiveSSTableExpiration(boolean)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.select.Select",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifExists() @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifExists() @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::ifRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition[]) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(com.datastax.oss.driver.api.querybuilder.condition.Condition[]) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.condition.Condition>) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT extends com.datastax.oss.driver.api.querybuilder.condition.ConditionalStatement<SelfT>>>::if_(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.condition.Condition>) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.update.Update",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(com.datastax.oss.driver.api.querybuilder.relation.Relation[]) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::where(java.lang.Iterable<com.datastax.oss.driver.api.querybuilder.relation.Relation>) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereCustomIndex(java.lang.String, com.datastax.oss.driver.api.querybuilder.term.Term) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "new": "method SelfT com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT extends com.datastax.oss.driver.api.querybuilder.relation.OngoingWhereClause<SelfT>>>::whereRaw(java.lang.String) @ com.datastax.oss.driver.api.querybuilder.update.UpdateWithAssignments",
-        "annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
-        "justification": "JAVA-2161: Annotate mutating methods with @CheckReturnValue"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.querybuilder.insert.Insert com.datastax.oss.driver.api.querybuilder.insert.Insert::usingTtl(com.datastax.oss.driver.api.querybuilder.BindMarker)",
-        "justification": "JAVA-2210: Add ability to set TTL for modification queries"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.querybuilder.insert.Insert com.datastax.oss.driver.api.querybuilder.insert.Insert::usingTtl(int)",
-        "justification": "JAVA-2210: Add ability to set TTL for modification queries"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.querybuilder.update.UpdateStart com.datastax.oss.driver.api.querybuilder.update.UpdateStart::usingTtl(com.datastax.oss.driver.api.querybuilder.BindMarker)",
-        "justification": "JAVA-2210: Add ability to set TTL for modification queries"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.querybuilder.update.UpdateStart com.datastax.oss.driver.api.querybuilder.update.UpdateStart::usingTtl(int)",
-        "justification": "JAVA-2210: Add ability to set TTL for modification queries"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.querybuilder.select.Select com.datastax.oss.driver.api.querybuilder.select.Select::orderByAnnOf(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<?>)",
-        "justification": "JAVA-3118: Add support for vector data type in Schema Builder, QueryBuilder"
-      },
-      {
-        "code": "java.method.addedToInterface",
-        "new": "method com.datastax.oss.driver.api.querybuilder.select.Select com.datastax.oss.driver.api.querybuilder.select.Select::orderByAnnOf(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<?>)",
-        "justification": "JAVA-3118: Add support for vector data type in Schema Builder, QueryBuilder"
-      },
       {
         "code": "java.method.varargOverloadsOnlyDifferInVarargParameter",
         "justification": "CASSJAVA-102: Suppress newly-supported varargs check"
diff --git a/test-infra/revapi.json b/test-infra/revapi.json
index 293d9f4d142..a16d06d75da 100644
--- a/test-infra/revapi.json
+++ b/test-infra/revapi.json
@@ -17,180 +17,6 @@
       }
     },
     "ignore": [
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Set<java.net.InetSocketAddress> com.datastax.oss.driver.api.testinfra.CassandraResourceRule::getContactPoints()",
-        "new": "method java.util.Set<com.datastax.oss.driver.api.core.metadata.EndPoint> com.datastax.oss.driver.api.testinfra.CassandraResourceRule::getContactPoints()",
-        "justification": "JAVA-2165: Abstract node connection information"
-      },
-      {
-        "code": "java.method.numberOfParametersChanged",
-        "old": "method void com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::init(java.util.Map<java.net.InetSocketAddress, com.datastax.oss.driver.api.core.metadata.Node>, com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy.DistanceReporter, java.util.Set<java.net.InetSocketAddress>)",
-        "new": "method void com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::init(java.util.Map<java.util.UUID, com.datastax.oss.driver.api.core.metadata.Node>, com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy.DistanceReporter)",
-        "justification": "JAVA-2165: Abstract node connection information"
-      },
-      {
-        "code": "java.method.returnTypeTypeParametersChanged",
-        "old": "method java.util.Set<java.net.InetSocketAddress> com.datastax.oss.driver.api.testinfra.simulacron.SimulacronRule::getContactPoints()",
-        "new": "method java.util.Set<com.datastax.oss.driver.api.core.metadata.EndPoint> com.datastax.oss.driver.api.testinfra.simulacron.SimulacronRule::getContactPoints()",
-        "justification": "JAVA-2165: Abstract node connection information"
-      },
-      {
-        "code": "java.method.returnTypeChanged",
-        "old": "method com.datastax.oss.driver.internal.core.config.typesafe.DefaultDriverConfigLoaderBuilder com.datastax.oss.driver.api.testinfra.session.SessionUtils::configLoaderBuilder()",
-        "new": "method com.datastax.oss.driver.api.core.config.ProgrammaticDriverConfigLoaderBuilder com.datastax.oss.driver.api.testinfra.session.SessionUtils::configLoaderBuilder()",
-        "justification": "JAVA-2201: Expose a public API for programmatic config"
-      },
-      {
-        "code": "java.annotation.removed",
-        "old": "parameter java.util.Queue<com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::newQueryPlan(===com.datastax.oss.driver.api.core.session.Request===, com.datastax.oss.driver.api.core.session.Session)",
-        "new": "parameter java.util.Queue<com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::newQueryPlan(===com.datastax.oss.driver.api.core.session.Request===, com.datastax.oss.driver.api.core.session.Session)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Method arguments were mistakenly annotated with @NonNull"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "parameter java.util.Queue<com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::newQueryPlan(===com.datastax.oss.driver.api.core.session.Request===, com.datastax.oss.driver.api.core.session.Session)",
-        "new": "parameter java.util.Queue<com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::newQueryPlan(===com.datastax.oss.driver.api.core.session.Request===, com.datastax.oss.driver.api.core.session.Session)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.Nullable",
-        "justification": "Method arguments were mistakenly annotated with @NonNull"
-      },
-      {
-        "code": "java.annotation.removed",
-        "old": "parameter java.util.Queue<com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::newQueryPlan(com.datastax.oss.driver.api.core.session.Request, ===com.datastax.oss.driver.api.core.session.Session===)",
-        "new": "parameter java.util.Queue<com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::newQueryPlan(com.datastax.oss.driver.api.core.session.Request, ===com.datastax.oss.driver.api.core.session.Session===)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.NonNull",
-        "justification": "Method arguments were mistakenly annotated with @NonNull"
-      },
-      {
-        "code": "java.annotation.added",
-        "old": "parameter java.util.Queue<com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::newQueryPlan(com.datastax.oss.driver.api.core.session.Request, ===com.datastax.oss.driver.api.core.session.Session===)",
-        "new": "parameter java.util.Queue<com.datastax.oss.driver.api.core.metadata.Node> com.datastax.oss.driver.api.testinfra.loadbalancing.SortingLoadBalancingPolicy::newQueryPlan(com.datastax.oss.driver.api.core.session.Request, ===com.datastax.oss.driver.api.core.session.Session===)",
-        "annotation": "@edu.umd.cs.findbugs.annotations.Nullable",
-        "justification": "Method arguments were mistakenly annotated with @NonNull"
-      },
-      {
-        "code": "java.method.parameterTypeParameterChanged",
-        "old": "parameter com.datastax.oss.driver.api.testinfra.simulacron.QueryCounter.QueryCounterBuilder com.datastax.oss.driver.api.testinfra.simulacron.QueryCounter::builder(===com.datastax.oss.simulacron.server.BoundTopic===)",
-        "new": "parameter com.datastax.oss.driver.api.testinfra.simulacron.QueryCounter.QueryCounterBuilder com.datastax.oss.driver.api.testinfra.simulacron.QueryCounter::builder(===com.datastax.oss.simulacron.server.BoundTopic<?, ?>===)",
-        "justification": "Fix usage of raw type BoundTopic"
-      },
-      {
-        "code": "java.field.constantValueChanged",
-        "old": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DEFAULT_CLIENT_KEYSTORE_PASSWORD",
-        "new": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DEFAULT_CLIENT_KEYSTORE_PASSWORD",
-        "justification": "JAVA-2620: Use clearly dummy passwords in tests"
-      },
-      {
-        "code": "java.field.constantValueChanged",
-        "old": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DEFAULT_CLIENT_TRUSTSTORE_PASSWORD",
-        "new": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DEFAULT_CLIENT_TRUSTSTORE_PASSWORD",
-        "justification": "JAVA-2620: Use clearly dummy passwords in tests"
-      },
-      {
-        "code": "java.field.constantValueChanged",
-        "old": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DEFAULT_SERVER_KEYSTORE_PASSWORD",
-        "new": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DEFAULT_SERVER_KEYSTORE_PASSWORD",
-        "justification": "JAVA-2620: Use clearly dummy passwords in tests"
-      },
-      {
-        "code": "java.field.constantValueChanged",
-        "old": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DEFAULT_SERVER_TRUSTSTORE_PASSWORD",
-        "new": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DEFAULT_SERVER_TRUSTSTORE_PASSWORD",
-        "justification": "JAVA-2620: Use clearly dummy passwords in tests"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class com.datastax.oss.simulacron.common.cluster.ClusterSpec",
-        "justification":"Dependency was made optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class com.datastax.oss.simulacron.common.cluster.ClusterSpec.Builder",
-        "justification":"Dependency was made optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class com.datastax.oss.simulacron.common.cluster.QueryLog",
-        "justification":"Dependency was made optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class com.datastax.oss.simulacron.server.BoundCluster",
-        "justification":"Dependency was made optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class com.datastax.oss.simulacron.server.BoundTopic",
-        "justification":"Dependency was made optional"
-      },
-      {
-        "code": "java.missing.newClass",
-        "new": "missing-class com.datastax.oss.simulacron.server.Server",
-        "justification":"Dependency was made optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class com.datastax.oss.simulacron.common.cluster.ClusterSpec",
-        "new": "missing-class com.datastax.oss.simulacron.common.cluster.ClusterSpec",
-        "justification": "Dependency was made optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class com.datastax.oss.simulacron.common.cluster.ClusterSpec.Builder",
-        "new": "missing-class com.datastax.oss.simulacron.common.cluster.ClusterSpec.Builder",
-        "justification": "Dependency was made optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class com.datastax.oss.simulacron.common.cluster.QueryLog",
-        "new": "missing-class com.datastax.oss.simulacron.common.cluster.QueryLog",
-        "justification": "Dependency was made optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class com.datastax.oss.simulacron.server.BoundCluster",
-        "new": "missing-class com.datastax.oss.simulacron.server.BoundCluster",
-        "justification": "Dependency was made optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class com.datastax.oss.simulacron.server.BoundTopic",
-        "new": "missing-class com.datastax.oss.simulacron.server.BoundTopic",
-        "justification": "Dependency was made optional"
-      },
-      {
-        "code": "java.missing.oldClass",
-        "old": "missing-class com.datastax.oss.simulacron.server.Server",
-        "new": "missing-class com.datastax.oss.simulacron.server.Server",
-        "justification": "Dependency was made optional"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method void com.datastax.oss.driver.api.testinfra.ccm.CcmRule::reloadCore(int, java.lang.String, java.lang.String, boolean)",
-        "justification": "Modifying the state of a globally shared CCM instance is dangerous"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method java.util.Optional<com.datastax.oss.driver.api.core.Version> com.datastax.oss.driver.api.testinfra.ccm.BaseCcmRule::getDseVersion()",
-        "justification": "Method has been replaced with more generic isDistributionOf(BackendType) and getDistributionVersion()"
-      },
-      {
-        "code": "java.field.removed",
-        "old": "field com.datastax.oss.driver.api.testinfra.ccm.CcmBridge.DSE_ENABLEMENT",
-        "justification": "Method has been replaced with more generic isDistributionOf(BackendType) and getDistributionVersion()"
-      },
-      {
-        "code": "java.method.nowStatic",
-        "old": "method com.datastax.oss.driver.api.core.Version com.datastax.oss.driver.api.testinfra.ccm.CcmBridge::getCassandraVersion()",
-        "new": "method com.datastax.oss.driver.api.core.Version com.datastax.oss.driver.api.testinfra.ccm.CcmBridge::getCassandraVersion()",
-        "justification": "Previous and current implemntation do not relay on non-static fields"
-      },
-      {
-        "code": "java.method.removed",
-        "old": "method java.util.Optional<com.datastax.oss.driver.api.core.Version> com.datastax.oss.driver.api.testinfra.ccm.CcmBridge::getDseVersion()",
-        "justification": "Method has been replaced with more generic isDistributionOf(BackendType) and getDistributionVersion()"
-      }
     ]
   }
 }

From 283d3a783f2be06d6caab792f543eb81be053119 Mon Sep 17 00:00:00 2001
From: absurdfarce <absurdfarce@apache.org>
Date: Wed, 20 Aug 2025 18:37:32 -0500
Subject: [PATCH 109/126] CASSJAVA-108 Update ESRI (and remove org.json)
 dependencies

patch by Bret McGuire; reviewed by Bret McGuire and Lukasz Antoniak
reference: https://github.com/apache/cassandra-java-driver/pull/2052
---
 .../core/data/geometry/DefaultGeometry.java   |  2 +-
 .../data/geometry/DefaultLineStringTest.java  | 25 ++++++++++-
 .../core/data/geometry/DefaultPointTest.java  | 19 +++++++-
 .../data/geometry/DefaultPolygonTest.java     | 43 ++++++++++++++++++-
 .../core/insights/PlatformInfoFinderTest.java |  3 +-
 .../resources/insights/test-dependencies.txt  |  1 -
 .../internal/osgi/support/BundleOptions.java  |  5 +--
 pom.xml                                       |  8 +---
 upgrade_guide/README.md                       |  9 ++++
 9 files changed, 95 insertions(+), 20 deletions(-)

diff --git a/core/src/main/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultGeometry.java b/core/src/main/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultGeometry.java
index 885d9bd48b7..9b1148dff69 100644
--- a/core/src/main/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultGeometry.java
+++ b/core/src/main/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultGeometry.java
@@ -176,7 +176,7 @@ public boolean equals(Object o) {
       return false;
     }
     DefaultGeometry that = (DefaultGeometry) o;
-    return this.getOgcGeometry().equals(that.getOgcGeometry());
+    return this.getOgcGeometry().equals((Object) that.getOgcGeometry());
   }
 
   @Override
diff --git a/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultLineStringTest.java b/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultLineStringTest.java
index 38dc84549c4..4bbaa629d60 100644
--- a/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultLineStringTest.java
+++ b/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultLineStringTest.java
@@ -22,7 +22,11 @@
 
 import com.datastax.dse.driver.api.core.data.geometry.LineString;
 import com.datastax.dse.driver.api.core.data.geometry.Point;
+import com.datastax.oss.driver.shaded.guava.common.collect.Streams;
 import com.esri.core.geometry.ogc.OGCLineString;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import org.junit.Test;
@@ -101,8 +105,25 @@ public void should_parse_valid_geo_json() {
   }
 
   @Test
-  public void should_convert_to_geo_json() {
-    assertThat(lineString.asGeoJson()).isEqualTo(json);
+  public void should_convert_to_geo_json() throws Exception {
+
+    ObjectMapper mapper = new ObjectMapper();
+    JsonNode root = mapper.readTree(lineString.asGeoJson());
+    assertThat(root.get("type").toString()).isEqualTo("\"LineString\"");
+
+    double expected[][] = {{30.0, 10.0}, {10.0, 30.0}, {40.0, 40.0}};
+    JsonNode coordinatesNode = root.get("coordinates");
+    assertThat(coordinatesNode.isArray()).isTrue();
+    ArrayNode coordinatesArray = (ArrayNode) coordinatesNode;
+    assertThat(coordinatesArray.size()).isEqualTo(3);
+    for (int i = 0; i < expected.length; ++i) {
+
+      JsonNode elemNode = coordinatesArray.get(i);
+      assertThat(elemNode.isArray()).isTrue();
+      ArrayNode elemArray = (ArrayNode) elemNode;
+      double[] arr = Streams.stream(elemArray.elements()).mapToDouble(JsonNode::asDouble).toArray();
+      assertThat(arr).isEqualTo(expected[i]);
+    }
   }
 
   @Test
diff --git a/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultPointTest.java b/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultPointTest.java
index 1e3a7366741..d4d867d8bc3 100644
--- a/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultPointTest.java
+++ b/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultPointTest.java
@@ -21,7 +21,11 @@
 import static org.assertj.core.api.Fail.fail;
 
 import com.datastax.dse.driver.api.core.data.geometry.Point;
+import com.datastax.oss.driver.shaded.guava.common.collect.Streams;
 import com.esri.core.geometry.ogc.OGCPoint;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import org.junit.Test;
@@ -83,8 +87,19 @@ public void should_parse_valid_geo_json() {
   }
 
   @Test
-  public void should_convert_to_geo_json() {
-    assertThat(point.asGeoJson()).isEqualTo(json);
+  public void should_convert_to_geo_json() throws Exception {
+
+    ObjectMapper mapper = new ObjectMapper();
+    JsonNode root = mapper.readTree(point.asGeoJson());
+    assertThat(root.get("type").toString()).isEqualTo("\"Point\"");
+
+    double expected[] = {1.1, 2.2};
+    JsonNode coordinatesNode = root.get("coordinates");
+    assertThat(coordinatesNode.isArray()).isTrue();
+    ArrayNode coordinatesArray = (ArrayNode) coordinatesNode;
+    double[] arr =
+        Streams.stream(coordinatesArray.elements()).mapToDouble(JsonNode::asDouble).toArray();
+    assertThat(arr).isEqualTo(expected);
   }
 
   @Test
diff --git a/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultPolygonTest.java b/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultPolygonTest.java
index d86e9cdc269..20795074806 100644
--- a/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultPolygonTest.java
+++ b/core/src/test/java/com/datastax/dse/driver/internal/core/data/geometry/DefaultPolygonTest.java
@@ -23,7 +23,11 @@
 import com.datastax.dse.driver.api.core.data.geometry.LineString;
 import com.datastax.dse.driver.api.core.data.geometry.Point;
 import com.datastax.dse.driver.api.core.data.geometry.Polygon;
+import com.datastax.oss.driver.shaded.guava.common.collect.Streams;
 import com.esri.core.geometry.ogc.OGCPolygon;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import org.junit.Test;
@@ -109,8 +113,43 @@ public void should_parse_valid_geo_json() {
   }
 
   @Test
-  public void should_convert_to_geo_json() {
-    assertThat(polygon.asGeoJson()).isEqualTo(json);
+  public void should_convert_to_geo_json() throws Exception {
+
+    ObjectMapper mapper = new ObjectMapper();
+    JsonNode root = mapper.readTree(polygon.asGeoJson());
+    assertThat(root.get("type").toString()).isEqualTo("\"Polygon\"");
+
+    /*
+     Note that the order of values in expected differs from the order of insertion when creating
+     the Polygon.  OGC expects the "exterior" ring of the polygon to be listed in counter-clockwise
+     order... and that's what this sequence represents (draw it out on a graph if you don't believe me).
+
+     Weirdly this is the opposite of the order used for this test when we were using ESRI 1.2.1.
+     That fact (combined with the fact that only ESRI classes are used for serialization here) makes me
+     think that the earlier version was just doing it wrong... or at least doing it in a way that
+     didn't agree with the spec.  Either way it is clearly correct that we should go counter-clockwise...
+     so that's what we're doing.
+    */
+    double expected[][] = {{30.0, 10.0}, {40.0, 40.0}, {20.0, 40.0}, {10.0, 20.0}, {30.0, 10.0}};
+    JsonNode coordinatesNode = root.get("coordinates");
+    assertThat(coordinatesNode.isArray()).isTrue();
+    ArrayNode coordinatesArray = (ArrayNode) coordinatesNode;
+
+    // There's an extra layer here, presumably indicating the bounds of the polygon
+    assertThat(coordinatesArray.size()).isEqualTo(1);
+    JsonNode polygonNode = coordinatesArray.get(0);
+    assertThat(polygonNode.isArray()).isTrue();
+    ArrayNode polygonArray = (ArrayNode) polygonNode;
+
+    assertThat(polygonArray.size()).isEqualTo(5);
+    for (int i = 0; i < expected.length; ++i) {
+
+      JsonNode elemNode = polygonArray.get(i);
+      assertThat(elemNode.isArray()).isTrue();
+      ArrayNode elemArray = (ArrayNode) elemNode;
+      double[] arr = Streams.stream(elemArray.elements()).mapToDouble(JsonNode::asDouble).toArray();
+      assertThat(arr).isEqualTo(expected[i]);
+    }
   }
 
   @Test
diff --git a/core/src/test/java/com/datastax/dse/driver/internal/core/insights/PlatformInfoFinderTest.java b/core/src/test/java/com/datastax/dse/driver/internal/core/insights/PlatformInfoFinderTest.java
index 2a098363d46..470a19b51e3 100644
--- a/core/src/test/java/com/datastax/dse/driver/internal/core/insights/PlatformInfoFinderTest.java
+++ b/core/src/test/java/com/datastax/dse/driver/internal/core/insights/PlatformInfoFinderTest.java
@@ -82,7 +82,6 @@ public void should_find_dependencies_from_file() {
     expected.put("com.github.jnr:jffi", withUnverifiedRuntimeVersion("1.2.16"));
     expected.put("io.netty:netty-buffer", withUnverifiedRuntimeVersion("4.0.56.Final"));
     expected.put("org.ow2.asm:asm-commons", withUnverifiedRuntimeVersion("5.0.3"));
-    expected.put("org.json:json", withUnverifiedRuntimeVersion("20090211"));
     expected.put("org.ow2.asm:asm-util", withUnverifiedRuntimeVersion("5.0.3"));
     expected.put("com.github.jnr:jnr-ffi", withUnverifiedRuntimeVersion("2.1.7"));
 
@@ -91,7 +90,7 @@ public void should_find_dependencies_from_file() {
         new PlatformInfoFinder(this::nullUrlProvider).fetchDependenciesFromFile(inputStream);
 
     // then
-    assertThat(stringStringMap).hasSize(28);
+    assertThat(stringStringMap).hasSize(27);
     assertThat(stringStringMap).isEqualTo(expected);
   }
 
diff --git a/core/src/test/resources/insights/test-dependencies.txt b/core/src/test/resources/insights/test-dependencies.txt
index e9186a35e6b..b780fe556b8 100644
--- a/core/src/test/resources/insights/test-dependencies.txt
+++ b/core/src/test/resources/insights/test-dependencies.txt
@@ -27,5 +27,4 @@ The following files have been resolved:
    org.ow2.asm:asm-analysis:jar:5.0.3:compile
    com.github.jnr:jnr-x86asm:jar:1.0.2:compile
    io.netty:netty-codec:jar:4.0.56.Final:compile
-   org.json:json:jar:20090211:compile
    com.github.jnr:jffi:jar:native:1.2.16:runtime
\ No newline at end of file
diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
index 63d11f8ee08..cb7e86b2a73 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
@@ -194,11 +194,10 @@ public static CompositeOption esriBundles() {
             CoreOptions.wrappedBundle(
                     mavenBundle("com.esri.geometry", "esri-geometry-api").versionAsInProject())
                 .exports("com.esri.core.geometry.*")
-                .imports("org.json", "org.codehaus.jackson")
+                .imports("com.fasterxml.jackson.*", "com.fasterxml.jackson.databind.*")
                 .bundleSymbolicName("com.esri.core.geometry")
                 .overwriteManifest(WrappedUrlProvisionOption.OverwriteMode.FULL),
-            mavenBundle("org.json", "json").versionAsInProject(),
-            mavenBundle("org.codehaus.jackson", "jackson-core-asl").versionAsInProject(),
+            mavenBundle("com.fasterxml.jackson.core", "jackson-core").versionAsInProject(),
             systemProperty("cassandra.geo").value("true"));
   }
 
diff --git a/pom.xml b/pom.xml
index 467373ae7d1..126279912da 100644
--- a/pom.xml
+++ b/pom.xml
@@ -58,7 +58,7 @@
     <hdrhistogram.version>2.1.12</hdrhistogram.version>
     <metrics.version>4.1.18</metrics.version>
     <netty.version>4.1.130.Final</netty.version>
-    <esri.version>1.2.1</esri.version>
+    <esri.version>2.2.4</esri.version>
     <!--
     When upgrading TinkerPop please upgrade the version matrix in
     manual/core/integration/README.md
@@ -68,7 +68,6 @@
     <slf4j.version>2.0.16</slf4j.version>
     <!-- when changing version also update version in LICENSE_binary  -->
     <reactive-streams.version>1.0.3</reactive-streams.version>
-    <json.version>20230227</json.version>
     <jackson.version>2.20.1</jackson.version>
     <jackson-databind.version>${jackson.version}</jackson-databind.version>
     <!-- optional dependencies -->
@@ -162,11 +161,6 @@
         <artifactId>esri-geometry-api</artifactId>
         <version>${esri.version}</version>
       </dependency>
-      <dependency>
-        <groupId>org.json</groupId>
-        <artifactId>json</artifactId>
-        <version>${json.version}</version>
-      </dependency>
       <dependency>
         <groupId>org.apache.tinkerpop</groupId>
         <artifactId>gremlin-core</artifactId>
diff --git a/upgrade_guide/README.md b/upgrade_guide/README.md
index 56d55aaab36..47f5be30746 100644
--- a/upgrade_guide/README.md
+++ b/upgrade_guide/README.md
@@ -19,6 +19,15 @@ under the License.
 
 ## Upgrade guide
 
+### 4.19.3
+
+#### Ordering of points in DefaultPolygon
+
+This version includes an update to the ESRI dependency which appears to be more strict about following the OGC
+requirement that points of a polygon should be returned in counter-clockwise order.  It's possible that
+previous versions of the driver could have returned these points in a different order so if your application
+relies on the ordering of points in a polygon make sure to test this behaviour when upgrading.
+
 ### 4.18.1
 
 #### Keystore reloading in DefaultSslEngineFactory

From de96ce864515b282e16c3a02eabf53fedc4e8227 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Mon, 2 Mar 2026 11:15:51 -0600
Subject: [PATCH 110/126] ninja-fix Update Jenkins label to Jammy

---
 Jenkinsfile-datastax | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Jenkinsfile-datastax b/Jenkinsfile-datastax
index 602f33101ca..9a7b7923f32 100644
--- a/Jenkinsfile-datastax
+++ b/Jenkinsfile-datastax
@@ -402,7 +402,7 @@ pipeline {
   }
 
   environment {
-    OS_VERSION = 'ubuntu/focal64/java-driver'
+    OS_VERSION = 'ubuntu/jammy64/java-driver'
     JABBA_SHELL = '/usr/lib/jabba/jabba.sh'
     CCM_ENVIRONMENT_SHELL = '/usr/local/bin/ccm_environment.sh'
     SERIAL_ITS_ARGUMENT = "-DskipSerialITs=${params.SKIP_SERIAL_ITS}"

From 3f5f3ac0841cab7b48fc6c3c83ac751312671adc Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Fri, 6 Mar 2026 00:08:35 -0600
Subject: [PATCH 111/126] Revert "ninja-fix Update Jenkins label to Jammy"

This reverts commit de96ce864515b282e16c3a02eabf53fedc4e8227.
---
 Jenkinsfile-datastax | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Jenkinsfile-datastax b/Jenkinsfile-datastax
index 9a7b7923f32..602f33101ca 100644
--- a/Jenkinsfile-datastax
+++ b/Jenkinsfile-datastax
@@ -402,7 +402,7 @@ pipeline {
   }
 
   environment {
-    OS_VERSION = 'ubuntu/jammy64/java-driver'
+    OS_VERSION = 'ubuntu/focal64/java-driver'
     JABBA_SHELL = '/usr/lib/jabba/jabba.sh'
     CCM_ENVIRONMENT_SHELL = '/usr/local/bin/ccm_environment.sh'
     SERIAL_ITS_ARGUMENT = "-DskipSerialITs=${params.SKIP_SERIAL_ITS}"

From 27e2bfa85d7a4132f7af76d05d53759027617b84 Mon Sep 17 00:00:00 2001
From: jasonk000 <jasonk@bluedevel.com>
Date: Sat, 9 Aug 2025 23:58:53 -0700
Subject: [PATCH 112/126] Fix race condition in ClockSeqAndNodeContainer

patch by Jason Koch; reviewed by Lukasz Antoniak and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/2050
---
 .../main/java/com/datastax/oss/driver/api/core/uuid/Uuids.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/uuid/Uuids.java b/core/src/main/java/com/datastax/oss/driver/api/core/uuid/Uuids.java
index 8dae31f3734..5d414884500 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/uuid/Uuids.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/uuid/Uuids.java
@@ -141,9 +141,8 @@ private long get() {
       if (!initialized) {
         synchronized (ClockSeqAndNodeContainer.class) {
           if (!initialized) {
-
-            initialized = true;
             val = makeClockSeqAndNode();
+            initialized = true;
           }
         }
       }

From bbd1998765befc7b673af147b40f31978affe5de Mon Sep 17 00:00:00 2001
From: David Stringer <dstringer@pingidentity.com>
Date: Tue, 25 Feb 2025 21:27:46 -0800
Subject: [PATCH 113/126] CASSJAVA-3: Fix ordering of LIMIT and PER PARTITION
 LIMIT clauses

patch by David Stringer; reviewed by Lukasz Antoniak and Bret McGuire
reference: https://github.com/apache/cassandra-java-driver/pull/2022
---
 .../querybuilder/select/DefaultSelect.java     | 18 +++++++++---------
 .../querybuilder/select/SelectLimitTest.java   |  6 ++++++
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java b/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
index e4b98ef6f53..3bacf72b0c5 100644
--- a/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
+++ b/query-builder/src/main/java/com/datastax/oss/driver/internal/querybuilder/select/DefaultSelect.java
@@ -425,15 +425,6 @@ public String asCql() {
 
     orderingClause.ifPresent(c -> c.appendTo(builder));
 
-    if (limit != null) {
-      builder.append(" LIMIT ");
-      if (limit instanceof BindMarker) {
-        ((BindMarker) limit).appendTo(builder);
-      } else {
-        builder.append(limit);
-      }
-    }
-
     if (perPartitionLimit != null) {
       builder.append(" PER PARTITION LIMIT ");
       if (perPartitionLimit instanceof BindMarker) {
@@ -443,6 +434,15 @@ public String asCql() {
       }
     }
 
+    if (limit != null) {
+      builder.append(" LIMIT ");
+      if (limit instanceof BindMarker) {
+        ((BindMarker) limit).appendTo(builder);
+      } else {
+        builder.append(limit);
+      }
+    }
+
     if (allowsFiltering) {
       builder.append(" ALLOW FILTERING");
     }
diff --git a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectLimitTest.java b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectLimitTest.java
index d617aa5673f..baef745b481 100644
--- a/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectLimitTest.java
+++ b/query-builder/src/test/java/com/datastax/oss/driver/api/querybuilder/select/SelectLimitTest.java
@@ -49,4 +49,10 @@ public void should_use_last_per_partition_limit_if_called_multiple_times() {
     assertThat(selectFrom("foo").all().perPartitionLimit(1).perPartitionLimit(2))
         .hasCql("SELECT * FROM foo PER PARTITION LIMIT 2");
   }
+
+  @Test
+  public void should_put_limit_after_partition_limit() {
+    assertThat(selectFrom("foo").all().perPartitionLimit(1).limit(1))
+        .hasCql("SELECT * FROM foo PER PARTITION LIMIT 1 LIMIT 1");
+  }
 }

From bf2b36fe1e71a24dfa0bc4fb6529c678cb68a7fa Mon Sep 17 00:00:00 2001
From: janehe <siyaoh4@uci.edu>
Date: Mon, 5 May 2025 19:36:30 -0700
Subject: [PATCH 114/126] CASSJAVA-30: Update CONTRIBUTING.md patch by Jane He;
 reviewed by Bret McGuire and Andy Tolbert

---
 CONTRIBUTING.md | 371 +++++++++++++++++++++++-------------------------
 README.md       |   2 +-
 pre-commit.sh   |   6 +-
 3 files changed, 186 insertions(+), 193 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 53857383cf2..d15d5921e82 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -17,42 +17,174 @@ specific language governing permissions and limitations
 under the License.
 -->
 
-# Contributing guidelines
+# Contributing to the Apache Cassandra Java Driver
+
+Thank you for your interest in contributing!  
+
+## Table of Contents
+- [Ways to Contribute](#ways-to-contribute)
+- [Contribution Process](#contribution-process)
+  - [Reporting Issues](#reporting-issues)
+  - [Submitting Changes (Pull Requests)](#submitting-changes-pull-requests)
+- [Development Setup](#development-setup)
+  - [Prerequisites](#prerequisites)
+  - [Building the Project](#building-the-project)
+  - [Running Tests](#running-tests)
+- [Coding Guidelines](#coding-guidelines)
+  - [General](#general)
+  - [Code Formatting and License Headers](#code-formatting-and-license-headers)
+  - [Javadoc](#javadoc)
+  - [Logging](#logging)
+  - [Don't abuse the stream API](#dont-abuse-the-stream-api)
+  - [Never assume a specific format for toString()](#never-assume-a-specific-format-for-tostring)
+  - [Concurrency annotations](#concurrency-annotations)
+  - [Nullability annotations](#nullability-annotations)
+- [Coding Guidelines for Tests](#coding-guidelines-for-tests)
+  - [Coding style -- test code](#coding-style----test-code)
+  - [Unit tests](#unit-tests)
+  - [Integration tests](#integration-tests)
 
-## Code formatting
+## Ways to Contribute
 
-### Java
+There are many ways to contribute, including:
 
-We follow the [Google Java Style Guide](https://google.github.io/styleguide/javaguide.html). See
-https://github.com/google/google-java-format for IDE plugins. The rules are not configurable.
+- **Bug Reports**: Identify incorrect behavior, inconsistencies, or regressions in the driver. Provide reproduction steps when possible.
+- **Feature Requests**: Propose improvements or new functionality. Please describe the use case (not just a proposed API).
+- **Documentation Improvements**: Enhance guides, examples, javadocs, or configuration explanations.
+- **Pull Requests**: Submit fixes, enhancements, performance improvements, or refactorings.
+- **Testing Contributions**: Add missing tests, improve coverage, or enhance test infrastructure.
+- **Support & Triage**: Help evaluate reported issues or contribute to discussions.
+- **Verify Releases**: Verify the release artifacts work correctly in your environment, when a release is proposed in the mailing list.
 
-The build will fail if the code is not formatted. To format all files from the command line, run:
- 
-```
-mvn fmt:format
-```
+### Communication
+1. **Mailing Lists**: Mail to user-subscribe@cassandra.apache.org or dev-subscribe@cassandra.apache.org to join the user@cassandra.apache.org or dev@cassandra.apache.org mailing lists.
+2. **Slack**: [#cassandra-drivers](https://the-asf.slack.com/archives/C05LPRVNZV1) channel in the Apache Software Foundation [Slack](https://infra.apache.org/slack.html). You can ask for an invite to the ASF Slack workspace in the mailing lists.
+3. **JIRA**: https://issues.apache.org/jira/projects/CASSJAVA
+4. **GitHub Repository**: https://github.com/apache/cassandra-java-driver
 
-Some aspects are not covered by the formatter: braces must be used with `if`, `else`, `for`, `do`
-and `while` statements, even when the body is empty or contains only a single statement.
 
-### XML
+## Contribution Process
 
-The build will fail if XML files are not formatted correctly. Run the following command before you
-commit:
+### Reporting Issues
 
-```java
-mvn xml-format:xml-format
-```
+All issues must be tracked in **Apache JIRA**:  
+<https://issues.apache.org/jira/projects/CASSJAVA>
+
+When filing an issue:
+
+- Clearly describe the problem, expected behavior, and actual behavior.
+- Include driver version, Java version, and Cassandra cluster details.
+- Add reproduction steps or a minimal test case if possible.
+- Use the appropriate issue type (Bug, Improvement, New Feature, etc.).
+- Set the correct components (e.g., `core`, `mapper-runtime`, `quarkus`).
+
+Committers will help refine the ticket if needed.
+
+### Submitting Changes (Pull Requests)
+
+All code changes require:
+
+1. **A corresponding JIRA ticket** unless it's a ninja fix.  
+   Include the JIRA key in the PR title, e.g.:  
+   `CASSJAVA-40: Driver testing against Java 21`
+   
+2. **A pull request on GitHub**  
+   Repository: <https://github.com/apache/cassandra-java-driver>
+
+3. **Tests**  
+   Every fix or feature should include or update tests. PRs without tests are rarely accepted.
+
+4. **Documentation updates**  
+   Update manual, javadocs, examples, or reference docs when applicable.
 
-The formatter does not enforce a maximum line length, but please try to keep it below 100 characters
-to keep files readable across all mediums (IDE, terminal, Github...).
+5. **Passing CI**  
+   PRs must pass all CI jobs unless reviewers explicitly allow exceptions.
 
-### Other text files (markdown, etc)
+6. **Code review**  
+   Committers will review your changes. 2 approvals from committers are required for merging.
 
-Similarly, enforce a right margin of 100 characters in those files. Editors and IDEs generally have
-a way to configure this (for IDEA, install the "Wrap to column" plugin).
+7. **Squash**
+   When the PR is ready to merge, use `git rebase -i` to squash your changes into a single commit before merging.
+   The commit message should follow the format of
+    ```txt
+    <JIRA number> <JIRA title>
+    patch by <Name>; reviewed by <Name> and <Name>
+    ```
+   For example,
+    ```txt
+    CASSJAVA-108 Update ESRI (and remove org.json) dependencies
+    patch by Bret McGuire; reviewed by Bret McGuire and Lukasz Antoniak
+    ```
 
-## Coding style -- production code
+**Do not** mix unrelated changes in one PR—keep contributions focused.
+
+**Do not** base a PR on another one.
+
+**Do not** squash commits before the PR is ready to merge.
+
+---
+
+## Development Setup
+
+### Prerequisites
+
+- **Java 8+** 
+- **Maven 3.8.1+** 
+
+### Building the Project
+
+- Ensure Maven is installed and you are using Java 8.
+- Build the project with:
+  ```
+  mvn clean package -DskipTests
+  ```
+- If using an IDE like IntelliJ and encountering issues with guava-shaded classes:
+   - Run:
+     ```
+     mvn clean install -DskipTests
+     ```
+   - If IntelliJ uses a different Maven version, use the Maven window in IntelliJ: under `Lifecycle`, click `clean` and then `install`.
+
+### Running Tests
+
+#### Unit Tests
+
+```bash
+mvn clean install -DskipTests
+mvn test
+```
+
+#### Integration Tests
+
+1. Install Cassandra Cluster Manager (CCM) following its [README](https://github.com/apache/cassandra-ccm).
+2.  **MacOS only**, for CCM and Simulacron-based tests, enable loopback aliases:
+    ```shell
+    for i in {2..255}; do sudo ifconfig lo0 alias 127.0.0.$i up; done
+    ```
+   Note: This may slow down networking. To remove the aliases after testing:
+   ```shell
+   for i in {2..255}; do sudo ifconfig lo0 -alias 127.0.0.$i up; done
+   ```
+3. **MacOS Apple Silicon only**, for some Cassandra versions, you might need to work around the JNA 5.6.0 version, which is incompatible to Apple Silicon.
+    ```shell
+    mvn dependency:get -Dartifact=net.java.dev.jna:jna:5.10.0
+    cp ~/.m2/repository/net/java/dev/jna/jna/5.10.0/jna-5.10.0.jar ~/.ccm/repository/4.0.19/lib/jna-5.6.0.jar
+    ```
+4. Run integration tests:
+   ```
+   mvn clean verify
+   ```
+   To target a specific Cassandra version or distribution:
+   ```
+   mvn verify -Dccm.version=3.11.0
+   mvn verify -Dccm.distribution=dse -Dccm.version=6.8.0
+   ```
+
+---
+
+## Coding Guidelines
+
+### General
 
 Do not use static imports. They make things harder to understand when you look at the code 
 someplace where you don't have IDE support, like Github's code view.
@@ -65,6 +197,19 @@ understood cases (like `i` for a loop index).
 Keep source files short. Short files are easy to understand and test. The average should probably 
 be around 200-300 lines. 
 
+### Code Formatting and License Headers
+
+- We follow the [Google Java Style Guide](https://google.github.io/styleguide/javaguide.html). See [google-java-format](https://github.com/google/google-java-format) for IDE plugins.
+- To format code:
+  ```
+  # Java files
+  mvn fmt:format
+  # XML files
+  mvn xml-format:xml-format
+  # License headers
+  mvn license:format
+  ```
+
 ### Javadoc
 
 All types in "API" packages must be documented. For "internal" packages, documentation is optional,
@@ -74,6 +219,7 @@ where the component fits in the architecture, and anything else that you feel is
 You don't need to document every parameter or return type, or even every method. Don't document 
 something if it is completely obvious, we don't want to end up with this:
 
+
 ```java
 /**
  * Returns the name.
@@ -102,7 +248,7 @@ in the documented item's signature.
 Builder withLimit(int limit) {
 ```
 
-### Logs
+### Logging
 
 We use SLF4J; loggers are declared like this:
 
@@ -115,7 +261,7 @@ Logs are intended for two personae:
 * Ops who manage the application in production.
 * Developers (maybe you) who debug a particular issue.
 
-The first 3 log levels are for ops:
+#### Log levels
 
 * `ERROR`: something that renders the driver -- or a part of it -- completely unusable. An action is
   required to fix it: bouncing the client, applying a patch, etc.
@@ -144,16 +290,8 @@ perspective (think about debugging an issue remotely, and all you have are the l
 Note that `DEBUG` and `TRACE` can coexist within the same component, for example the LBP
 initializing is a one-time event, but returning a query plan is a per-request event.
 
-Logs statements start with a prefix that identifies its origin, for example:
-
-* for components that are unique to the cluster instance, just the cluster name: `[c0]`.
-* for sessions, the cluster name + a generated unique identifier: `[c0|s0]`.
-* for channel pools, the session identifier + the address of the node: `[c0|s0|/127.0.0.2:9042]`.
-* for channels, the identifier of the owner (session or control connection) + the Netty identifier,
-  which indicates the local and remote ports:
-  `[c0|s0|id: 0xf9ef0b15, L:/127.0.0.1:51482 - R:/127.0.0.1:9042]`.
-* for request handlers, the session identifier, a unique identifier, and the index of the 
-  speculative execution: `[c0|s0|1077199500|0]`.
+**Log prefix** shows origin, e.g.:  
+`[s0|90232530|0]` (session name | hash code of the CqlRequestHandler instance | number of request attempts)
 
 Tests run with the configuration defined in `src/test/resources/logback-test.xml`. The default level
 for driver classes is `WARN`, but you can override it with a system property: `-DdriverLevel=DEBUG`.
@@ -224,7 +362,7 @@ Please annotate any new class or interface with the appropriate annotations: `@N
 the types from `edu.umd.cs.findbugs.annotations`, there are homonyms in the classpath.
 
 
-## Coding style -- test code
+## Coding Guidelines for Tests
 
 Static imports are permitted in a couple of places:
 * All AssertJ methods, e.g.:
@@ -340,6 +478,10 @@ Do not mix `CcmRule` and `SimulacronRule` in the same test. It makes things hard
 can be inefficient (if the `SimulacronRule` is method-level, it will create a Simulacron cluster for
 every test method, even those that only need CCM).
 
+Use the `@BackendRequirement` annotation to restrict the backend type and version. 
+Specify the Cassandra Distribution, CASSANDRA/DSE/HCD, and the version requirement.
+For example, `@BackendRequirement(type = BackendType.CASSANDRA, minInclusive = "2.2")`
+
 ##### Class-level rules
 
 Rules annotated with `@ClassRule` wrap the whole test class, and are reused across methods. Try to
@@ -371,7 +513,7 @@ public TestRule chain = RuleChain.outerRule(ccmRule).around(sessionRule);
 
 Only use this for:
 
-* CCM tests that use `@CassandraRequirement` or `@DseRequirement` restrictions at the method level
+* CCM tests that use `@BackendRequirement` restrictions at the method level
   (ex: `BatchStatementIT`).
 * tests where you *really* need to restart from a clean state for every method.
 
@@ -379,156 +521,3 @@ Only use this for:
 
 It's also possible to use a `@ClassRule` for CCM / Simulacron, and a `@Rule` for the session rule.
 In that case, you don't need to use a rule chain.
-
-## Running the tests
-
-### Unit tests
-
-    mvn clean test
-    
-This currently takes about 30 seconds. The goal is to keep it within a couple of minutes (it runs
-for each commit if you enable the pre-commit hook -- see below).
-
-### Integration tests
-
-    mvn clean verify
-
-This currently takes about 9 minutes. We don't have a hard limit, but ideally it should stay within
-30 minutes to 1 hour.
-
-You can skip test categories individually with `-DskipParallelizableITs`, `-DskipSerialITs` and
-`-DskipIsolatedITs` (`-DskipITs` still works to skip them all at once).
-
-### Configuring MacOS for Simulacron
-
-Simulacron (used in integration tests) relies on loopback aliases to simulate multiple nodes. On
-Linux or Windows, you shouldn't have anything to do. On MacOS, run this script:
-
-```
-#!/bin/bash
-for sub in {0..4}; do
-    echo "Opening for 127.0.$sub"
-    for i in {0..255}; do sudo ifconfig lo0 alias 127.0.$sub.$i up; done
-done
-```
-
-Note that this is known to cause temporary increased CPU usage in OS X initially while mDNSResponder
-acclimates itself to the presence of added IP addresses. This lasts several minutes. Also, this does
-not survive reboots.
-
-
-## License headers
-
-The build will fail if some license headers are missing. To update all files from the command line,
-run:
-
-```
-mvn license:format
-```
-
-## Pre-commit hook (highly recommended)
- 
-Ensure `pre-commit.sh` is executable, then run:
-
-```
-ln -s ../../pre-commit.sh .git/hooks/pre-commit
-```
-
-This will only allow commits if the tests pass. It is also a good reminder to keep the test suite
-short.
-
-Note: the tests run on the current state of the working directory. I tried to add a `git stash` in
-the script to only test what's actually being committed, but I couldn't get it to run reliably
-(it's still in there but commented). Keep this in mind when you commit, and don't forget to re-add
-the changes if the first attempt failed and you fixed the tests.
-
-## Speeding up the build for local tests
-
-If you need to install something in your local repository quickly, you can use the `fast` profile to
-skip all "non-essential" checks (licenses, formatting, tests, etc):
-
-```
-mvn clean install -Pfast
-```
-
-You can speed things up even more by targeting specific modules with the `-pl` option:
-
-```
-mvn clean install -Pfast -pl core,query-builder,mapper-runtime,mapper-processor,bom
-```
-
-Please run the normal build at least once before you push your changes.
-
-## Commits
-
-Keep your changes **focused**. Each commit should have a single, clear purpose expressed in its 
-message.
-
-Resist the urge to "fix" cosmetic issues (add/remove blank lines, move methods, etc.) in existing
-code. This adds cognitive load for reviewers, who have to figure out which changes are relevant to
-the actual issue. If you see legitimate issues, like typos, address them in a separate commit (it's
-fine to group multiple typo fixes in a single commit).
-
-Isolate trivial refactorings into separate commits. For example, a method rename that affects dozens
-of call sites can be reviewed in a few seconds, but if it's part of a larger diff it gets mixed up
-with more complex changes (that might affect the same lines), and reviewers have to check every
-line.
-
-Commit message subjects start with a capital letter, use the imperative form and do **not** end
-with a period:
-
-* correct: "Add test for CQL request handler"
-* incorrect: "~~Added test for CQL request handler~~"
-* incorrect: "~~New test for CQL request handler~~"
-
-Avoid catch-all messages like "Minor cleanup", "Various fixes", etc. They don't provide any useful
-information to reviewers, and might be a sign that your commit contains unrelated changes.
- 
-We don't enforce a particular subject line length limit, but try to keep it short.
-
-You can add more details after the subject line, separated by a blank line. The following pattern
-(inspired by [Netty](http://netty.io/wiki/writing-a-commit-message.html)) is not mandatory, but
-welcome for complex changes:
-
-```
-One line description of your change
- 
-Motivation:
-
-Explain here the context, and why you're making that change.
-What is the problem you're trying to solve.
- 
-Modifications:
-
-Describe the modifications you've done.
- 
-Result:
-
-After your change, what will change.
-```
-
-## Pull requests
-
-Like commits, pull requests should be focused on a single, clearly stated goal.
-
-Don't base a pull request onto another one, it's too complicated to follow two branches that evolve
-at the same time. If a ticket depends on another, wait for the first one to be merged. 
-
-If you have to address feedback, avoid rewriting the history (e.g. squashing or amending commits):
-this makes the reviewers' job harder, because they have to re-read the full diff and figure out
-where your new changes are. Instead, push a new commit on top of the existing history; it will be
-squashed later when the PR gets merged. If the history is complex, it's a good idea to indicate in
-the message where the changes should be squashed:
-
-```
-* 20c88f4 - Address feedback (to squash with "Add metadata parsing logic") (36 minutes ago)
-* 7044739 - Fix various typos in Javadocs (2 days ago)
-* 574dd08 - Add metadata parsing logic (2 days ago)
-```
-
-(Note that the message refers to the other commit's subject line, not the SHA-1. This way it's still
-relevant if there are intermediary rebases.)
-
-If you need new stuff from the base branch, it's fine to rebase and force-push, as long as you don't
-rewrite the history. Just give a heads up to the reviewers beforehand. Don't push a merge commit to
-a pull request.
diff --git a/README.md b/README.md
index d8ef01d0964..fe9e5d1a67d 100644
--- a/README.md
+++ b/README.md
@@ -76,7 +76,7 @@ See the [upgrade guide](upgrade_guide/) for details.
 
 [API docs]: https://docs.datastax.com/en/drivers/java/4.17
 [JIRA]: https://issues.apache.org/jira/issues/?jql=project%20%3D%20CASSJAVA%20ORDER%20BY%20key%20DESC
-[Mailing list]: https://groups.google.com/a/lists.datastax.com/forum/#!forum/java-driver-user
+[Mailing list]: https://lists.apache.org/list.html?user@cassandra.apache.org
 [Changelog]: changelog/
 [FAQ]: faq/
 
diff --git a/pre-commit.sh b/pre-commit.sh
index 912564ae81e..9be78ab3caf 100755
--- a/pre-commit.sh
+++ b/pre-commit.sh
@@ -19,7 +19,11 @@
 # STASH_NAME="pre-commit-$(date +%s)"
 # git stash save --keep-index $STASH_NAME
 
-mvn clean test
+mvn fmt:format
+mvn xml-format:xml-format
+mvn license:format
+mvn clean install -DskipTests
+mvn test
 RESULT=$?
 
 # STASHES=$(git stash list)

From bfacd80b97bcf83a5ff0f2883d553e478222012a Mon Sep 17 00:00:00 2001
From: janehe <jane.he@datastax.com>
Date: Wed, 1 Apr 2026 19:13:28 -0700
Subject: [PATCH 115/126] CASSJAVA-104: Fix Flaky tests patch by Jane He;
 review by Bret McGuire and Andy Tolbert

---
 .../core/cql/CqlPrepareAsyncProcessor.java    |  8 +-
 .../core/cql/PreparedStatementCachingIT.java  | 80 +++++++++++--------
 .../cql/PreparedStatementCancellationIT.java  | 77 ++++++++++++++++++
 .../reactive/DefaultReactiveResultSetIT.java  | 23 +++---
 .../oss/driver/core/metadata/SchemaIT.java    |  6 +-
 .../driver/core/metrics/MetricsITBase.java    |  9 ++-
 .../internal/core/type/codec/UdtCodecIT.java  | 24 ++++--
 .../internal/osgi/support/BundleOptions.java  | 22 ++---
 8 files changed, 178 insertions(+), 71 deletions(-)

diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
index a3d11cff054..48988ac4335 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/cql/CqlPrepareAsyncProcessor.java
@@ -34,7 +34,6 @@
 import com.datastax.oss.driver.internal.core.session.RequestProcessor;
 import com.datastax.oss.driver.internal.core.util.concurrent.CompletableFutures;
 import com.datastax.oss.driver.internal.core.util.concurrent.RunOrSchedule;
-import com.datastax.oss.driver.shaded.guava.common.base.Functions;
 import com.datastax.oss.driver.shaded.guava.common.cache.Cache;
 import com.datastax.oss.driver.shaded.guava.common.cache.CacheBuilder;
 import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
@@ -64,14 +63,15 @@ public CqlPrepareAsyncProcessor() {
   }
 
   public CqlPrepareAsyncProcessor(@NonNull Optional<? extends DefaultDriverContext> context) {
-    this(context, Functions.identity());
+    // Use weakValues to evict prepared statements from the cache as soon are they are
+    // no longer referenced elsewhere.
+    this(context, CacheBuilder::weakValues);
   }
 
   protected CqlPrepareAsyncProcessor(
       Optional<? extends DefaultDriverContext> context,
       Function<CacheBuilder<Object, Object>, CacheBuilder<Object, Object>> decorator) {
-
-    CacheBuilder<Object, Object> baseCache = CacheBuilder.newBuilder().weakValues();
+    CacheBuilder<Object, Object> baseCache = CacheBuilder.newBuilder();
     this.cache = decorator.apply(baseCache).build();
     context.ifPresent(
         (ctx) -> {
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
index 617d489fb95..c2c359be280 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCachingIT.java
@@ -194,8 +194,8 @@ private void invalidationResultSetTest(
       Consumer<CqlSession> setupTestSchema, Set<String> expectedChangedTypes) {
     invalidationTestInner(
         setupTestSchema,
-        "select f from test_table_1 where e = ?",
-        "select h from test_table_2 where g = ?",
+        "select f from test_table_caching_1 where e = ?",
+        "select h from test_table_caching_2 where g = ?",
         expectedChangedTypes);
   }
 
@@ -206,8 +206,8 @@ private void invalidationVariableDefsTest(
     String condition = isCollection ? "contains ?" : "= ?";
     invalidationTestInner(
         setupTestSchema,
-        String.format("select e from test_table_1 where f %s allow filtering", condition),
-        String.format("select g from test_table_2 where h %s allow filtering", condition),
+        String.format("select e from test_table_caching_1 where f %s allow filtering", condition),
+        String.format("select g from test_table_caching_2 where h %s allow filtering", condition),
         expectedChangedTypes);
   }
 
@@ -263,16 +263,18 @@ private void invalidationTestInner(
                 preparedStmtCacheRemoveLatch.countDown();
               });
 
-      // alter test_type_2 to trigger cache invalidation and above events
-      session.execute("ALTER TYPE test_type_2 add i blob");
+      // alter test_type_caching_2 to trigger cache invalidation and above events
+      session.execute("ALTER TYPE test_type_caching_2 add i blob");
+
+      session.checkSchemaAgreement();
 
       // wait for latches and fail if they don't reach zero before timeout
       assertThat(
               Uninterruptibles.awaitUninterruptibly(
-                  preparedStmtCacheRemoveLatch, 10, TimeUnit.SECONDS))
+                  preparedStmtCacheRemoveLatch, 120, TimeUnit.SECONDS))
           .withFailMessage("preparedStmtCacheRemoveLatch did not trigger before timeout")
           .isTrue();
-      assertThat(Uninterruptibles.awaitUninterruptibly(typeChangeEventLatch, 10, TimeUnit.SECONDS))
+      assertThat(Uninterruptibles.awaitUninterruptibly(typeChangeEventLatch, 20, TimeUnit.SECONDS))
           .withFailMessage("typeChangeEventLatch did not trigger before timeout")
           .isTrue();
 
@@ -295,17 +297,20 @@ private void invalidationTestInner(
 
   Consumer<CqlSession> setupCacheEntryTestBasic =
       (session) -> {
-        session.execute("CREATE TYPE test_type_1 (a text, b int)");
-        session.execute("CREATE TYPE test_type_2 (c int, d text)");
-        session.execute("CREATE TABLE test_table_1 (e int primary key, f frozen<test_type_1>)");
-        session.execute("CREATE TABLE test_table_2 (g int primary key, h frozen<test_type_2>)");
+        session.execute("CREATE TYPE test_type_caching_1 (a text, b int)");
+        session.execute("CREATE TYPE test_type_caching_2 (c int, d text)");
+        session.execute(
+            "CREATE TABLE test_table_caching_1 (e int primary key, f frozen<test_type_caching_1>)");
+        session.execute(
+            "CREATE TABLE test_table_caching_2 (g int primary key, h frozen<test_type_caching_2>)");
       };
 
   @Test
   public void should_invalidate_cache_entry_on_basic_udt_change_result_set() {
     SchemaChangeSynchronizer.withLock(
         () -> {
-          invalidationResultSetTest(setupCacheEntryTestBasic, ImmutableSet.of("test_type_2"));
+          invalidationResultSetTest(
+              setupCacheEntryTestBasic, ImmutableSet.of("test_type_caching_2"));
         });
   }
 
@@ -314,25 +319,26 @@ public void should_invalidate_cache_entry_on_basic_udt_change_variable_defs() {
     SchemaChangeSynchronizer.withLock(
         () -> {
           invalidationVariableDefsTest(
-              setupCacheEntryTestBasic, false, ImmutableSet.of("test_type_2"));
+              setupCacheEntryTestBasic, false, ImmutableSet.of("test_type_caching_2"));
         });
   }
 
   Consumer<CqlSession> setupCacheEntryTestCollection =
       (session) -> {
-        session.execute("CREATE TYPE test_type_1 (a text, b int)");
-        session.execute("CREATE TYPE test_type_2 (c int, d text)");
+        session.execute("CREATE TYPE test_type_caching_1 (a text, b int)");
+        session.execute("CREATE TYPE test_type_caching_2 (c int, d text)");
         session.execute(
-            "CREATE TABLE test_table_1 (e int primary key, f list<frozen<test_type_1>>)");
+            "CREATE TABLE test_table_caching_1 (e int primary key, f list<frozen<test_type_caching_1>>)");
         session.execute(
-            "CREATE TABLE test_table_2 (g int primary key, h list<frozen<test_type_2>>)");
+            "CREATE TABLE test_table_caching_2 (g int primary key, h list<frozen<test_type_caching_2>>)");
       };
 
   @Test
   public void should_invalidate_cache_entry_on_collection_udt_change_result_set() {
     SchemaChangeSynchronizer.withLock(
         () -> {
-          invalidationResultSetTest(setupCacheEntryTestCollection, ImmutableSet.of("test_type_2"));
+          invalidationResultSetTest(
+              setupCacheEntryTestCollection, ImmutableSet.of("test_type_caching_2"));
         });
   }
 
@@ -341,25 +347,26 @@ public void should_invalidate_cache_entry_on_collection_udt_change_variable_defs
     SchemaChangeSynchronizer.withLock(
         () -> {
           invalidationVariableDefsTest(
-              setupCacheEntryTestCollection, true, ImmutableSet.of("test_type_2"));
+              setupCacheEntryTestCollection, true, ImmutableSet.of("test_type_caching_2"));
         });
   }
 
   Consumer<CqlSession> setupCacheEntryTestTuple =
       (session) -> {
-        session.execute("CREATE TYPE test_type_1 (a text, b int)");
-        session.execute("CREATE TYPE test_type_2 (c int, d text)");
+        session.execute("CREATE TYPE test_type_caching_1 (a text, b int)");
+        session.execute("CREATE TYPE test_type_caching_2 (c int, d text)");
         session.execute(
-            "CREATE TABLE test_table_1 (e int primary key, f tuple<int, test_type_1, text>)");
+            "CREATE TABLE test_table_caching_1 (e int primary key, f tuple<int, test_type_caching_1, text>)");
         session.execute(
-            "CREATE TABLE test_table_2 (g int primary key, h tuple<text, test_type_2, int>)");
+            "CREATE TABLE test_table_caching_2 (g int primary key, h tuple<text, test_type_caching_2, int>)");
       };
 
   @Test
   public void should_invalidate_cache_entry_on_tuple_udt_change_result_set() {
     SchemaChangeSynchronizer.withLock(
         () -> {
-          invalidationResultSetTest(setupCacheEntryTestTuple, ImmutableSet.of("test_type_2"));
+          invalidationResultSetTest(
+              setupCacheEntryTestTuple, ImmutableSet.of("test_type_caching_2"));
         });
   }
 
@@ -368,18 +375,20 @@ public void should_invalidate_cache_entry_on_tuple_udt_change_variable_defs() {
     SchemaChangeSynchronizer.withLock(
         () -> {
           invalidationVariableDefsTest(
-              setupCacheEntryTestTuple, false, ImmutableSet.of("test_type_2"));
+              setupCacheEntryTestTuple, false, ImmutableSet.of("test_type_caching_2"));
         });
   }
 
   Consumer<CqlSession> setupCacheEntryTestNested =
       (session) -> {
-        session.execute("CREATE TYPE test_type_1 (a text, b int)");
-        session.execute("CREATE TYPE test_type_2 (c int, d text)");
-        session.execute("CREATE TYPE test_type_3 (e frozen<test_type_1>, f int)");
-        session.execute("CREATE TYPE test_type_4 (g int, h frozen<test_type_2>)");
-        session.execute("CREATE TABLE test_table_1 (e int primary key, f frozen<test_type_3>)");
-        session.execute("CREATE TABLE test_table_2 (g int primary key, h frozen<test_type_4>)");
+        session.execute("CREATE TYPE test_type_caching_1 (a text, b int)");
+        session.execute("CREATE TYPE test_type_caching_2 (c int, d text)");
+        session.execute("CREATE TYPE test_type_caching_3 (e frozen<test_type_caching_1>, f int)");
+        session.execute("CREATE TYPE test_type_caching_4 (g int, h frozen<test_type_caching_2>)");
+        session.execute(
+            "CREATE TABLE test_table_caching_1 (e int primary key, f frozen<test_type_caching_3>)");
+        session.execute(
+            "CREATE TABLE test_table_caching_2 (g int primary key, h frozen<test_type_caching_4>)");
       };
 
   @Test
@@ -387,7 +396,8 @@ public void should_invalidate_cache_entry_on_nested_udt_change_result_set() {
     SchemaChangeSynchronizer.withLock(
         () -> {
           invalidationResultSetTest(
-              setupCacheEntryTestNested, ImmutableSet.of("test_type_2", "test_type_4"));
+              setupCacheEntryTestNested,
+              ImmutableSet.of("test_type_caching_2", "test_type_caching_4"));
         });
   }
 
@@ -396,7 +406,9 @@ public void should_invalidate_cache_entry_on_nested_udt_change_variable_defs() {
     SchemaChangeSynchronizer.withLock(
         () -> {
           invalidationVariableDefsTest(
-              setupCacheEntryTestNested, false, ImmutableSet.of("test_type_2", "test_type_4"));
+              setupCacheEntryTestNested,
+              false,
+              ImmutableSet.of("test_type_caching_2", "test_type_caching_4"));
         });
   }
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCancellationIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCancellationIT.java
index d7e581e4606..6eb1a7d57a0 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCancellationIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/PreparedStatementCancellationIT.java
@@ -21,20 +21,34 @@
 import static org.junit.Assert.fail;
 
 import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.api.core.context.DriverContext;
 import com.datastax.oss.driver.api.core.cql.PrepareRequest;
 import com.datastax.oss.driver.api.core.cql.PreparedStatement;
+import com.datastax.oss.driver.api.core.session.ProgrammaticArguments;
+import com.datastax.oss.driver.api.core.session.SessionBuilder;
 import com.datastax.oss.driver.api.testinfra.ccm.CustomCcmRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionUtils;
 import com.datastax.oss.driver.categories.IsolatedTests;
 import com.datastax.oss.driver.internal.core.context.DefaultDriverContext;
 import com.datastax.oss.driver.internal.core.cql.CqlPrepareAsyncProcessor;
+import com.datastax.oss.driver.internal.core.cql.CqlPrepareSyncProcessor;
+import com.datastax.oss.driver.internal.core.session.BuiltInRequestProcessors;
+import com.datastax.oss.driver.internal.core.session.RequestProcessor;
+import com.datastax.oss.driver.internal.core.session.RequestProcessorRegistry;
 import com.datastax.oss.driver.shaded.guava.common.base.Predicates;
 import com.datastax.oss.driver.shaded.guava.common.cache.Cache;
 import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
 import org.junit.After;
+import org.junit.AfterClass;
 import org.junit.Before;
+import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
@@ -50,6 +64,69 @@ public class PreparedStatementCancellationIT {
 
   @Rule public TestRule chain = RuleChain.outerRule(ccmRule).around(sessionRule);
 
+  private static class TestCqlPrepareAsyncProcessor extends CqlPrepareAsyncProcessor {
+
+    public TestCqlPrepareAsyncProcessor(@NonNull Optional<DefaultDriverContext> context) {
+      // Default CqlPrepareAsyncProcessor uses weak values here as well.  We avoid doing so
+      // to prevent cache entries from unexpectedly disappearing mid-test.
+      super(context, Function.identity());
+    }
+  }
+
+  private static class TestDefaultDriverContext extends DefaultDriverContext {
+    public TestDefaultDriverContext(
+        DriverConfigLoader configLoader, ProgrammaticArguments programmaticArguments) {
+      super(configLoader, programmaticArguments);
+    }
+
+    @Override
+    protected RequestProcessorRegistry buildRequestProcessorRegistry() {
+      // Re-create the processor cache to insert the TestCqlPrepareAsyncProcessor with it's strong
+      // prepared statement cache, see JAVA-3062
+      List<RequestProcessor<?, ?>> processors =
+          BuiltInRequestProcessors.createDefaultProcessors(this);
+      processors.removeIf((processor) -> processor instanceof CqlPrepareAsyncProcessor);
+      processors.removeIf((processor) -> processor instanceof CqlPrepareSyncProcessor);
+      CqlPrepareAsyncProcessor asyncProcessor =
+          new PreparedStatementCancellationIT.TestCqlPrepareAsyncProcessor(Optional.of(this));
+      processors.add(2, asyncProcessor);
+      processors.add(3, new CqlPrepareSyncProcessor(asyncProcessor));
+      return new RequestProcessorRegistry(
+          getSessionName(), processors.toArray(new RequestProcessor[0]));
+    }
+  }
+
+  private static class TestSessionBuilder extends SessionBuilder {
+
+    @Override
+    protected Object wrap(@NonNull CqlSession defaultSession) {
+      return defaultSession;
+    }
+
+    @Override
+    protected DriverContext buildContext(
+        DriverConfigLoader configLoader, ProgrammaticArguments programmaticArguments) {
+      return new PreparedStatementCancellationIT.TestDefaultDriverContext(
+          configLoader, programmaticArguments);
+    }
+  }
+
+  @BeforeClass
+  public static void setupBeforeClass() {
+    System.setProperty(
+        SessionUtils.SESSION_BUILDER_CLASS_PROPERTY,
+        PreparedStatementCancellationIT.class.getName());
+  }
+
+  @AfterClass
+  public static void teardownAfterClass() {
+    System.clearProperty(SessionUtils.SESSION_BUILDER_CLASS_PROPERTY);
+  }
+
+  public static SessionBuilder builder() {
+    return new PreparedStatementCancellationIT.TestSessionBuilder();
+  }
+
   @Before
   public void setup() {
 
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/reactive/DefaultReactiveResultSetIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/reactive/DefaultReactiveResultSetIT.java
index c00cf064e51..77a449de44f 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/reactive/DefaultReactiveResultSetIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/cql/reactive/DefaultReactiveResultSetIT.java
@@ -31,6 +31,7 @@
 import com.datastax.oss.driver.api.core.cql.ExecutionInfo;
 import com.datastax.oss.driver.api.core.cql.PreparedStatement;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
+import com.datastax.oss.driver.api.core.cql.Statement;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
 import com.datastax.oss.driver.api.testinfra.ccm.SchemaChangeSynchronizer;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
@@ -67,19 +68,15 @@ public static void initialize() {
     CqlSession session = sessionRule.session();
     SchemaChangeSynchronizer.withLock(
         () -> {
-          session.execute("DROP TABLE IF EXISTS test_reactive_read");
-          session.execute("DROP TABLE IF EXISTS test_reactive_write");
+          session.execute(createSlowStatement("DROP TABLE IF EXISTS test_reactive_read"));
+          session.execute(createSlowStatement("DROP TABLE IF EXISTS test_reactive_write"));
           session.checkSchemaAgreement();
           session.execute(
-              SimpleStatement.builder(
-                      "CREATE TABLE test_reactive_read (pk int, cc int, v int, PRIMARY KEY ((pk), cc))")
-                  .setExecutionProfile(sessionRule.slowProfile())
-                  .build());
+              createSlowStatement(
+                  "CREATE TABLE test_reactive_read (pk int, cc int, v int, PRIMARY KEY ((pk), cc))"));
           session.execute(
-              SimpleStatement.builder(
-                      "CREATE TABLE test_reactive_write (pk int, cc int, v int, PRIMARY KEY ((pk), cc))")
-                  .setExecutionProfile(sessionRule.slowProfile())
-                  .build());
+              createSlowStatement(
+                  "CREATE TABLE test_reactive_write (pk int, cc int, v int, PRIMARY KEY ((pk), cc))"));
           session.checkSchemaAgreement();
         });
     for (int i = 0; i < 1000; i++) {
@@ -92,6 +89,12 @@ public static void initialize() {
     }
   }
 
+  static Statement<?> createSlowStatement(String statement) {
+    return SimpleStatement.builder(statement)
+        .setExecutionProfile(sessionRule.slowProfile())
+        .build();
+  }
+
   @Before
   public void truncateTables() throws Exception {
     CqlSession session = sessionRule.session();
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
index df5571974c1..728bd3c6225 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metadata/SchemaIT.java
@@ -151,11 +151,11 @@ public void should_disable_schema_programmatically_when_enabled_in_config() {
     sessionRule
         .session()
         .execute(
-            SimpleStatement.builder("CREATE TABLE foo(k int primary key)")
+            SimpleStatement.builder("CREATE TABLE foo_schema_it(k int primary key)")
                 .setExecutionProfile(slowProfile)
                 .build());
     assertThat(session.getMetadata().getKeyspace(sessionRule.keyspace()).get().getTables())
-        .doesNotContainKey(CqlIdentifier.fromInternal("foo"));
+        .doesNotContainKey(CqlIdentifier.fromInternal("foo_schema_it"));
 
     // Reset to config value (true), should refresh and load the new table
     session.setSchemaMetadataEnabled(null);
@@ -167,7 +167,7 @@ public void should_disable_schema_programmatically_when_enabled_in_config() {
             () ->
                 assertThat(
                         session.getMetadata().getKeyspace(sessionRule.keyspace()).get().getTables())
-                    .containsKey(CqlIdentifier.fromInternal("foo")));
+                    .containsKey(CqlIdentifier.fromInternal("foo_schema_it")));
   }
 
   @Test
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/MetricsITBase.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/MetricsITBase.java
index e6121217619..716dc1b66a6 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/MetricsITBase.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/metrics/MetricsITBase.java
@@ -174,11 +174,13 @@ public void should_evict_down_node_metrics_when_timeout_fires() throws Exception
       // trigger node1 UP -> DOWN
       eventBus.fire(NodeStateEvent.changed(NodeState.UP, NodeState.DOWN, node1));
 
-      Thread.sleep(expireAfter.toMillis());
+      Thread.sleep(expireAfter.toMillis() + 100);
 
       // then node-level metrics should be evicted from node1, but
       // node2 and node3 metrics should not have been evicted
-      await().untilAsserted(() -> assertNodeMetricsEvicted(session, node1));
+      await()
+          .atMost(Duration.ofMinutes(2))
+          .untilAsserted(() -> assertNodeMetricsEvicted(session, node1));
       assertNodeMetricsNotEvicted(session, node2);
       assertNodeMetricsNotEvicted(session, node3);
 
@@ -226,7 +228,8 @@ public void should_not_evict_down_node_metrics_when_node_is_back_up_before_timeo
       eventBus.fire(NodeStateEvent.changed(NodeState.FORCED_DOWN, NodeState.UP, node2));
       eventBus.fire(NodeStateEvent.added(node3));
 
-      Thread.sleep(expireAfter.toMillis());
+      // Add a small buffer to ensure the timeout would have fired if it wasn't cancelled
+      Thread.sleep(expireAfter.toMillis() + 100);
 
       // then no node-level metrics should be evicted
       assertNodeMetricsNotEvicted(session, node1);
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecIT.java
index 804a078bbe0..ff6f3a9d2c5 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/internal/core/type/codec/UdtCodecIT.java
@@ -22,12 +22,14 @@
 
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.cql.Row;
+import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.data.UdtValue;
 import com.datastax.oss.driver.api.core.type.UserDefinedType;
 import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
 import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
 import com.datastax.oss.driver.api.testinfra.session.SessionRule;
 import com.datastax.oss.driver.categories.ParallelizableTests;
+import java.time.Duration;
 import java.util.Objects;
 import org.junit.Rule;
 import org.junit.Test;
@@ -47,23 +49,31 @@ public class UdtCodecIT {
   @Test
   public void should_decoding_udt_be_backward_compatible() {
     CqlSession session = sessionRule.session();
-    session.execute("CREATE TYPE test_type_1 (a text, b int)");
-    session.execute("CREATE TABLE test_table_1 (e int primary key, f frozen<test_type_1>)");
+    session.execute(
+        SimpleStatement.newInstance("CREATE TYPE test_type_udt_1 (a text, b int)")
+            .setTimeout(Duration.ofSeconds(20)));
+    session.execute(
+        SimpleStatement.newInstance(
+                "CREATE TABLE test_table_udt_1 (e int primary key, f frozen<test_type_udt_1>)")
+            .setTimeout(Duration.ofSeconds(20)));
     // insert a row using version 1 of the UDT schema
-    session.execute("INSERT INTO test_table_1(e, f) VALUES(1, {a: 'a', b: 1})");
+    session.execute("INSERT INTO test_table_udt_1(e, f) VALUES(1, {a: 'a', b: 1})");
     UserDefinedType udt =
         session
             .getMetadata()
             .getKeyspace(sessionRule.keyspace())
-            .flatMap(ks -> ks.getUserDefinedType("test_type_1"))
+            .flatMap(ks -> ks.getUserDefinedType("test_type_udt_1"))
             .orElseThrow(IllegalStateException::new);
     TypeCodec<?> oldCodec = session.getContext().getCodecRegistry().codecFor(udt);
     // update UDT schema
-    session.execute("ALTER TYPE test_type_1 add i text");
+    session.execute(
+        SimpleStatement.newInstance("ALTER TYPE test_type_udt_1 add i text")
+            .setTimeout(Duration.ofSeconds(20)));
     // insert a row using version 2 of the UDT schema
-    session.execute("INSERT INTO test_table_1(e, f) VALUES(2, {a: 'b', b: 2, i: 'b'})");
+    session.execute("INSERT INTO test_table_udt_1(e, f) VALUES(2, {a: 'b', b: 2, i: 'b'})");
     Row row =
-        Objects.requireNonNull(session.execute("SELECT f FROM test_table_1 WHERE e = ?", 2).one());
+        Objects.requireNonNull(
+            session.execute("SELECT f FROM test_table_udt_1 WHERE e = ?", 2).one());
     // Try to read new row with old codec. Using row.getUdtValue() would not cause any issues,
     // because new codec will be automatically registered (using all 3 attributes).
     // If application leverages generic row.get(String, Codec) method, data reading with old codec
diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
index cb7e86b2a73..f15207219f9 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
@@ -35,12 +35,14 @@ public class BundleOptions {
   public static CompositeOption commonBundles() {
     return () ->
         options(
-            mavenBundle("org.apache.cassandra", "java-driver-guava-shaded").versionAsInProject(),
-            mavenBundle("io.dropwizard.metrics", "metrics-core").versionAsInProject(),
-            mavenBundle("org.slf4j", "slf4j-api").versionAsInProject(),
-            mavenBundle("org.hdrhistogram", "HdrHistogram").versionAsInProject(),
-            mavenBundle("com.typesafe", "config").versionAsInProject(),
-            mavenBundle("com.datastax.oss", "native-protocol").versionAsInProject(),
+            mavenBundle("org.apache.cassandra", "java-driver-guava-shaded")
+                .versionAsInProject()
+                .startLevel(1),
+            mavenBundle("io.dropwizard.metrics", "metrics-core").versionAsInProject().startLevel(1),
+            mavenBundle("org.slf4j", "slf4j-api").versionAsInProject().startLevel(1),
+            mavenBundle("org.hdrhistogram", "HdrHistogram").versionAsInProject().startLevel(1),
+            mavenBundle("com.typesafe", "config").versionAsInProject().startLevel(1),
+            mavenBundle("com.datastax.oss", "native-protocol").versionAsInProject().startLevel(1),
             logbackBundles(),
             debugOptions());
   }
@@ -51,7 +53,7 @@ public static CompositeOption applicationBundle() {
             systemProperty("cassandra.contactpoints").value("127.0.0.1"),
             systemProperty("cassandra.port").value("9042"),
             systemProperty("cassandra.keyspace").value("test_osgi"),
-            bundle("reference:file:target/classes"));
+            bundle("reference:file:target/classes").startLevel(3));
   }
 
   public static UrlProvisionOption driverCoreBundle() {
@@ -59,15 +61,15 @@ public static UrlProvisionOption driverCoreBundle() {
   }
 
   public static UrlProvisionOption driverCoreShadedBundle() {
-    return bundle("reference:file:../core-shaded/target/classes");
+    return bundle("reference:file:../core-shaded/target/classes").startLevel(1);
   }
 
   public static UrlProvisionOption driverQueryBuilderBundle() {
-    return bundle("reference:file:../query-builder/target/classes");
+    return bundle("reference:file:../query-builder/target/classes").startLevel(2);
   }
 
   public static UrlProvisionOption driverMapperRuntimeBundle() {
-    return bundle("reference:file:../mapper-runtime/target/classes");
+    return bundle("reference:file:../mapper-runtime/target/classes").startLevel(2);
   }
 
   public static UrlProvisionOption driverTestInfraBundle() {

From 48f33e1faf880d1b1afc12d5fd63df966a549460 Mon Sep 17 00:00:00 2001
From: janehe <jane.he@datastax.com>
Date: Thu, 9 Apr 2026 15:29:03 -0700
Subject: [PATCH 116/126] =?UTF-8?q?CASSJAVA-109,=20CASSJAVA-117:=20Manual?=
 =?UTF-8?q?=20and=20API=20References=20after=20donation,=20Build=20CI=20fo?=
 =?UTF-8?q?r=20Java=20Driver=20Doc=20Patch=20by=20Jane=20He=20and=20=C5=81?=
 =?UTF-8?q?ukasz=20Antoniak;=20Reviewed=20by=20Bret=20McGuire?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .github/workflows/publish-docs-gp-pages.yml   | 101 ++++++++++
 README.md                                     |  12 +-
 build-doc.sh                                  |  16 ++
 .../api/core/config/DefaultDriverOption.java  |   4 +-
 .../oss/driver/api/core/data/CqlVector.java   |   2 +-
 faq/README.md                                 |   8 +-
 faq/favicon.ico                               | Bin 0 -> 16909 bytes
 faq/logo.png                                  | Bin 0 -> 28790 bytes
 manual/README.md                              |  16 +-
 manual/cloud/README.md                        |   4 +-
 manual/core/README.md                         |  36 ++--
 manual/core/address_resolution/README.md      |   8 +-
 manual/core/async/README.md                   |   6 +-
 manual/core/authentication/README.md          |   4 +-
 manual/core/bom/README.md                     |   4 +-
 manual/core/compression/README.md             |   8 +-
 manual/core/configuration/README.md           |   4 +-
 manual/core/configuration/reference/README.md |  32 ++++
 .../core/configuration/reference/README.rst   |  34 ----
 .../configuration/reference/reference.conf    |   1 +
 manual/core/control_connection/README.md      |  20 +-
 manual/core/custom_codecs/README.md           |   6 +-
 manual/core/detachable_types/README.md        |  12 +-
 manual/core/dse/README.md                     |   8 +-
 manual/core/dse/geotypes/README.md            |   2 +-
 manual/core/dse/graph/README.md               |  14 +-
 manual/core/dse/graph/fluent/README.md        |   6 +-
 .../core/dse/graph/fluent/explicit/README.md  |   4 +-
 .../core/dse/graph/fluent/implicit/README.md  |   4 +-
 manual/core/dse/graph/options/README.md       |   4 +-
 manual/core/dse/graph/results/README.md       |   4 +-
 manual/core/dse/graph/script/README.md        |   4 +-
 manual/core/graalvm/README.md                 |  32 ++--
 manual/core/idempotence/README.md             |   8 +-
 manual/core/integration/README.md             |  34 ++--
 manual/core/load_balancing/README.md          |  20 +-
 manual/core/logging/README.md                 |   2 +-
 manual/core/metadata/README.md                |   8 +-
 manual/core/metadata/node/README.md           |   2 +-
 manual/core/metadata/schema/README.md         |   8 +-
 manual/core/metadata/token/README.md          |   2 +-
 manual/core/metrics/README.md                 |   2 +-
 manual/core/native_protocol/README.md         |  10 +-
 manual/core/non_blocking/README.md            |  22 +--
 manual/core/paging/README.md                  |   8 +-
 manual/core/performance/README.md             |  46 ++---
 manual/core/pooling/README.md                 |   8 +-
 manual/core/query_timestamps/README.md        |   4 +-
 manual/core/reactive/README.md                |   6 +-
 manual/core/reconnection/README.md            |   8 +-
 manual/core/request_id/README.md              |   2 +-
 manual/core/request_tracker/README.md         |   2 +-
 manual/core/retries/README.md                 |  20 +-
 manual/core/shaded_jar/README.md              |   6 +-
 manual/core/speculative_execution/README.md   |  20 +-
 manual/core/ssl/README.md                     |   4 +-
 manual/core/statements/README.md              |  22 +--
 .../statements/per_query_keyspace/README.md   |   4 +-
 manual/core/statements/prepared/README.md     |  18 +-
 manual/core/statements/simple/README.md       |   6 +-
 manual/core/throttling/README.md              |  16 +-
 manual/core/tracing/README.md                 |   2 +-
 manual/core/tuples/README.md                  |   6 +-
 manual/core/udts/README.md                    |   6 +-
 manual/developer/README.md                    |  12 +-
 manual/developer/admin/README.md              |  12 +-
 manual/developer/common/README.md             |   6 +-
 manual/developer/common/concurrency/README.md |   2 +-
 manual/developer/native_protocol/README.md    |   4 +-
 manual/developer/netty_pipeline/README.md     |  14 +-
 manual/developer/request_execution/README.md  |  14 +-
 manual/mapper/README.md                       |  12 +-
 manual/mapper/config/README.md                |  10 +-
 manual/mapper/config/kotlin/README.md         |   6 +-
 manual/mapper/config/record/README.md         |   2 +-
 manual/mapper/config/scala/README.md          |   2 +-
 manual/mapper/daos/README.md                  |  24 +--
 manual/mapper/daos/custom_types/README.md     |   2 +-
 manual/mapper/daos/delete/README.md           |  12 +-
 manual/mapper/daos/getentity/README.md        |   2 +-
 manual/mapper/daos/increment/README.md        |  10 +-
 manual/mapper/daos/insert/README.md           |  12 +-
 manual/mapper/daos/null_saving/README.md      |   8 +-
 manual/mapper/daos/query/README.md            |  10 +-
 manual/mapper/daos/queryprovider/README.md    |   4 +-
 manual/mapper/daos/select/README.md           |  14 +-
 manual/mapper/daos/setentity/README.md        |   4 +-
 .../daos/statement_attributes/README.md       |   4 +-
 manual/mapper/daos/update/README.md           |  10 +-
 manual/mapper/entities/README.md              |   6 +-
 manual/mapper/mapper/README.md                |  20 +-
 manual/osgi/README.md                         |   8 +-
 manual/query_builder/README.md                |  26 +--
 manual/query_builder/condition/README.md      |   6 +-
 manual/query_builder/delete/README.md         |   6 +-
 manual/query_builder/idempotence/README.md    |   2 +-
 manual/query_builder/insert/README.md         |   4 +-
 manual/query_builder/relation/README.md       |  10 +-
 manual/query_builder/schema/README.md         |  18 +-
 .../schema/materialized_view/README.md        |   4 +-
 manual/query_builder/select/README.md         |   6 +-
 manual/query_builder/term/README.md           |   8 +-
 manual/query_builder/truncate/README.md       |   2 +-
 manual/query_builder/update/README.md         |   6 +-
 mkdocs.yml                                    | 177 ++++++++++++++++++
 mkdocs/CONTRIBUTING.md                        |   1 +
 mkdocs/README.md                              |   1 +
 mkdocs/api                                    |   1 +
 mkdocs/changelog                              |   1 +
 mkdocs/faq                                    |   1 +
 mkdocs/manual                                 |   1 +
 mkdocs/upgrade_guide                          |   1 +
 pom.xml                                       |  32 ++++
 upgrade_guide/README.md                       |  60 +++---
 114 files changed, 852 insertions(+), 520 deletions(-)
 create mode 100644 .github/workflows/publish-docs-gp-pages.yml
 create mode 100755 build-doc.sh
 create mode 100644 faq/favicon.ico
 create mode 100644 faq/logo.png
 create mode 100644 manual/core/configuration/reference/README.md
 delete mode 100644 manual/core/configuration/reference/README.rst
 create mode 120000 manual/core/configuration/reference/reference.conf
 create mode 100644 mkdocs.yml
 create mode 120000 mkdocs/CONTRIBUTING.md
 create mode 120000 mkdocs/README.md
 create mode 120000 mkdocs/api
 create mode 120000 mkdocs/changelog
 create mode 120000 mkdocs/faq
 create mode 120000 mkdocs/manual
 create mode 120000 mkdocs/upgrade_guide

diff --git a/.github/workflows/publish-docs-gp-pages.yml b/.github/workflows/publish-docs-gp-pages.yml
new file mode 100644
index 00000000000..57851d517c0
--- /dev/null
+++ b/.github/workflows/publish-docs-gp-pages.yml
@@ -0,0 +1,101 @@
+name: publish-docs-gh-pages
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build-docs:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      # 1. Checkout doc branch
+      - name: Checkout current branch
+        uses: actions/checkout@v4
+        with:
+          path: java-driver
+
+      # 2. Java 8
+      - name: Set up Java 8
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: "8"
+          cache: maven
+
+      # 3. Python 3.10.19 + MkDocs + plugins
+      - name: Set up Python 3.10.19
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10.19"
+
+      - name: Install MkDocs dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install \
+            mkdocs \
+            mkdocs-material \
+            mkdocs-awesome-pages-plugin \
+            mkdocs-macros-plugin \
+            mike
+
+      # 4. Build docs via build-doc.sh
+      - name: Build documentation
+        working-directory: java-driver
+        run: |
+          chmod +x ./build-doc.sh
+          ./build-doc.sh
+
+      # 5. Checkout gh-pages branch
+      - name: Checkout GH pages branch
+        uses: actions/checkout@v4
+        with:
+          ref: gh-pages
+          path: gh-pages
+
+      - name: Copy and version documentation
+        working-directory: gh-pages
+        run: |
+          git config --global user.email "gha@cassandra.apache.org"
+          git config --global user.name "GHA for Apache Cassandra Website"
+
+          cd ../java-driver
+          # lookup current project version
+          release_version=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout | cut -d- -f1)
+          # update links to contain version prefix
+          mike deploy --update-aliases $release_version
+          # copy documentation web page folder
+          cd ../gh-pages
+          cp -r ../java-driver/docs ./
+          rm -rf $release_version
+          mv docs $release_version
+
+          # update latest symlink
+          rm latest
+          ln -s $release_version latest
+
+          # remove latest tag
+          sed -i 's/\"latest\"//g' versions.json
+          # remove already present line if exists
+          sed -i '/'"$release_version"'/d' versions.json
+          # insert new version at the beginning
+          sed -i '2s/^/  { "version": "'"$release_version"'", "title": "'"$release_version"'", "aliases": ["latest"] },\'$'\n/g' versions.json
+
+          echo "release_version=$release_version" >> "$GITHUB_ENV"
+
+      - name: Commit and push documentation
+        working-directory: gh-pages
+        run: |
+          git config --global user.email "gha@cassandra.apache.org"
+          git config --global user.name "GHA for Apache Cassandra Website"
+
+          git add .
+
+          if git diff --cached --quiet; then
+            echo "No changes to push to gh-pages"
+            exit 0
+          fi
+
+          git commit -m "Update generated docs for release ${release_version}"
+          git push origin gh-pages
diff --git a/README.md b/README.md
index fe9e5d1a67d..bd09d98cf44 100644
--- a/README.md
+++ b/README.md
@@ -43,8 +43,8 @@ are multiple modules, all prefixed with `java-driver-`.
 Note that the query builder is now published as a separate artifact, you'll need to add the
 dependency if you plan to use it.
 
-Refer to each module's manual for more details ([core](manual/core/), [query
-builder](manual/query_builder/), [mapper](manual/mapper)).
+Refer to each module's manual for more details ([core](manual/core/README.md), [query
+builder](manual/query_builder/README.md), [mapper](manual/mapper/README.md)).
 
 [org.apache.cassandra]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.apache.cassandra%22
 
@@ -63,11 +63,11 @@ but DataStax does not officially support these systems.
 Java Driver 4 is **not binary compatible** with previous versions. However, most of the concepts
 remain unchanged, and the new API will look very familiar to 2.x and 3.x users.
 
-See the [upgrade guide](upgrade_guide/) for details.
+See the [upgrade guide](upgrade_guide/README.md) for details.
 
 ## Useful links
 
-* [Manual](manual/)
+* [Manual](manual/README.md)
 * [API docs]
 * Bug tracking: [JIRA]
 * [Mailing list]
@@ -77,8 +77,8 @@ See the [upgrade guide](upgrade_guide/) for details.
 [API docs]: https://docs.datastax.com/en/drivers/java/4.17
 [JIRA]: https://issues.apache.org/jira/issues/?jql=project%20%3D%20CASSJAVA%20ORDER%20BY%20key%20DESC
 [Mailing list]: https://lists.apache.org/list.html?user@cassandra.apache.org
-[Changelog]: changelog/
-[FAQ]: faq/
+[Changelog]: changelog/README.md
+[FAQ]: faq/README.md
 
 ## License
 
diff --git a/build-doc.sh b/build-doc.sh
new file mode 100755
index 00000000000..3be00f379b9
--- /dev/null
+++ b/build-doc.sh
@@ -0,0 +1,16 @@
+set -e
+# Set up python environment
+#pyenv local 3.10.1
+#pip install mkdocs mkdocs-material mkdocs-awesome-pages-plugin mkdocs-macros-plugin
+
+# In some bash/zsh environments, the locale is not set correctly, which causes mkdocs to fail.
+export LC_ALL=en_US.UTF-8
+export LANG=en_US.UTF-8
+
+# Build Javadoc
+mvn clean install -DskipTests # or guava-shaded can not be found
+# mvn javadoc:javadoc -pl core,query-builder,mapper-runtime
+mvn javadoc:aggregate
+
+# Build manual with API references
+mkdocs build -s # strict, so it fails with warning. You can also use `mkdocs serve` to preview
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
index 60c44193577..2900e897cce 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/DefaultDriverOption.java
@@ -1022,8 +1022,8 @@ public enum DefaultDriverOption implements DriverOption {
    * }
    * </pre>
    *
-   * Note: subnets must be represented as prefix blocks, see {@link
-   * inet.ipaddr.Address#isPrefixBlock()}.
+   * Note: subnets must be represented as prefix blocks, see <a
+   * href="https://seancfoley.github.io/IPAddress/ipaddress.html#parsing-addresses-with-prefix-length">inet.ipaddr.Address.isPrefixBlock()</a>
    *
    * <p>Value type: {@link java.util.Map Map}&#60;{@link String},{@link String}&#62;
    */
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
index 8089d551750..da645c02400 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
@@ -80,7 +80,7 @@ public static <V> CqlVector<V> newInstance(List<V> list) {
    * Create a new CqlVector instance from the specified string representation.
    *
    * @param str a String representation of a CqlVector
-   * @param subtypeCodec
+   * @param subtypeCodec the codec to use to parse the individual elements
    * @return a new CqlVector built from the String representation
    */
   public static <V> CqlVector<V> from(@NonNull String str, @NonNull TypeCodec<V> subtypeCodec) {
diff --git a/faq/README.md b/faq/README.md
index 97cb4decd00..1fe06171ddc 100644
--- a/faq/README.md
+++ b/faq/README.md
@@ -65,7 +65,7 @@ At any rate, `CompletionStage` has a `toCompletableFuture()` method. In current
 ### Where is `DowngradingConsistencyRetryPolicy` from driver 3?
 
 **As of driver 4.10, this retry policy was made available again as a built-in alternative to the 
-default retry policy**: see the [manual](../manual/core/retries) to understand how to use it. 
+default retry policy**: see the [manual](../manual//core/retries/README.md) to understand how to use it. 
 For versions between 4.0 and 4.9 inclusive, there is no built-in equivalent of driver 3 
 `DowngradingConsistencyRetryPolicy`.
 
@@ -100,7 +100,7 @@ This ability is considered a misfeature and has been removed from driver 4.0 onw
 However, due to popular demand, cross-datacenter failover has been brought back to driver 4 in
 version 4.10.0.
 
-If you are using a driver version >= 4.10.0, read the [manual](../manual/core/loadbalancing/) to
+If you are using a driver version >= 4.10.0, read the [manual](../manual//core/load_balancing/README.md) to
 understand how to enable this feature; for driver versions < 4.10.0, this feature is simply not
 available.
 
@@ -109,7 +109,7 @@ available.
 The driver now uses Java 8's improved date and time API. CQL type `timestamp` is mapped to
 `java.time.Instant`, and the corresponding getter and setter are `getInstant` and `setInstant`.
 
-See [Temporal types](../manual/core/temporal_types/) for more details.
+See [Temporal types](../manual//core/temporal_types/README.md) for more details.
 
 ### Why do DDL queries have a higher latency than driver 3?
 
@@ -119,6 +119,6 @@ noticeably higher latency than driver 3 (about 1 second).
 This is because those queries are now *debounced*: the driver adds a short wait in an attempt to
 group multiple schema changes into a single metadata refresh. If you want to mitigate this, you can
 either adjust the debouncing settings, or group your schema updates while temporarily disabling the
-metadata; see the [performance](../manual/core/performance/#debouncing) page.
+metadata; see the [performance](../manual//core/performance/README.md#debouncing) page.
 
 This only applies to DDL queries; DML statements (`SELECT`, `INSERT`...) are not debounced.
diff --git a/faq/favicon.ico b/faq/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..87454355a3d48daf4ba2a600adb5f5b40a33a52d
GIT binary patch
literal 16909
zcmd2@<98+9(~U8)ZA@$@6WbFznb?@vwr$(Ku`{u6d}CwciS^6#;r$=pT76Eh{?com
z>Qhzw?Aog%l@+CszTtlZ0|P^nkrr3^x;Ond;9$Pyqo`C%FfdXu8F3LckDR}`?jCxF
zsh>huJ?@?6YBfySmuw@OBhV%UCVbSWq-3#armApcfx@B?G6B=(cfkta=x~7vAsnOx
zY3Th40ah@!8~t3D06nv{Gm2@;iJr&z_nR%e*n^*qjHGM1S9d3gE|Z{3&spy+=NWJ0
zg9I^T-v4*g+oTBM?T7H}VZsoahfu_KUF}Mnb+9XW+(Ea4YkznV8W_D%?U;<p3CG7f
zd2N4aTo#gR#Im|#tJUzpUUM7d;BceseHyTNaFak&p;^<9ON8G@IWSt<c?$3Oc1>_#
zkTZ?H=uk--mPi8^L<Ck0vzs^19ng=i1q=HQ`Bz7KtVxCLijYZ=XcX5pJt1iDD~Mon
zPJ`+nT@AzKzzj()h{}gB-WTT~L#t5sUu{s<B2^CVS-~mcAdhaC`!7DZi?|2Af#Jv(
zAH$-7;lCBEwBGP_E0U0GdLDx^KP`e0%J8nOg)VaHhdkHpJ=6#^z*S#7`(P2Dl$Kh0
zK_vsNJxrx}Jq0VD5E8@gD1Z;bFl1ULce6BaIRTc=$7ZJXtpEoz!HS_|K8E6QnxvQh
zR)`PTZK$-p;c}Y>jqvz~8@&$X_(wYar7~^&8iFa)LT}?uh@81?c8EO3fvK%~E9<YP
zE@GT1H;ouVK}1uAQChTq)CPgcVs;L#i_kxn2rzH*!JH6VU?X5&tvWB&obCF-)7o$>
z7=lQ>WdksU)MC^svpA>M_}6$|Xjm*igE{%$E&%qI>*)e{FP|<*muFXaNcPy*@>e7H
zj#bE?z}H+-M4*vAIOf0kS;8%)6URIlf|GHD*+nC{k<USdVh)c{?cQ?!m09<Q6FVY}
z(+1J-L%#09Az2~~tA_Ox+9=cIcNy?{-mAKQBI;?Ql4sXx;PfhXGMm=}0z?|t4QckS
zx@Wz4wTjG(mJP@><tRbU16Ybe-_7F!2^8mc^i$l*+zpB6cL>%d_=$1F^mjf*;TG%O
zzmXOW4PonDh9<&4`3J~oYX^vhlVhsqCE8Yg_69(aYQ1%!KlDAy*nuXp#oN+Ei>SrQ
zau}ec3DV#)szrK2+5-}hI8~fXRD*sEsp>1|uL&dd((b5~|J7wX6A7Ok+2vDv76Rug
ze<>OIvz(YM2);PH%N!T8onR;6@{|G1{cRPzJH68YX$$gN4haB0?V<!>)!#;?2D+|{
zar%M(?^!Xf)gmwjj*Jav>M*N1bKE;rt%?Z&4JNZb7|96wTlURiXlt48J`p)gKf2dO
zth$j*XIO<5>*Qf4@-CN*xDS3#P!dR?a6PGI$E5(l(dt@kM-QA;E>f7gAdh}&*8=;E
z0JZqL(*eB1Frf6nk$%4ytOVgG!?7MF4f+^@amKeTz`})wduez=ulC6Lx&Y}BtnY{>
zVilp-*fAic@gkOx>@nwXbN>d^>7&CRc9%^syTbkPUW8I=wwCxjZ8}22MDPLWu>m`T
zaSgYVND5_3AH>WhT8?18=E&^W1wH#f2Pz$EhKN$gzY^{2e7LXDgiv*PYE`R#e&-TM
zxam*ESCi4Q9(q*0dMe;6JUGNgnBk4`ljWA@+Vvsu<5(4W778WS)07Q<<%-+a+~x`0
zyqf8kS4%vZSef#WhBQ^G`=^9Z?edom`Kn@WS6sPM2fUi0eG`&QmGOc-P=U*5-BY3H
zq`!Q~U#<d*xM>&11;Zf<W7d_YDxqN_tiI%IdDk7C8k|@c&pInt*PbXZRoSQ-YbRI4
zMWR4Fv6;$eI*1C9H0sTe{NOS$Vc`#+A<>^gg=9Ex=7YJq$V>5KN7_g^X;~>#X|k03
z{Pgs6oa@(j@cNbWN3R|O!HmXa)=*0h{8$$^H_5?^i(Fp;dMHap5EZGdu=To4ryY)L
z22~2~uhgL=$j#eosIXJ(j`}oZi=po-_Z9-|s^PDcClJWmj#zVWa7ccT@>te`pJTsU
zu;S+TS>a7wwDP9x`+18<6n*m-cCd*Av(*SDzztsv5yB~CN-%R=k_J*{Q7jJg>rC$^
zfQVD1Mlx&3mf#S90rdq1q(ZpgLLmZ$rQyg_pv~Dr<sTBfpoC@DoZoSJ!n94Tdre1}
z@7ogC-t!zM<d(=vQxc^qH_(v7LF?=56p3T=W80#GTm(#$mVTji|5lh%V%}MIjLtkU
zzvr0^`OdU9KpTqLT?_CD$h5f`=a-tAAV}=QLli@E@HV+fhR54xJ1ep8xDm|28Z_;W
z1ipl<Gkn&Ib3gvLxK-7DZi~l=U;IX|T@akNrxPgLk25xj@YHSKV8DWV`|J})Tq<1|
zm8gQ2-qNUNAa9ruK`$)w6D?YaP{B+jfqUC4+PBNyBwL0-;kyP$j<^9@nGi`O!RBy{
zm2@EmXP}Bf$wb>yydBvTrROX6zMW7+EglpEIC>;hZf@>LXI$Mm92u%8YV@BXyV_dD
z*x1<V8;|bUX=Q6YhIoIHdMW#Z^}DQ=R5=H9M`~nlSbNr8Pd4*R<otBU*5*tO#&$dp
zXxzdfho8%e@ELyX1&~=_h)>M$(NG@pPvo+UJPBok<wN;Yi*S}LDe4XNg75__6+W6-
zpWJA_A4y|#xMI_S%h9g%_M)Wd7*5cQY_iI*aBy&ra4<0spdrXMSrFl^$gvhixHdAj
z1Q?Wv)3^gp$A|vGG<17r*b9}-X=$lW@wQ^MuOr{Q+#c2#^kkX(;f?=NA4Z^O^(9M4
zBUe`LriDb8XqR5Aey%ixs3bUPRD^(S+jm%%F;j=O$n(TDs84^tzh5M>Ea)lC1RPPX
z>t>;4h1J=>si$)&0AnPJbEp3^1%=v8*WyAhYbH|a{v=tfr;O%8S!YS9ceg-_B+391
zoom8t8HLI%+j99f<?PY#U>xm45+N$#+tj<qi1NdCu1~D8^>*I7a)}>@rvfQJAOVlf
zMju-zY<UfXuu8s^)a0}zn+8qlmIlPZ;o-B~<b-T=RFrH&lQ)MeWaTO4`}6R(>If`#
z<BoUa#I+x39;h*l$hQ~J7}6u19{=X0JRHuElgx^(a(wvGM&mK@PhbFL6r2<$9#lX2
zOdcB$K%!dIgR(_y)PwQ`-}fU-38&>r6QpTr{jSW87UN0)fV9YDY9}7^WMMHN2YMqD
zpsy|P;(TR(VKE|8-Y8Q>m=ww-gn#|)?9A;udZaC}`{3=<3Y*o<eT^senI3^%KSdMh
z2?N}(YRC=YGKodr<%%LC<h!j|+_G!C=Af;Vfq}z7`dF{FB2t7@aCSgEe1yy#)Z4I%
zPI_;IP{jZ@(X@0u+WU%FRdQ*&&o<8Zs%ao1oT~ziSfTLGU%!6ISXqVcb#e^?WT3uP
z*3=mX*Tej3UzqIOo3Ng;ZHsRQNvYi#b^2H`1>@9djlKOme0#g>dY;Vx5Z)id<51*-
zJbfr5FkR<TmAzYATr9+=Nljr2xGhKzCTb)m!i~YFobD(+AOO-oPa<hH9u(s=?)+n4
z1L2DRF<Gm_q0_7u7V(NN93geL{Bj}r0R`tU<ECr?lhHUkeSLkaHU;pkQ-mdF;I`j%
zB?5{w@Q?lrNNEFZac}Ggz{|cZgd9l}Z$GX$NcVKC5uS(`GE7cl<CW3}Tx#(Ive~5_
z<BxtRyAyG1s&+T`O}S<3@O+>@mUKPGr*&G-KT>>L1luX40IdS5uB7MC&_HDx%n1aj
zTOU9FycB?Oh020DSC~gdhIj)M=)%l)h1kVEp=9nWRWP)nfG+-U39N<@=&y8~=g{g2
z6r#74&70|rX@xNRemHk`*fA@V`$t;-!a9y&*t_CKDdf#rX`zgkO20KQ(bC6&(3Pc5
z3!{1Pu0V0WU&YKyi<KkkPt~U3<zu4KsY&+5*&16Yef+&%B$4B@p4rmYI*(^x-rSQK
z_rN8bbbPl<#2Z${x-T<gLb#<n8mO<^<5~Dd3;S?sC7)%kDL@=AQ9R$ihQ+iugCI2O
z?*fg;Zt#oViK6sbSaUsoK5K|{jMNzXO6!`)s0z6aLPFHH*q7<aO%KiKs#F@ngrgmX
zD&M`bK14UzjCunlW39If9D!2LhPJ$XIq%<feV|$}63$e^E-aV1m5h^9!<Uibemg`U
zb4h?J+?|~?c{<TS<R71OW7Qxfp>jW4wHL~E=W055slOd<<p=8VNEpb-{l1eq^fAA^
zZV^s6=3)tr$9V{~>bsU~F(u^BG;;YBAkZelVO2`tby{M5snwe*(1x!AOnZ9?%Jgwq
zD|7LzBF>(buiR~nef2_h=aPofU>mPU!0BoT3YM!oOv`pSs?^*T#Y|V$(hHj7;2?u*
zYi)3!HNeNumZ8RgQ&8smjfhn|%6hyJ&D-GXJRZhvK)$gdO}-pzC&#|LgcT`Hp1T_t
z7xw_*>ay6J@X0&$?yeqyRC!h?;Wk4@wszDd1pF?sRJQKdv~6Ea?CQ#KcL8_E6x>!i
zIh!amNa52n8sJ8J3WM(QN`J2x9b163$iDtjznyQWqNAgtrp6(^;tHAKH348y%;C*W
z#%3BhzuW)a(SGOdPc2xMWxB<}5Kn?CP1bN*ooU$?U`HY%-c+5e+Jjb5zG2qB@pPQ4
zB*lg-y0ft3&qcBmWku0$@dtSW*&<ghYj!vZwF^WJN5)ggGX_sZ);cgra}`xdaU%U-
zF5v5ye}0tTPoTS8@Kc;zOCET@{<Q0Ee=sTZl<74HXbcc$$-lw)o=l>iJ?&`2j?@J}
zkCtq>z%`?gROK?}NHhCw`KY+%^-v#H7Wvj~#L`#OO*q*!<;b(KyuPsTbuFZoveLS)
z@DN<0TRW#YMmR-7Kk7{UlIA3w!z%Ru69#eIQD<<-=seJ)p}7Ly3D5Da8!iNyif%7Q
zH(E|%dhD+us>rPt9vwL8Qt!SOaduWTI5=pmJe(afT1osPPNw--<%bu8eH*O83T-w1
z41$u7$h!=Q1Q1F1Awjb?3*&UXJt%||CVn3HJUIvLz+gC2^NavoDKUZJ=;9lwMs|QB
zJBi5N=-z?)umFN1OYOmtCb4wfr0Dd%{N+nZoBo55Qk=Cim&2*O$Ley)W5f2x{S7If
z^_rGe0j};xN1CVq3q?$RctR2Y1E*;>6}Eu^LjmY5FRc)ui$iHABH~0FT6#E4j>e~(
zZE3|LY@v&gRj11N043=6{%Ez)7oK}nXZ*UJip$jYQ%g%r@4xZG$D^jQva<1`KTv+O
z5Hrzp43#s4jndV+0hNaU4h|PN=64JJIN}YZdIGY*X^@mjLv|h%UEu7Qb#uF6za0(E
zQVl`>m*3LtGfW3ipkk`<1-sk3ySrs&Bke%A_S{tJ6dA2ggjLn_BC-$zK6KWSEHyQR
z^j5b?8lmR6R?}i-LDWC_f*!eqM%tK!^7FeJp~cRrsrzO}UAKGj0$yIcHkfc4wPMP`
zg4-vhj9k}Fvgqi|b!;6@54sS(JKnR~fSdiw6e_}1fMc+_t9?ETNk}XV(sf(<Dkctp
z99;%Z73CszSERM9U6t08zQS6&e<;f0BYY-^PKy6~KVX&Bnz%L`pQf(n@`uk8QtU$r
zozyxPaXw1C0}s`Z)WXu5h}fnZA4rD<!zpT_nx>L?V2XXlVhKUXxxt>`rjCXweNtCj
zo432E>36$T*0}p}t@n5RfyB9x-@3W;uf1bM2mrF00TaG%yzmRWLl~qCrd<vAp#V<o
zw{IT&a=BJ->}bEO%dpO_Z4j)%Mq)_}F}{U<Q(dlg0$Q-!&GTAzD$ea2n_fUgP11FC
zm@iN+U={ztIHTS(n5&_zZ?&@3W66Wnypo@6ho3x3jGu-un!ViAbJ-2`=r%~;(mm3j
zS=SYsWn{KL=(s?#GWK(vX1dg83nuCA%=F!*fuAg+-j1Iwbzb_1c6uyq2UDNLngmZJ
zLag0~lfLCUo0f$3>^Fh~3nUop)8or_9#uDz8=v)iQ8hN(zv0ngCZoD3lI5!Ni2Xy-
zM+iDg1B&d-H$QH&DF_G(abhfrq{J;#KiC_@n`NDZMR&+84#X<Z8<^}9OfKwO<A&Kx
zELN&M{9RLB*;-znpLHjUVUxt4kh=`U{R`dQFN3c~ZIt!b?af~+n7h`V{8AO?U8&TM
zeJ31!#_@p0`wjkk%;e-GJxj7o86#izysG)m4Kxi+ZGp>^v}8JVP_f1Ifh}Vq6O-4I
zMCrm6WL;RU5AUL^%kKAf|3fzy1;@>t#*I!7@^SH?Kbm^eacIr+HBjS5@MYhHt@@|a
zY-Y_*A7BLUx9R6OMHZUiw{L%P5h1f52bwMV?(0Rp6JHv(Mr*5wPF2td!wqQWX-{?r
z+jZYVyIPuF22ZYT)jV*@Odb^?C>2re92LiRhnj%|K5o`>ID4zYJzoaH4U9ZZ9t$l%
zP3?To#Od2l`V7t43995%g?a0}6bZcciH-!}kAI75E5Q|j^Dem_9D{iZ=h}A*>~T~-
zV=d(5<o4@w`Q1@&o6UnAhrcO6f;9Z)QUIcGhfU8J(A7WvrcdqfLs60`EUFY0)2}IX
z(Hf}wiTUj}GK^TXSh^p?&GWs{?CbM|f1#<HDE436li4BAUbIwlVaO0Lh(8pgR9Z|(
z-n{|c8{YW0k0Ku*7E)WDmLaHMx?8O|U4hI6?3IfqqHs`2VR5+8{*QE%b$qGQD|yqS
zB;L_W_q8>Z4rb<NWX)9wxeHW=d7Su@m(-ZLgAUADp(#ljR*isOr20bE^3Dh$eKy#(
zLe|^z*&-W!aef+P60oX;D>>Q@OCR2P&PxfoXTeh##$5Adc4_oLNo=X4sbjVgMpQbZ
ze~ZZxZXs5yt*MT37)<f$>zU4Y+`e4ZA0HgvT=k>!)U*r?47^s$HAycoFFp6L$b@I*
zQN5(0#m3H1_CVGUO3H3pqsmIchsQY-oEdTd?U#4)DknjyNWVzupJ`tfgUkC{{P`N~
z`PlcNIwprBcd&_WL@{6Cmke}PSyl}h9PS<*s07Rn5aMY+`Qf*uqXLwELZG$VoGhQw
zmY3+C+?zi;cnQk>h?YP&x_i!~&~EI51}ZxFTAsx0vU1E2s*W6+#}pN^OX@O=cW3?5
z<F%voOBb;&lsiqQN{V09P$9e~4cWQG0(sggVYugW$L8nq#|D6QDEz&W!)9<r;aos_
z*X$_H<D-Jho6KY$C*!5IERZEVN`W$xIL^m2e*p1s%RikR&wU;Xr1h9^Ld{ZBG~!E|
zYeU8L8t<zbzq43;kfUG3a&U7}lu}}TJ51M9Q#<KY)YR0R0$h9?DR4zB8o{qx59ssR
za{uZGNdv*k3}5d$nu1Fs)nQ%ZNj2K1r==m&(=yghG1J{LJ)M-((o`3;|AsoG7~Q+|
zkh%Y^kn;{F;Uz>a(TN67u(*$Wd;0j?%LFPNFG9CU(>_l&GtUX$%YOh$^IGp2-}Wb<
z+g)=<xi5}q4s|1`8GBzBsH?>Mn0Onb3>h*NEsVi9vxeMCOo)Y0<9@ntdZrvzk_x$Z
z_lBmvW&=kO+rRfy_pSH$Je*ZC_+Ih?y1U|1TP;Km8;B3Fv5$bG8o~;<#YLv~Nh#>l
zEETz)Y>k#7kRWahdqMf^#r6Y?{IW0C^nJcx)oAzN*RNEke!1g6mxO~rx<f=nyV8{C
zr*PpE?@Q#VT7{tNrhqo6ke-I=#LW2h?2F)(M4$!{kss-<I5>R%>@ksnsw&3R<YYdJ
z1(~YS4-Ef`fQk8i_yZhcZF7y8Dg>Gb!tq4#hgR3yN};|5lj2k)^s(yg2~Mh?_Agtt
zU^#c6enTM4a@dg;yGveod`(3X_<m;)zK89;fx+hH@H%t8Vxm6_T6xpr#aKBgi$CM8
zpG`izm<jjiRFadK9=io0(*1qT`;8JAWN6Duo_xDGde$Z*LN?%_TvaTm+X$^EvoK{2
zGhItcZcKZ<@|15kjT-+9upiaJCSbX9<FVT1&dmI=Phz{(jYlTlR!P{vFsaw(cENXS
zxNE!P0{#>Jm1C7=sq(f2KGx*d9WvJaiB{P*tmv549{>RpU>EyzOp2<sbf~JjS_(Tg
z#k$<^!ED2TnG>T76<;H2%D84s+%SZpw4{}OMvBDGNjMr$B}w?YOJb<Q^pXQL2#s4v
zTB>47yI1wL_8_P6@a@#38Mr5E?hCmLge{Uuh8Ozehj`kE`RU_74`oZcwnALWcXGI=
zWH4gmTqmwo_S^XE-fyAF<2mZNJy=3&gMd!-l1Zt^3SYy5ek9LbhC1~#vCK-m_-CHq
z87;tJyH10sl$uksMz3RGo=A$y7WgYQ#FwYATi(pvAeb$Z1OvSMTExk;ZQp{A&TO>4
zs;-WKj;^Zntg2c%Ew=RcU#O^R>p2cP<>7e}DdbUfy|-5!8S_K}cCx^SI-cbV64-*9
z>tEmGWN{y_{L40TSBjC+7-=86Ja?m>V`#sX$tAFP6Tk#tOcQw^=1vsghygup4B1mf
zm?^$N_&g&R?nLf&P~OSCyh*cV?kw3bffW*26%rbYYM9AxbQ+07O6uCsU-iB+-FOh{
zucYD_kc+Toim!9s-``Kxy`O1bi4w)MD(kH^6kxd0w5Hm>-#VeOcK5M037;a&CS70g
z;KK(*O-$@MD+zYIEyywdA><<TcV+xAqUjMp4jZ~(v1zN@U3N`+=%?P%=>mOwoj$KO
zxzRpWc0b3`yLkdJRNGMQEZ^YqG3gJL+UR{e(Ovc#!KhBC`6QZ98Pihjhd~3AA0Ds%
z{xX<mk;H`ZxYq33<6WUif;O9Ytwn*-<10gA+7I595`{|wyy$b-;+8WSOaYaC{Ao%z
zD5|cGHlh(%SI45Twtm?5-}ZfkJ3*bm>1Hof)M=X|;$Ur_AN{epg(9jr%>>!L6{Z9~
z%FV;f%&g4s_qOUh`(wrT1<yiRpFN1r9|>SabdSym<j<klb|T;-PFFM~HH3jLM`8ve
zP2^Z(`9PFhx-dRpu6_GRT7z8nuOWwaQCgk}8UI1=<~UhNXFoC2_e#{p1d?89VP6dN
zdC6K$+EXU>654Y1wS$O<b(1XY^E@H*ySdB%I#8*MHk^FfYLB<OlmKyk%Ptir?96(1
zq3z16$Qb%Hyoa7}Wq_%Oh)Bg3U@mH@VfeRXQ(szC6tw1i)KH~v{JqA69FCxs-d&Hz
zOBg3;-0YbF<Y^gzlyB;l`7I5Poe{r#sJ-ux>FIaoQnv+6zt3=?xl9&qz&Q&}j`G_3
zvJ<)!HKM{k2tm!Vwa5FhC_Zc0)sR2)NIEDkM8;PNr~cAjK$NQuEybH>&uexI>4(Zv
zPqRJI<Ay7af#GaGzAnICzqb0v+!CK2Z7T4c=t@l0%ZLV^_fI6wIUPhi*x#zNvx&i=
zpeo?3Kyvd8Uo`ypJZS|5BqzCrOaU%(7<JVJl|bC4jlIE03eR7<KRTBUai}CjgbFyo
z;N^_5G?d*xkSGm57>{#(vAKPZ&6%`XBDQNbr|<Z`8aDX<RXm8RxsZo@{LNdtuh-rM
z4SCqPQ*`N4*a~2p%c=6vH&V+-%az3l?sWngOH6JE&%}f~O#)ull>Dov9+CO@_|{Q~
z1w52#M)Pn&`6e|X)XuMA<#HGNQppm+n}5;3Yg=EdBlVIO0x#SMTK7klXlQ7zea=+#
zjVD^HrZQL|<E1LA*OR2O(&Dl8-P}ZBGPs)v`zBAeo2Uj9X%eSJGt)!tlCO`OFM=G<
z^*=0nUpKFQ?}p<19zx>2?!cpHt^*r|B!jxLUz<@{{<~k_wa!{PY+?C>FtbUdS$-yi
zBP=e%)zmwL(kijg9gok$HP-cfx$)N!%!WO;ifo7b)mG=oP<S>tM?31Z_B9UVIy6Vd
z^>;**lu3?q>MnhOa7;0gF$lB8r|1CdkcgOy%1S0C+RBQms=a8#7xZGO_%gR{w$HK%
zcmD&+SYas*keRG#9feS83OcZf*Gvtse&yalL}Az)#<ndml=F{|j|wMA#{>64M^3Rg
zaw{BbOA&Pcuv4+8<6ld`W-FYww+lwVgpWjs?+pGpG=>zaTv<1HJco+Z^ghwHZL6$l
zQM656FMj%DsG0Wi3=uydbZB?x(n7jO<FKPFD)Wt6**Jq*=CJCycgF*cw^cl5L47Lt
zmxP2w;nzMw3pjqeo3+@YEobq4afu2;lJkGV1m_rykJp7Oe8XWF9jZ9~5oiU<;RPg_
z@gqNY=g<%$mwzsE4umA3iuP{<h!3v#k$>(utDZe7A8}Wl@`-0kQ7H2;{9p}-=qxLQ
zv{1quT~i&IU!Na8_s)8Hz?iHAiaxa>2Bpz~Z4M@yQP%z~%1ohK1u5T|Y##1SOZf+1
zoIJU&EM1II?oCmH`5}FP)wm7hI$?>DqDVLg|M<ybNk~st9^uhh=Oa;BQ9(mnUxE8m
zS-JmEQ*R&y9wS501Saek;lO~ruCZJsYrvr$%QTB!<W_dl&tV@)JFL&fzeIcHBqLbh
zugHX8!Wj5zAqwF`KiUfzOYb0AE1jacg2RP=-12}fgk`sQS0$wuC@C3kO_Ku1u3z4B
z{Ed-t<U3<VHEWJx=^s^a8d*33#f?^}5k`?lC(6<iO74%vXdz^1*ZMpm{oAjY-aJL{
zk%>39*VplhcQ`RJ(n3Z#pQ;J`_A?58MVK8HQynbMNu%W0(7iV>&@(gFR@D(Z4Tiw$
z`8^-T5VME<ES9`?6qyqL9ij1qjMTVQp9%H<v;aYxvx4Mlj2)iy9QM9W7if<qP=Q9v
z8_D2so`}6a`~}>58*4|0fow(Z0&j^{K3>)e>t3!Kd!eZE)eNQ+J)cJYJm28{)w#(o
z_epOBD#+*ZrF#2)I5TDPhdO-hY7?(o6v033dNwyda8pGN*9@HQ#lv*kUytQ(59Q-f
zVn<6nUTym~)LWE(+jJGKP}T%5Bu8VE?|<g&wyT`ermYj8gz{zR#Zw8sf=GvB5i3+S
z`rGb=QP+MeORbbQHI=ML&dglDjY8B+S<jIn)}M$q%5ZOO%Fjw!N@=y0b2o?Zqa!`V
zh}z@guAH^8sa;AJWFm9){$hsgR)I0g3fxP=sD4`O0OB4wH&=5G`Z`=4j9Q@ZK}+RJ
zEBvdlayk>MZ>Z)hqWNiQInLA_>s`5i4ROqzG5Ki!=?+-p{yl$Xcoc8g4kyOH;L8~r
zJpVEMDg}~M06uNntu(tX{pQ#-8jT~;1-<N!s6hL47}9XdhmfmHLY)S=!Hd94q>=yo
zfe6k@qVM3)r2us3x-fvh;~+zShK827JDw$ZKb>SM{^|i#s+L!Y!s3eS${JK~J0XFS
z$-(<U-fkw;@<Vudj)M2zz2R@nJPXJT-X}*te<URXkDu5Y>wiovzJ7>k=cV({W=;LA
zBF_UY_XpdYYjyO6UKk2x&xd*{zK@P%W*0k!@ghs9$f5&GKkCyPdw7dnwpGYOh0mBo
zb<@}@&FF<*w%jYS_>zN(G#*5$T(Xkl4(9A6UDF4?sF;c5$E`xH)7OU!drM18!r|&)
zavjGb(fylykH=`SVTf2H#q8j&!kDA$-rczJ4yw(6N{3WE2X@B3_`al|pr9gX1Z>M=
zM(sg(3~FU{byqbK*R=u4G{P(@Wm4KZUZ+JbR~gyJIxD@qVS;Y&252&<-H`D@=3M!o
z+7ipR@}Q$TrMlhd@3DI$ILmiiyDVX42RA}`0@(=PY4)Xg2&pl@AyvgzHp;yB?%y+Z
zH+4lC`kL~kk{Rl3a=mIYHx`#RA8QMKEtLuI=s2`wI09()_ok(ab!vqdG$>i`aDKP;
zyPswbC>wpeTx;&Ct*sU6;Mug4npiWhyl!2anio{V2Mqnob#|P?CB#zKeBFRW5maY4
z9&RZrDoX0^7WlY8Ff1r53rjYi9^AhnY@NC7;fj7C(}5^W@jwzO<oDKAkzF@|pYbxH
zHHeSaYR|pT&l}8$RBc*z$fjoZe|C3sr3B)m$;mQhs|@uV&kD<q^V_Wat|$$4o)KWb
zaH)qWy!!ZS!!vw++r*J5|9Kew*ZQJ_e0J1xf1+c*X1v`cR-(@{6e-+$L5>H1|LW6?
z>(792KJ~e@3aTP<uGYL>UwT*FGe_dg%uFu7+uw-MeMmGt2rOf_vJmK*Plwg_@MI!%
zJWrPI;#EO__pjjFH-Gi%eft7Aj!PColfyE}8G^oiVZTar**&BMvI=@_EV*h$;TS68
zvQ3+V;K{DL^mCN6W`zJN#jv6+La(}lUqx1X(%a%4=5o^!uFzGgN1(DOL5evSLD*T9
zBES8C`tt2#`t&w`(=FjF!EpS&hpQto<ckGtzsiMV*ai*<p;4VJjy=f|Yw1f-S~Yg|
zrvAr=At7DpahgDNfr?HsC{$!G1#Iw>!_yx-#*>BRd@RMkkwIO=hCi)o3d(3wqHlJ(
zo&&_$Xq6|xiKKG#4%I<HrJdh+yCC3rcEPD9DT?<|XkR!<JdJW-<fLK=c}p7_=G^a>
zH18VYePf;xu$6Unvv=E_TTr18zqhZVzDxqBRs2ajx6_g&OsaS+^zgJ~49@;J9Ui6w
z7Z!r7+^RW?6XDYR-?LXc>3wwuOW}!oT#!{{87B9lnDv9N_6_Cwn!7j$)jyl@r`H1B
ztuO3t*LpHv-&Ctv?Xp8Thn{9v0FIX=>B%fq>SQFE)3_oF@VTkSTppE|ET0dH_*+(%
znq<(n<8KqF<qEi=OQSO6WCawSZ^k-RJ$B&)?fcC*Mww+BUmuSe$dMf=<?@6_H$Qz>
zLCH%i^`!R4zHNf}wg~*3(?e}A7lQia8YfQZ(=C6j%nzdiUx{tE_p86S(ENqP{m+7+
zV+c8;zMvwHW&W-o{W4T>aFE@vY>GBrDU?HFnp1hvJo?R8VivpXt32N5k(m{3?t8>7
z-%}ALz2C%v%7Vmg+1sBt@wiz=ptsqiV_OJUh3mJ&yBoYHe*e!jT@UX)Xgv*s1g1y!
z_&x=v{@}})QSP+fA?SVj3Pif_EIWnVuPrdOu`7|0HXY?Vy|{HJFj=QF7C)Ock?oze
zw!UGf$&z!E+CP{@?&tE+O>AJ1sXT%rvnb$a&k$1Jv~7Rc@xT^R*696snX7UUo0rzG
z$(t1t;tOGr9K`~O?=u`E1A$(q(r6bm<j)+`sks<gpdn|b=ew+eryVYkD&a6MTHq6*
z1lSb>M-qD5MUi6AYoFtGUFVRD!%w}uR-XD0jhFOwImzh@MWwWj)LfYpcdOKw9hahx
zGkp(~<Vsa4rms(kpt5Y$*9!k?((V0m2?J?^F#n__@h(Zo)4;Pfa^&BiFW<(tp`g)L
z9O&NJ;29DggdJ}muGzuTB73xZE#u~GsLbwXBcpQL&ERPw_cKm%-44cyZLrj*rMnRw
zDO<#ZnB7$`xnjO-`1oFGUFtOUNG(#p=kOJUe7b)K)CgvVeH&iN+G(#LQIXZN$I;d3
z8GzjWV3U?%%Z$0Is|M}kD$_HxgMuC@ZL`6<Q2KwNge0T7|3>O%RC`*phPSY4s8`f?
zNK?L2DHjJIJmsi4?XEZZ6_|)$sWmM?H&ecOtp7XBCieZ?*x&tp7k$L6B`hNo>17$g
zg-*NXpi;Q?y^VJy$tp_DHq#e{EF?<8=}`h919$PXBBy^BPtG#qm6iDA9N5y*;t0%S
zcZ4s!_+s6fOEj#w>t2^AD66bxvZyU$X)U~+VNv>;VdD$;mpNP%u2;i+pY&l+>OskM
z>{e?Wl6!An3Pgsv{MexR<&&(PZ04Hd6`S*Rv)zz?cYu_sDu#n_xg(<orvtgY9EixZ
z(b`hftdZOA#D^<wdc})=D(mOlzV5zNbnu5^vOXq|#<2@*Exf<#G%_2eRGwcAFt7C$
z#)r1q)Kmxqq|r6-8n(iOEU&fOWYq;s{S;`i6JE}aA?5tu_DLq`>$-1&(Mm$T2iLnp
z;YE2hsG>VSXksLM6EO>wR2B4QO7QfwC0zwLtV`GNlAkSvg2N-rxSat{C#Na){>h<V
z8Ruf@>8>nz!}GzkEalMoli6?JN*`m6BQ`TN^bIui^D7X1yo%Lzb4JZnr5x|KQ?PzQ
z;N&UG^w-`cbGPj-aB>kN-z7Vj{ho~?I;AbM337!6t!{0|Y_vpXVjJeEPI4=$dal13
z6XIJdCGa&m)$ErLz@TjYMxxL2CLD5{Us}Ri>$L+tm^Qtt1vNMF{|x{3I%awaA+Zx~
zw@MIzta=*04N;}fG9Ppw(2%1_&NrM)mpG&C@;zIC$utVPw47N-%@ye0%YGb$!2CA#
z)jDwM*y3IjK%%93wvR1gw30*ItOKP5g&_G+)Z$FO{N0N*!Np+F>ih+(LpmJx$mMh)
zrD*b79o}1)!pC7gGGGV6-#6K@0jlI+8K`)WUhUR&qr5twA+1QHJ(vfek!#~FaUH~v
zyTjAX82vi`7r=|Ca>U62SLYXGC@C;&QG=uh2a9bsoCov-*_=${cbI;RB5)K&@R$>U
zJY;BDH<*zBu1>sfzd^tP97KUGMTyd*fLh%)vvCP>Th4%F&I}s$m(Ut%;l(h0^mSKM
znbr7jkxQ2X#%mMX<OhK;NRsQ03?c?zTyxKfHY;^K3mnt0<}*2`BvI2F^Q7u4VH(lF
z`fh#Y#Bp_ct*UrO*b#!J<~h}6W=_+F2Il&5F|(`uo;%)~r%Cx=92b+}X5cOgdC1OJ
zI_NkoeT4H|6j##X;+`g%by!}S-!dz!&eX`8HDvmc$?DFikgw)+j=vv$=dm&`Tf!!s
z%hr^_pFSlM4t-KAB@J}}FSEjGd%4JCvzj(ep!8$#3&I65D-o3_P@*^9U-fns#_vWJ
zwO653v<xKBIlUS&_?Y|z?^9)KoO;rS(=womq7C9^za+v!JT9FZj>K?q?b`gfMD}M9
zN8FU#KM*C#2X`eBD_+DAg}$_pk%{Wb%4*e)YAqFCarJv12Wq#O5v=?GPE3bq;c0Ur
zmQ1^UbRzmLWRluZIvx{%;5uW8uew}gXWExc>bg6-B6}|8iCsq&5X3B3k-<^!yq^vw
zzN=zSO-5Lz<YFK|F~VnuxY}mhkwMjlBRkHv=98gCmqzm7$GX{jUG+?_Z6#VS`Dv>b
z1%b^iWrmTQTniiCM5(G5i5gl}u(aG<8lzPtFY46rGe5F+d6Y?tNz-1SWCeIrn335;
z4Rogc4b+aS)x*-N8Dn%jU7LL_JzL>G0?FS#0Qi_P1;ZffqnEl+ey<PJ@4I;~7*?0-
zR!xsD4SBo@%f+8N0r#3JDZWVG-hXr^Ye_TWNmQ+=dV<b`$#h}&O8qn#-DU_n=;%Pf
z&K_~Pepxo+<39i2^aNWT@MIiG<E9LR$Zc(3Inb1{5OZd(1Z#O_uE%DejfOT7xOyUK
zCWQo{0E3y`uwZp2oYNv?e=do3!}=`w&4_Z2y403vXAK34mONTF$(0fNLMGCUaP-nU
zCAOrW>KciZyF6kdZ9<}DwfJU_|LW#G-F@zttcya)Y+b3*+HFK|ovbbDFe5^IA^VpO
zV6p1g7qCK<@B}Y{mxB&EjSk4A9$^?=1&%`f{pwI-Tv%Ex-6`Gvt-lflB0XGz+Nz6-
zi`m&};~>e@ipKP@r@-0bDME4y7dBtEGuid?IBg_HcZI=m?NE=NAZtqq&EsC)Q*QQO
zlzfiZn=fAvnT1XtUqkCGPS}M^nS4o&o2hK8OFg9D*!oLl!aO;`X<(MYWR4}oFl+_p
z#_m9m%|1#P7mcPmNNMn7YLU+dIOTB+zsBL!<?9%Jia^H~k)X@y3LF{=Wc0eG+hxjV
z2tM-63O=z@iY~9LT-ot>Tsu}px?toMc+Xd1T+>&Yt`Im5_Q<m2bOY&MDmuX=#w02h
z`^BvP;vzzkcC&~ErG@BL)6thtXY#LfUl&FHLtt+IPsWHO#z=uJd*T4~!qe+b$;Z#f
z<8p!ui$YvdSs8hhhOMKka}p&PDOtQ(rz}XqlpejXph8DSS5Z@Ax>q98zA5Xoju&WW
zCxgg}S*9g{D@b&^`R;tYrTiPvkBZvHfL<ms*aYl!RDj#)3>%%h!KDj`qB{IZqH`fH
zI-C-m*RLXrm>w-IFrwP`gqE$*tH`mTC}m-B9{B$HC{;Y~(qdYv82*l)nqb}-aw>Wn
z#wbTb%;}PW;3Fa$S?rgbwtyhTo1`o;qGZG{9REEI)JXb+A`m{HwAwZ)nsN#wDgdSU
zciDwlr7~acjN>hB`J#L-+u?x`4aXXwW-rb$qv7rg=!)v<5{SZakj>?^G-s8SG6w(9
z!zzV3)=IR>;ws1-r~D#|V(|FWGTALy?DtG#CY+uoY$9|g<Sslk5NWBh0t)0#oBzzu
z|4R@->!{)}m*GP<LT)n5s-p<Zwb5)iyHaYlUvswX6wzeB7F?Wjq|p^6sFa`ngePR_
zcNpR*gj;o}JXZn(7xQfNl^Em!2f*~n4fgy~D8Mh6g<7WZe1zPeBHwR=(u2tfA>XM8
z(9xwDViIFyhw<gX_v|rHV!=gxdh_dBIlu4JV`}?_%cKBwnT7{i(rcAjQ74a^l4D2z
z=`5PJ{PL?sP5KlzA`E1xghXheGR^k+{Y&m6t3vXd5plGT7cIt2JFb5PSo&!4$H}PZ
zDy>Ckf!q%F3yK%pL4s_^NfT*KLfm)D&nEr=JKbRlwB^2ALS_LU68%P8QA;;(Z*MtO
z6BE_1yZ<R#NWc}ZXF0g}nQX0FPrz^8LvR_V>kfQ9iXA9;Pd}~IwYGIe1u4Y9_?!8H
zdgdc=Yed{oKL64}wWd6%b`F}Qf?<s{F9G!KnX3%d3I&q!hEh8If<PtFLN$0LVTr2Q
zGx@z6kBtE%mK_wRH-q@mbR5K^eR&!~gM{uk(J}^s<h5f1aVIn0@sPi%swPG>IvOEG
z2xII}f<soU#u0d}>rigm6XWAan}rok)mxOJK$Z<Y{as{@A2+aDPovE)003&F_};v9
z3B^}7<K*UU8z1PP{07gwMt5WU?YSQUJRhTBKm(o>JOtdC%148ax@|g4X`ydI;lcUS
zSHy6ex*3g(8FL-A1*`lai>|XQEh(4HPrRP3sqm3sMYI<t6*~r<C0>L$ijjr}E;S`B
zEkv}Ce3Ao*7bU5XH8U0o#C6)ktQyIU*j;FlZ>SxJB&RKs43JXgz2CrZ=SXyGNe`yH
zSj0$EE6+~mqO_G>U8pQCm!w`2RN!XWK((?r*)DUn)o;t{bk}UKnKVai3qMLr3l2vi
z;@bdyJGNbaD5^0dGs<zUbtjjO_XXJjJ1ziI=fsfa>(}Z;m-1C5N3@~+m^;=8N035o
zxxl+m23&^Zajq^GIywPD0m}loS-60R3UGo5qOvAn*G9tkrFfiH_)N>8L+vxUQ=Vj+
z=gDO2bkKzx5<L^s#O#-SsU~2l!nDRI0d}ljxAJ970?F&zch`rZ*B<YRm_Fg8usm3~
z3pypzE48%TYUyPkN@(uZ3AUAf@|8YhNh+Zjs57dfrcv;l-q7sCRK&4!Ys(W`ob|Uy
z3*}!72XZ<n*dAA$k0124M3;)z*47?(0`~PYY{z(Icr#mJ_Zr82_N)lC?Hv@rE$byX
z&QzjfCH%I?gsE)Le%Ls+kIbL|jt@CS?P_?Oi9X|YyqQ?RaHz9ODj|!0@6b;^PApUh
zZX+vYyP;z*oFc2NwETRMDFm3iH$VUWuP8zqlID;75*~%^4ib!+{B7Zl$>t4r0v@5#
zj7hDN+C}Edn&v^XHLFVjdC7z$T&na7#fo}TA<s1%?KWkX>$N2;+KJdRhvgqonayl$
zY*haXB$5H;xC+_edzmNvs04afiD9zE#A5l+Eb37qo@^c#*gv*u<rA)#3d=juqG<Qz
zf<|aX%sw99_9)1}DhEhHCluqM(v>@6(`8o~2FyejO1mrcxZb)o!3Q<2D3vE|5OK}h
z^*H_VmF`}Ah~q&Q4=+Bw$~0=GAZ$RXAH*{>RJ1G{77~S)mON=+LeL(%s00<1D6~h=
z^HVU{1~Ew(C>C@s2IRD@_BI0~vrg5~jC)`<S4T^G)7wqQwzL7}))%EUy%7=t=6pKY
zRyNip#l?_?=O>DM4KY|EZXrV#wRU#33bC<_JxNn=nT_~`57<4NP{!anZ?bJ2ns@zL
z@T!dMh-R6|DvV4knRMTjuN=T9v;h3Yw%|J&#C9tPmh7p$&tl(?{INx`0~U9a(e1Hi
zVKY&$JK^P!4r|ceR5VIcUWkbdlzNz#l!C!O6J!B$R$2@gRW9wKqQA;&EZg-Ytz^a<
zzSulbe^S&b%Xq%RU!YY$Yzo%`02rv9l0g=~iUk*9f+SOkqrSmYXl2!EV)#`J)sZv5
zbdrGOWk(XcB&dm<YkqJAd?<z1`ixlFhEq|r3S@>>^|!=-PY@EsuD8eM=o2|V6c-Y`
zRlTvjdiF<uwwW8avjP1;LEA-pr2ZAdZ?mFfV4cX!a@Pol@b}8H#9Zp6-Arse!8nrC
z>elR(mV5#X>c2$-(SJO26;KsLbgTzJAlT2Pq#Z<nyLaeG(g+FRDxZnvPhPln=`pz*
zo{8ya3WeH%G}scQ;S_*~Lo6=(+&S(Gd|n_xsU0ZIOuMYoCH_nAi5CCI_@>UXrMkJ9
z{mha;<uzbSJQS!DAD|nmW5uAV;Fs>$PVdM`SA`<H!Af8LPIIEsm`AsZU+}G8WdKI=
zp{h>kLhNjvgQ(Yb;G%-v=d&DMyMRGPsR$zY6IzRYU_a<l<+SRAvw+Ws`00z@eIf&A
zgwRPk!&LyRBKQ%_K-u$V0mcm!Iiw)N*{uVnigf-ekV3Sgzw7nWATTXAp(X|p$R9eT
zWqwSeU=ql#cvpsGLdeUZ*#HP<U>u{6SBi&Y+~i`X=SfSadB)dp{bsE`!$qe^GzP~o
zRes-G1V{yU1q_MivT51VY4d>i;XIV94)1Xw_!L&nhG1Ui42x6XF7SP-G_@gGhaQ2>
z0wKUOB4JMwvrDnl+0CLA*p^@Q$n>Q;3J>3C5>PQWliBFhO+Tj|5siWaTA8%$=~n`i
z7R8ff!#~?ELW(B-63p3uRpwSJMCBUV$qfqab;h5|>(oe!*vbrxYn=+d|C*WM2#{AB
z3^gm$SMJDIM^Um9=6B4IlK2EHt38ae?N+6QCftyEDUI4;+#%WE=#5o~4<10TsX)X-
zAxEz&1_EQ4H%t$Gx}NhE%)&J~g86tVmv3gLvTY)Cvkj#Xd6;y&yLyW-i11-BN><n0
zM)3jEg^EPXu#$6(>$sg+F~CzR##+D*GD4Os=Kw^%WBFBB=>v4v%UN;l1N<vh4n^TG
zbiMXO;}3#|GiByoQ=^y=saLu-61ak&boK%$t>k_?!vc;`bC0ltm2WUa2LJjUY+Y3z
z)fbsM41+LPMuP|x<`_I`k=6+<LjBS?5$rLdP<tQ@fV<&o6E2{gpkuc7;?jZHkO^rQ
zaTuj9_3(9PfFz17$F6%5zj-it4a={5c!#X(CiqEt*NLayMQ3z96~=QRiSbXK6{(Z6
zzoyyn^)}Wfk4=tTbu*@a-EEUq>R|lHN$m&Md}E@;sciJZvXu8-OZ$X$N;EQvh+V;2
zOX6R)G<|SG7=&||0lS5iixLIvcypNZ|2R<>0<N@WiL1d4s1XXyDp9_hH5gWzy^t+-
zG)F)?fD!CX`1k)lSa<)qH=PY(eosdaA#kN~`?Mahci@kS{2iT+N|V4k^HMyLkD3nR
z5`ky3UfE)Wn&*BS(uHTmq{71rOapy6>-swZ7ynFW^XX@oOh`i7y7OPG2~FxB$l3{x
zdA^9H-pK#%Y`0y5h{AI#kX}CF;}`;e%3!H*1kN6dnDr5&`c)wIGwWF|_ldNbObXvW
zL+Ozf3<Z%`H~ewwSeI{=FRw9$2v2|#u%@k6C*&#C^mIpv_+BbcbOV0K`9z|qA9;|7
z!PcYWu>-zFWLk;JLm1>=&^?i)NI(sf`ao7Xu2nyzM7db(;|Cdh;=T~%U5ai&4dix4
z70yO_gzR$VjEoB{E_+!W2v6958$xGvgY5klP*?YkXb)ra^SXszv~qOU2(p_(xvJyS
zP0jhUwEED6V*CK#t12TztwY(s<zw5dpO$AGCj3d`8&y=z3Dradlx-VPEAEf`IxA^Z
z{p&hMM64_fxmtBAq_iTgt~8`^#Y1L9*?qF)21Od<htuE{7KY>o5zQO`bIHs0PP?N)
zD7t4{X!W<8Zqd=}OQ+qTl*HQLvtSgB#7mJsi__&G8n!v_g;K6Ce!Hhq<;fGeMQXZc
zgUEGd84QgM^$<c(Sm+Ej47?pg9@i4(-wSfuzzpPbupv-*=S<>&f>#|S?d7`JfHQiY
zh#js}!G?t@6qURd(~doXJz>GNmF2Z2!APNx_KRp##tOK*Wz@CmN*qkn$`uMC2{swX
z<+U2Q3<%Lmc3Uu$iWG(cIn`#=d3yh`7!XkTyT8=!y5~F>LcmJcS<T6Z&@L1zq;OG7
z|6embcPeC@;lC@6)HQehdJAndT?wykI5>SPaJEPas{s>yTQ;@TW$<6m@AcoP;t(;%
zv>~*vYibW(=mepH1T=iKLJ+06rD-pB2nPr=Fq$nB3u%=)&ttS~bDA?_=3&wBmFahg
zn)yRD0z+<8o=qH@3b)j}&U)9Gl&=8p_d@fwUHpDxHFwgm|EQ5J-NZ8qnikQTcZ6)Q
z>Ns6%9mI?8A>3>nt@>tN)6KwzR(7J_Fe)ryqfwF*;<1CNe85k-ZzpKE1i<9oBHFjH
z`opm0w4qQSEGN!Vr&iyV3R}=1TkGS%x%lHAM3Ni)O_f;1AO_dqn6Z=(RCF*BJxNwC
zEM-RiE#=E=$%Z~A2IfuDRL=+W6?GqdP+ixHkFoF=r_tE;R};HRyHP=AXY>GMSzq(+
z`gHq^7h$eBrPNl(NyYKu35aSZgy#Y}H>IM;(3f^TlP1>Pn0~x6g8v#&<;xLnb8VXC
z0<Ztp8c0tl-X&~juq`%zIs$h1sk&nrn*a+Lm=r9xzd6i37amc_<$5vGOckIz=%;|k
zzI^)$>dN0J3#5tL?{oUVRI3U~_?D`yx!Dk^OG;+nPsRhUyDaSpoz@T-B&;7K3;_>?
zrC&ftL)Q`+{)b>i!KBNi&1&KLU3ybIl07zmbf0_H<a|D!XrZNKrBa_K4Zw`VZN-O>
z*7QquR*pbylE9*#$S2;myPK>UvBo+*{ojgQA3wlHU0&I1ZQxUHmz-yhU6nIFFelfq
zE!BeB*iF1jc?AS0Uw0qkxFcB$L|dZ2&`q5A{pU4#c){m~MJuI*1p@PU`GQzF&L5I@
zlAOPHth|T%Yiyb}&>-4meWOPg<UP|Pf>q^Y4rR9}hjI;{j{zA&7!8n~h3-}?&OM=4
z>vs1=?FYH~bHnI3apx0L;w6r+(i3R@=GEz>_G3>{{1wH)@Ykz_;K0w7ZkXSyiVL}O
zx`KFGy}U;cMQ9gMMR|;`(_NAOe$X->CEf~q;g6h~UBu$uN^>D<M|y1k6jQKT??8s&
zJvKGj=-L_yYsB#|sXM^nGD)k|Iw?vPG(^Trs^UVbH8)ZJBNlPOu4KHDS11hz2HySO
ze*rp9%YNAWy|%T6JIG1jG;7S0o(%)+H+Q=d*;g0AlsII<T$Mfw)lwIq3Ew0MdR8{m
z=vS@9p#}f>6EEZB`>02nfFe@@yJdcjzILIZpje*Tqe-`!){=QpeLqY{ll^|X_rdf2
z@nH1U2=5#$JmX4L+g8F2N#Ba7v}awyk&){{pK5Tau2dIeDaWj{`_UQJ^mn=q!`7q>
zZLA{|y6dp282=Q|sd8$*av4(RoaKLR_uN$06ii2-mc<YCdoJ<vLKf$t7MT}7USC%#
zepZS-7FwDIy^#mKvt+W3XHmwyo<*K8eNT1T$e`L-{J))i`{wJyFBu6pCq&#dP&NDT
z-`jZp3p-`&{W=l*vWoU@OzC#mH_4V|*}3mabgTPfAGaSBv9Kzgf68i`o434=v~7__
z@06#R>bopTC8Xnn|89xfmH+r#Rrb@c)2}pFrHP;KEe_7NN{lq{zjA?Z$~K(^uRm<6
z>Xu)AWy&V*eV+4r4b<nX30j+ZE#a-mZKdArho|o0>#;l;koWLPRN^TnN#KzU#DO^%
Y>}}o^1&6(ut_afL>FVdQ&MBb@0K?9s7XSbN

literal 0
HcmV?d00001

diff --git a/faq/logo.png b/faq/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..cb003c2d8437c087cb9b348c6fbf08a51e4d2e1e
GIT binary patch
literal 28790
zcmYIvbx<AM6YS;U4#C~s-QC^Y-QC>+1c#s(m*DOY+}+(B5?q4Y<NLi=^=eOT?Vo%0
z%=Aq6^hPNwN+H7G!T|sPL>XyuRR93&`0Lpb2I}j63tcx205}WCh>NIuub&%0dZTNt
z4BMi6(J`q05*A%X%f@8TY+9sFX;G&}|GEsDxY0|cU0_kjg};S%KtATfl8{J#|MNW4
z?#F4Lwgp-<$NKYl6_9&ZHJQWL(D>MOHHXimf6=q)+Fb=+xpca67@rUTXWP8)r7x6R
z*`E2|dJnR0NBJkqgPRTOjN|UmQsU_7bawv&R1M%45ZIZoP&Ybr|6N#<H@>7l_22q9
z0oBSDSH$<~&%qk+bearAIIW+~maCO+;>MLwc26;|C^~j&@<E9_oB7oy0N#Ui7ItlG
zj{jS=-gYYOw|J>4zgEkSyqay7Xzi6NUujgRR?1WkJc>^W)hdO=j6d`%kV6|3ul8<2
z)QPHf1#m}nrBAGoXZKCTs<p~D@d3Zv$=QL;=j~KA$JtPTynKj4b=NIKEjJD=zv4`-
zsm#>Gg5!EPXAZmWq7~~*e&~GN3y2)aJH#+$MOc*T)4jc$nxA*f*6fHbo9~8>juiIg
z4O?4V6Z<Yf#TSFw)uA1dY!D-`l$=H#o)@C3#5UXid;@qky$o}BJ#Ht!m~7zf35*Ud
zYYq-{Auaf8ADCiT$Y74d%fn2C$L>F$+eglb0K+AoQ^5Z={ZOc<2xP~zZ-D`Zrz2jE
zS8G*bq0E{CnVWy30=3bBpgv4)me-5#W<eV=x<~dv`YyxDfU<?Zz8yF?zK(X2dX;mN
zQgyXqM0eWYT>Pyc+(^660UFi1&4t{Kh7?>shKJud3;*r;nV@ku(`s1pM-pn*>Xa_*
zik8&I*-gfraHL}*s6I}O8LLB5AW=kYe+oe#8{uSV)X?<*cbJCOWS&vMa|=+3>||Lr
zh{hM;lXnq3WoTIvyF8J%-+LF=1Mg3l=;8rf;3EHseI(fMTF0hg{vi6kgX3zQ9BYO=
z)c1X-+T*EaIQjd$?041mn2o4gsrhL=`xh|dL(%Y$m0OXe_z~ujAmTNg7_BCjIA`X#
zeYxgc@PRKZ1_N2{nldf+<d2zhrN(j%*43CXe@}T6OkHt-H<&RyK1C{6c^-U*LGSs0
z(Zf{0Vr(x)sk_h9yKI}z3O==nqW=$uw7xCCX)2RLZr*F~_WBM^sf!TBd>)m&19TN;
zteuSsfU16A1tX8&2s!U)IWIrl4L?BW?N(BrcL|xz>Flhom*LkGI?wuXviT!~4~=?1
zFu)pt-;;SQ|3-I$#-eyI7-yF1TA<;#QBH-%-9Z5V_mlb|RS7}YLupstSFDlin&@|W
zjT_$73PQ&YiF^jgH$|wzR+XCkr^0h7p0L}9|Nr`JfBE_OVc$@=1)Bhk%P^Q;D9T$?
zJ&&rDbR<vu|5&kMs+KcXX#!XB0I}*rP({C=P#yEau0Ch+ME*iKSnb9OmlzCXR%djJ
zrEQ|WLYV(sv2H=pYc`)4q>q|1&0{y;tpvelRhGJu{6XxipLecO_kTxfO>g}}W&ysk
z7l`Vcb4kLWY+vuei<Eo7ubXJi&%ds{p2$I~VYHbWYt~e^DY>WHwqub3`P+6Wx|@E4
z2_oMTLEI?cT}(#GW*2CQ#oX})80+wkFfaqB-o8NKpzng0$JsIiz4{2Q0)A*zB#!kr
zY9g{aa*;ZN(W(Xkpf-O<gN%H>?Kd>*yB2i+t&m+Mm%&_j1R%qkBRAnAF(KEKeIE2`
zEf`@(6VDG-Qxu^8Y1r;3`pENl?RFbJF#LG71$V->0KzpV1(ylZc%91Xq=5+B984fY
zhACL#ocz#-g#%B{-hO@p)x&_>&X3;LTpw;MLoGS}K+^d7sOfh7cGqLWUG$b_2#Scy
zfr;pH%hK8<>N#o&725p4!bvZ%#;^1Fg0%}sP9~<>Z!mCNkN{kqBW%+sm^ML#*uPKh
zOcZCr*LHCmwJZl5AtgjS&U>%YZo3+!KxMYDX4J{4o(0<jn>XCtT!~3QJ9_A*Q`@`d
zFi@muO)&-vjd=e#O+0baxFvY?tXy;DwoI)QA<R|Bbp24n(W5@}^+0e0C&g)Ap#Dfk
zfkYpo(_3(F@ZXdIux<ak_Z2r{CH2Roz(RjWZLv@eQSJo7?aMT+9_76^r^qP8ApB(a
zM(DQ)RsFt?aF|}@ZT8n1Vp+PB9hDDpoYAVzV1ko-URjBh_;U&Y^kODiw3IhbLo>z{
zTWX^M1Tma2R+wUe@eXRA!(g19bg}1@88i0r8ETIUjc2pZPHIGzm%FZloArEj&nelj
z-23d&bA*U(*935k?ehV1jDe1H0Si;Y>jnLuTT=Zh^3{Z~0G>qq)hAq2q|;CaGH%s#
z_C{Zf&|4KXqRq(QW)d(W7Drdv0T!ghifwnINhi4SN|(H9Q!r7pvZb)mzA0QiO3H))
zQfrowE2-qnO>``Us~hf<u2^|rfrdReM@yC+bKc(f+}#%FHIoVNY)>fjziSZ3M%dp4
zSzl||f*wJk?|SuAt$0Bn2uHlKaDF~gAf8l%l6s3_y5M>EBfz*CVdOCK$;=|-tP6%=
z9@V%dVWcjrEI+?plsi9O@A>cv8|+d2TKiz#@4R&pI5stJM)z99f?qc-M1}l&^^Uad
zJO6`op+$&0iQV}>_XMc3%YQL|6>Py;<r&(w=^m-vA={onMbn}uP<Ah=KpxALAI!MJ
z4~t|h&TgdqaA@E$dV^A9kw%1XwqWwsraOLg7AH2sQgyurTtL5{ccjieW3&M$%RcYu
zq{{|LOG4xU4?Bz1#9>$5<41|{gzg11mp=PwF;4Tc^Nx^p-%l}0LwzXfZR7kl^FHsG
zqD`?ii3&#$%R001UzHbT>=_eb`Z(24&=oQ@7xrXeI(98-*tH0hv{#C%zv7Wfw-~I2
zvje@Gqfh~PfjDd1vKY<8fyTZ#>77cZ-uX(xOe5h=7~kZFU4DvrdEa?f6Cx`5CxaVf
zfcGSE%Tc=70$7fmU5Z&}K)zjzD~HzWj(z*6id?Cx%IE?!#18@(S*@{L8(>E|WJ|pH
zlDEMGcfptsnw;fzw{(RC#PXxFp4MCE%tYC;pqPw;_EENp5hZ8Lq@M)TlNx=C<U$($
zIK2)>`4FmhEi7m3Bf3blqk?9P+o*OvPMZ?(MuW`MHi}5@`JYZFV#YMVd~X*%om;!6
zHex1cU3TeWY7M|7Vn+45qs0b4ls*@TMVBp^Vz(n<Ua^oVWDeGHmT2uyGIVi6vG3Zr
z58Cd_hAwv<Tz1U`cSu>zW3f=!A>npUr}$2qf8Luz4jU8TkAA1jlv9zCNlL)vAH*7(
z$uGPRs`^Pe^JjcCVhj`|EL~QXRKGV!l(zRh6{qRLYS29Zb0szQ(KJe=2=wD|FJlZ8
z+w+-eKWS+r>E@zYt6=$XhyKQ&0@x(=r{Q8X0}o-TEF&V$Xsy(1b@ail<zz82U$Z=M
z!%onc_*F722stVeE5d`Y)7k{}rW(T#FqKK6Q%sa_uuNt=UEz?K)1B5((H@<8VOZsw
zQz$GT_x^1Zvud{u*K#T4_O`i7@Tsj9IpHoh)!~ZupeHl6DbupT-n73N{h!fPg$);8
zupg-T8-@9>$_=U2z~|$+-G2#RoR+*;2QkcEPFBV)aSaMaa70#oNKimh*X*U$3l%mF
zzzcL5Md65%^sikhQ(lx*Y5XxW^Dwu8yCRaGV-i#Hh&$z?s*u&6i+enpBo#AS!d9Lm
z<59CvoP3A(P%b&`V)-bbM9|d@yM1EJR20pN`}&Xcx<<R+R0NK0z=3L#9W@CT89921
zQI2K7+;8~m1G6W_FfaPijr^jLc*ttFuy<>#3+jCu=Dgf|ffA#Op_KjZL;?u0ZGv$n
ziMKH(^Ot->5Pkx{#*Big<;t?^l*2&W2+kkL24C%Du>m7kdey+)0-KRecfOPJ+S=Gq
zjplS#?Oc^Zo$yQh_kVqH7tq+AwoSQJ6490RRF<W`DpQfg9OK7SUy^V#K)Vt;ZW@ql
z=#lSIBsp6pgGS=f)roE2PShY+ZAGBG;)KvFWDo18uo0?vha_pUjAR?I30vXy2X=`s
zfXYzFdI#LL=@rhl<r2=3fzR~Q(^SZ#YdC-5ZyvZcLvDg%aYGmJXlONVh<!KS$$E*l
z<(vGNSWQ+KSHmnF%;^2SrKgeUz*7L#IofzHUc$*^qzuJn@zU~0023%qY|l8z$J+;X
z7vt5AJqR}!>~oq|*8vfJw{`6Y>OtTXN(vJ(b?LzqbXjPc1q_IT*=oa+5f5-pz_z7C
zF1(KnmD&Oq>{FC2ux_81+o_ap4{&25EQ%U>tZh8NuHTyfg568FS1zuh5WTgQ?@J4*
z=<yc6PdxP1^1hmb%9UI1G`hz$EFi##@N6`<VquHS$$CgQ8?5`(YPWPHWLOzm9Wg7|
zFL`<Q!Nsa9K3}KUjmi0p1?6{aHWZsy4Kz_61GB@e`Jef6w0eGsImzASLNxWWd3f4?
zZ{XvPAfN^GWC$zxiP+yAEYZItF>$Qks42L&$SL?O__9c!D^D*Ytkm}-s&9d?jw6CS
zOrfk{n8IrxL1M+1VUXH(0%t%&s?ahd!Owqcf1anfX7`en@>Rm1gkAcfa!~7<X(29R
z&*rFGrOw>7Tt0~gyB2M`V1=hdK;QDLH7aJtiZV4;+kY6~p?r7Qfw)W-CYH<BuhguL
z=GJtAOJ$7<17u2q7Dqkhd*$-0I4E^wxO}3>?3}1EupH`%Co0)^n<d<=v5ycwwMD!&
z99@;~)XQl%GTvZ2k?J4aRXl->luJ4iUE684O9&ZM>tOzIK6$9D@6?ljIb7w%d}4I?
zEodgFz$S}%D6_I#8dAJA5i-tb&UaE?gDh^|v(6Vi!n-<lREbL@<fK;6|9r6z+a`T>
z5Zb~`KP)!YiUbT?E8^q}c^`MO?<$OTChvU`s707^16JpZ>-q!heYfjMYJe}GM6~^*
zF`qru_NMPscxbM2cj73p?(d-lx9dLnB!~lzmz27~`STQJ6T=T7ob}y`Y?Lu<pKL`q
zDydRM6EtS~woPuQtqF^|AyqY*_>)YN*f^OUOBE=Tj{Ab#`MSVewsy=mi`$v+aJF1$
zd2h=d^udqM?~QU?qYWK4tQbKk^a0Fs|3DXf`$Gny3#JbI<zcHZERd+?kYz#4md<_a
zOxeqzRilr}ia{KFO5;8*PeGUvFucr(y-ha43bDzNtuZ+`zHrk@TH5#<qSInLWlRoM
zA7Msx%9Og9nm|nC+=bBNizJTb+IwEYszZQ-eHuj3o0}Tt$S!3xBp%hNxQ8wFR6%u*
zA~-Z*;0(F6m`n=NO#s}2_=1&&=v~v|E^1xq+1J|r@?)+1o+zR8O$WW!q9(s(RNg+*
zk3-?L()Im-V8*gia#vNT6@S)}OsnVOwPF3;ULvOD)|@^WuhXTAN3}l(GgxW?a*1F_
zAB5>AjLQ<6(##W0t?4T0ZzW4wQjB2jnZmGdK4d2IV+h%mRmIn_|BL!5IwHYmys=h^
z;(vxouft5VPC~tWYYTxPbb(l$w1i2}0UIrU9iocXD!S*ARWR!PlYw5)R4)luFMm~>
zh}!;Tx@6ZAH!OUZ@ujp?<vO5#?kwN`N=CU|1Rk63L20$gg>19U6R~C!K730{%=j_&
zweIheg!XX<Q3<^P_<O`BY>v<;Tqe6+eAV_fLfJ)~(cSx2**w`VReW|JU0|+){3=4P
znX;sh>Uo2q5GYzVBaAQMCb7a2H49^VP4~hZ9Gq)NFJ=cr#GoWtQjt|B@ihB3+Ap(w
zB<W&iZn;`dMHW(#K0CP&p~Pi%j3FIT`|uE@K>eXGkeZ}`e(_};P`upvPQ@2IlLLAZ
zrQ5izpL#%vRM@hZu~toG5(o9ciniSC_kYU}c=EUG0`|%q{y|<%3(_vYKMa?0TWR_)
zCHD0cRi);|<C1-(fY1;r);i3Ve#~I?C4Ex6Yaec9vjNP&bt9m(9Les_)73#~IaU-b
zF=a*$TMYH=UBu!Mp8@EF*1pZ672->qZxA_xuwC63u$Q^_`J|z~u$#5lzb=%$_c_5j
z!&PvZw%{>JuYyGnI6+`{nAAV=G~C{L-S!BnnK|z`kM@(nZo{wJ!V@iOH@&|7cE3ar
zgGP>!+Cz1wWygKkgoFOHBcU$X_gE?Rt9#dHreF7gkz~?`?1Dm!T)yBFdxt_q&5o;Z
zq5xErDHji+uo}K0=K2a=^#zJr#lCl24Ri=#VrdAu%HKmjJrl8U_^`(F#B{c-!Skgv
zD0?heSGZ<Qle1CgRxDX_Cawr*-8EF?Vzk&d|E4<H`hdaVIDrV7g8PwTIxEmy-=;zF
z3vPrevQhSd0d}~mjTFPr63r~v@g^WJWvFv1!G5+SJD*&AjpOOHy%xZnz84;sVE6k=
zk9kEds~k&<IzNVXJtj#lt6nuF2#Zm)Lh&?l&G-GB2)v$VQp*?3lbN;M)uxUT)^vSh
zrRK0NPr^vhrdb>xlB|s+9hHpw%c<Ldb)3@%3)b3ieBa*TydOyZtC)NsQ-iL+r3kq|
zwlQAWb(g=4-Hl5<rx_3I35RVuA$Y^@RmZw{A8^P9Ze%+8{ILmf@L&|tQi&Y(I1_eh
z*&+O!n6Py}HmB}(lHqB$lx4SMx&N)lO3Yf7Hal7|GI`F%nf{FiA0aBd%ZpH~_dc@j
zU_M|K#hqw5yBl!=*(kI}(<#hIGBz?k&npZHW}Y&VmBQ8$FJPYE!KrkX0@X0Qw)(o2
z*BGh-V!V<X3>ItF8;N>s!qA{tmgW3W;L?i>4Q=G$G!8W0)YQ}bGi`AcD@6S!#W{TO
zkNyyCEh5U_KKVOnzF=Fh5yX`wz;V52tQD}K0CVT@$gSw0i-Ap&2(MQ^HzeSI4lo(c
zEq~hP1H}5D2o??iQED=MiE-r|Nda38kWl?}IDKu7IlpHwlOJ|9dQjD0PPwSVdUb56
zD~nNo$bIm_3tn-d+bV7$giF<g7ed711lyVy44Mk*1Yi>mk_TIKxbFeIIc(vMIuJt(
z+l)xeM~_PE!@9ez3b5<7pq5%k>_dg#n0l+oR&L(e@)>@ZY2~z|O-D+IZKQ%i+L<r)
zeCIWlr|z+;bZM9uNOy}Ypp9L6S*U-QrF=TFd;9wK#Tx`VlMq61=S72YPl*Z#yt%NR
zcM^bSF$#quo)GoE<oi*3?d=q48J8##zrCEG|G9qFQf_q=DEh4j{B<GgT(}^i_D9VD
zLJ{I93cVo>)psago^a6|i?jHQeI-qqRt0e=*RDCT>JXVqSy1w3{1>p*Bz?NL#;}W>
z&<Zt9WTXIvR*%!#^JRU2b4Jw@ph2b?Fw^j_lN0<n)iZV_>(R#PfnY6lhHZep*f{ov
zGZ<vQu)^)xCan2Uh6G{hYPd1H);Hc(BK(E$S_p|Qt{Qva`L@tKlVKCX9Ts7*4Rdp6
zTg0sX@VTSY->xB|Sx$x18r`FvTJ-%GGl9clt=|hB&=PqB6Dv5H7akS5^hu<P-N7I@
zLkz@n3TaNuNCXfm8o)nW@4yP;81n`0SXlQ&2QS0)`;2&t_2gLX*@`2ih}KO3>^DEc
zW^AP8lp;ClkoQj%aPsv5tpSbC5bpYZ*tehM*&Jxs32@xd0hm=`tx^ssr~kZ!&cO2m
z)*%%m#NnASckL-lRgffqg&0}Wo(CpE@LdiLq}e6y2C$$n=XFHdzYx+3x#E;m-GviH
z#zv$$Y``nIx#BKZu;l8l25@9@92Upr)oKImegfpe3V11qO_Zl4&b0^GS8Cq7)0!xT
z#hGn#F=N<NjSkLGQKK!I<b<G`AkKZewu8;^(KUM1E5?^%i^*c70YB0j)fF1i%0}^C
z*f)N~Yyd2Q{i1Ng<5M1aMN?>5bzB@gAOcnHVM4rKd)aJLj^SqsAe$53;D-LR{uh0z
z6`qg@rmsNwdyg|MJ_FWpO}#9#U^%tdVH6YwqU$m_n7iwbKlOXy_22X&M}L1OqUMCd
zxygtFVY?L6XBDW-7@7Pl=^ABJnAWoFm9O%;7TWC^g0^qI3Q&X%=D0}4TD!r*OX$1A
zLoVQMv;-a-d1i+!Ho04O`}Y8hU%FSnGdS;hwy`t<fjlgBxJ7{6bQ2K({%<@m4a+Cd
z0+(@N(BerkrBmdT)Qo6X!NL#+2B=PhJ5s}G9tpE%8%6|nIpo=z9Oxz;t%8#OuJWgg
zDYR+kp8C2Q1rBd|EArmzs$a-&roYUGF5fQUsvvMc@|?Yd|1COvKh><tTHxoH4+6+p
z<93%aAN^+9(2(P%Ly6{GK~_&xKI>c5AN2~~!QgU)(jm9htYP#Dy9(Rz011$6MKpy9
zLKv7G9Gg)seejag+o*dp*rbhq08Qy6kN;>)n8Gm){aV;F$;st31)HS6bZU+z?Br%C
zMP(z`n%?^uY_EP)V<mxyM&g$u;5Qar<>6HuVs9DYAgn1yP|G`8Ag6`RbK#_o<Bi~H
z&<!1^bp?NQ5YU%kd~-RVY}sp1{eAbJynq8#=O`szfB;Hb%?6C4+apX%7VIDAp3pGN
zf&Su&T<}A8^Y$?rnOWalCCUyL5s0PJMo&>^b^d>w{@-rnSb%q4f>c9+$;gHn@|nHu
zkfH9TvK7XYl*W|J9QC%JStfNK`vy19?T`a*d0bX?N1T-j{b>Z<$}j0--T@nN8&nRF
zKZTS+9lLx7#zxf(##<mxlBq)qXl8oXproDJAFw$MVNmIPm&US~9R?VmOlGOA=c^#C
zcqUphv-&fUh>aaf=}mp3?Uw&4nwwiT?rln0aF&acKNu;lV*oASAF{H}hhcgdBxvMv
z7-92BoT5uh{5M&*w<&i!rT{m(n7tLW;FFwpPsR`9ihJ}XSlkb5nF~6Ej4VFUYBtM_
zg%4XJwnlNy*ye;q{EvM7BMzoTJG6%1-}+*A*1g-cyO{JISSoubH%6{S_nbVPC&&t5
zz160>FaJ}}J=s-^d#9>H`>dV(6MepMHn27jtyJy+y3g<7<v&*NTC#uB24@T+TU_Nx
zbKg>fg*yAbZ21Wt;x!A3O}%AT;DS|(U(qmIE?Q$B29YGcYpvR$3ZF3{1ka9Iv)Fx)
zh!EA*#uk^7>^q`M-@D!$m<{wH4y6ih!!iC@?R|0|=}bb8JFc_^<rII5Nvv>Ts*RA6
z(}{R{P>-31gt=2p%Iu}<CJt~5-1HLPg}ixhZJW_6>S6<{Q?5ODRZWgX=wYthl>2Pf
zSpB61wH47<G$PVRA~#io2jXk63^=(&364o`te*jA8|$t^UnMYw%>Gg+%PtioF8b>0
z{<>n@a|aPE=d>fjzs2_j!?G1vWId3AWIWGjad^h3DokmlVZ_GF0;P5X^2Ws*UNTp2
z&diNU21!#E@I(Z47QL5ksg%d0R6YDMm#WeL2{ZDtKj|yH++2{X#*fY&!6yIOb8Yw6
z&*iy5mb~GAh|9?H=4bCQmxpl1&w)mS#=>dgGAYn$`VMjrQ*w!P;L}<0Vk)FBtc3N4
z>Ng~~=cK>_jk4%un%z;Dy&CHUgscEXb{kWVRor<}g5A?Us}wRMZw_kK7MJuHUKtXU
znJSjL5PaW{P5?R%@}YBeCT4#=CIA@?%UGJZZD4v#+hGRjm!iFKk<Qm5^w~e;ML07U
z&&x!p9nvl^gss%x<tmO*D+{L51&kj-6W81Sa&Wd654Yq2vWBaRg++zC8-xP+Ymr2v
zX9;@3UC3FY$tDYXy<OCQuJ9lzs9s=N<acENa-0^Z;9(oCahot(oe42BN@@%FYYp$p
zKEp^bCXuYBlQ}DdAuDx8Z02)Gures13<N^Ax1kJ5<q|jA$diBfB?tLAM8xXbzZgGV
z4_LJQK9J5~10hTj$o3jdk`v4I>VnK?QvHy^Q$He!skeEViQtq{p)A>0>i^_;p&8#b
z!xSy7u65LTU+FwK%-dUU)yJ?Xl!D_Ap%1EzkX|FHl&d?UJBH7w(r|ILx~5PdBq)J;
z9#kCc{cGm0IlgyS#^uM#w-<)`uTkD#X?j-qa#bSp@Yu1`#Ww*gZFiX4><@j1QnbyO
zWC46;6wdOu$lovuVBR7d-k)K^t~rr%eh(|!O|&tKa|kM;Mcpxs5N<2AU2#C2g}r^S
zIK2*=_82|+3!rbOQ*M63M+r9dVvn7^a8HYL=UvUPEL(~<<^<H)$$D^TP54eoO!KD{
z$51NCS(=-V;#zM$kv)0#5;2?I5u(mFUeb>dTzB9gNhJ{^Th+I#E#Rb(C8+h8eGq~f
zs(R|EK5E*3GT7g31Hj)HVT8$0CWVf1+!U0Q!XV|+M8Y|ZMD8{7L{gCi3jWoy?J<~l
z5iH|JjKF@u+f^@gqZdgcE>7c0zi>ebQhaon?1ERX)mef?S>MP-2SPwg-q<h9tM6Ym
z@Nu<kWWS?VFJX|hZ}2B<{uw>ocLyz^UhU01!G%Jz-f3cKMTLo9mO{>S5VQ&#xno%!
z*WauA;R7BbE}RADB66NxGEI$JApROW=JhXU%~c(DBg;KP_wCx;#R955c!f(z!Q+WH
z8V!qhBJ*Zc`w&v7EGPM3TM3pb)Guh*V}f-=pjgnTJNr0-^{h@ztUMn%P9mmlz$S(6
zPF6ruik5g+oKOoyRT`lUF8CN&h1xT(wI}lCzRB+(9ZHrzu5iOe-zmY%s38+tQ*q7#
zglx4EpSt)|2J(B)X$NP1Mj}QHJV7&Ks{T*@%k}S{Y}=O=^hdTeX{nO5lCFP5N*c3W
zX{@5fEK@z+q2lsSYQv0=kA=1UBEWFKobQ&LS3Q`(;-!l9?pY}{F48vYl}*;C<!=UC
zg4@0GY_1(<oc2tmxz)3p<+z>yCM5~_|D?8@)LU^1euy+tHs){Gm)Xcifm<tuZ#3}Q
zt#M1tju=6V`nJ6aF>OvI_)I*X0rA|6QBc9ze1=-@d}-oN$^33Vz>?v<D?5B5^q_B?
zb!Q2-+H=VbUf?Yl$km^}Xe1~aVCeq@$L%upd&E0vhYe@i94FphEUiDqV`Hyh?JV}$
z+Z^}F3M^v^EOT*l!*MA1aVWB1$9}Av7@OT9{`zp)j^pq;^>WfyJ8i#wAt}<6n}UX=
zY^nc2p3|anK9#B2g5oay|C$JjvaX|t#u|hyLL1}}M1%EP9SxptU%$}Mx;lykdJ7|7
zs^gLZ4glkwL5rVO1vc4E1)!^U0`;_v0UMoR1_U_-FA-kfJ^Oa3oZwHYEUcWY>eg89
z(t;f`xfXNJkSQn~F%0L!b-LsalIgi!<W{52z9pNu?@CZdA58Q5ip8Qn9MV+rdX1D=
zdBKIgWZroZAKOGf;pb%o<I>N?Brg#?FfT)<(l2AKt|UjqE_ed_9~c^<?{kpsmaBst
zI~Nz#v3m}f4`<BtB#kAB^Fm{?;iJAfFmZR>bJ!_fW-C><WP%q>dVA7fNvQXkZ8n;`
zfE~Yt;emtSK9-DB6>VzaWFXBBw2(G|wH%q#rAn=AS($FyAgKR0GL>^UbcnOhIK3sT
zD`}xDEl@OakA(enjL@KR>|Jm4f)L{b-l`Sdsr;C0kpZ~M0yEML;)8!C%RiSF55$hb
zRxKtR?43Do?d}~=V|QGA<BwNjZ8*~7Dp=27Q}$>Pl3xviOv{Chs5wgz9kSVoQ`F!V
zET7l`H7JzjE%>C}x8DLJp$t)s8CK{!vL%lVY<@Gb-VnE85zH9pz!^F6=k|rdt5nR0
zz!z*FcahMrsFZCa=L&{@{|>?3$%XRool3M%K6j%HfYT0Vc_|2Yf>s62#^C<IKPkwp
z$7=10zTwIM)XZ!1X|h@1RA|DTV)sX)Hu8*S1AwwSs0Be4CMw0WK=X(B>Bow9D*gXA
z%#Wi`%Qd5w7p|{NgC(IJERl&xFxfQ<8n_k13V+WK_PI;_N-3@+FrK?#N&r&G$%$HV
z7>|Z;#+cg^W?Ul8#{|Y(r>Qu*vi3gna89E_rg6$N3*LhfS0m)TYl+riyF`pzk(2&(
zz!EO&6Ug4?A5=I1yu1|PZQYwceA}}!w;Kren{9^ITgj-XrgYsu21%uBAuf@GD7QTu
zfBdhpF(joz229VxC8FV!o)`<nML$}rC0sqNpd|slAU4E_19wo;xd-vr2lzwKYG%@x
zoBV!zJgTBwG}k2VY#2w3y9Wp^F~u6=-bPCicxp!ut>>$(rgNoM&(*p~*aKSrkErj(
z+54!M5#mg;4BWAl+3?13)<|7}DV<#L(=INV%RO}eQy!eu1vgJVM@)t~ZssaX8gj%6
zt{~@$gvojF;PszxhaVgo{sFq3D`K8a&_{qA7LeN&aTz13<tCoD{%OF&%YyTzB!zYJ
zO$%4^bQBz94xl8b0M~5BY(P2f@tZNhUZsvR*G(m+*zVapBTl_VgXrGh(7<;--{94k
zyhWBuE(+XxbR;!eCC=T}ZnBKu*NnOGtOzp3!0es0ZPW03Q%1K(gaH9h6JTU=i6`tp
zOA3hjmM47s-jmRI7gcJt-&G82+Ic(}M#<DGErz9hazj)o=X}bB4rs(hDGjMa8<3O#
z8>@c)q*$raY5YaKQ@Svu+hCrl-b_e15`-r-;5GGkBWm#Hn2xoc^Lb;2PPvRBFk`0f
zPHX6IcXY^F3h&*@5FQD~TG_B*;2vBGZu2*tiWxT>rpoE-@ZwS@G1GB26biiS7kDoc
zenwRMCBh*AjMQ>j`Bhrc@(*5T$ms}4F;UryIl-KtK(*4D;D)V8;i$dO=-Y&}e0#W0
zU#DA5n9ldFB9{&}IhYMTF#q$NP-F{#7(FYzY(IH@qVn5XNHgwK4{uyVgD=JI-7S0a
zpZh3#HY5p7f7m{6ta0-59gW(RN&%Eu84CrMv6P|8ujq1m$NC_DLTh1p9QWk-FBaTn
z$r9|MNt!L?mhtF5#LG7~OWs-RWb*DsyvSe@TlEvrAEbGNIc4(EnaTFH&@y2-EMI9D
zi>beTC-!#e#(j~;c>hN;$?vK_em4qZU^+HqYXRryi;|T;nr81*gqofW8xg`6w%dCl
zm6(`Ki$5ftN*EHHla>j$(PAHJYY>DP1FZ&<snjUF_P6`&!kZSS+~{<Im<&;bu>2X2
z1o%K!W2L20`LJ_^A`hliE-pkH_3s%uF>j;REL@5&#J2E{@Fjx@3Xg5W0Apb>J)L<~
zCswkfwH2A!4*J^@D&)cz&vdz$$@4!88BScq$KgWxQkb)7T+_d{;jz?CmxQ*C75mS#
zUm(Qg>`spfXt1@F2m+mN85H)Dl!<c;DKgBaebjXF8(?0mYqX4vNNG&Z(59qhCVgYZ
z1(>D%-_V8RrwvQE_gAER#NLB|64Phw&|z$GSnupS;J=bp7mOd{l)2HqLH@O|aXueK
zy*|H1L?>)trzFN=nUGxeJu=~@bD5F;)6I*P0Zs-8I!o!|nfz&<(W_Ifxgr{TUsy+}
zDx=oP0(;WQs8nk>8LMMp5dH0Y-EZELpc~|Yn?c)&ea!zwa^5Rbmg=Ia?rJOdXP;aG
zVC>-dSTg){McZOb*P%(X2vj`;LZ{jvr;9h(k}Ob?U0hxk_qLEKmRko2>3He0Fr%$5
zgF5KQbflc6shh4|c&hXobq@!(U7x}Hn{TkcSS~Pd)fX;Mq-2u_bbi$_16!awRlnB6
zumNQqjADLN8G6}U4lSwN?fJ~w^wvOyPS}P5r?B~=|6y-u`$E*3hk-L^4|GdG&3Mm-
zo!k?yU3t42!Q`;fawd5M8J5BeOUmC2tMFDoAPF+@DM#S2XY!hVBjJ=MmWLOz9BMbb
z5wd2S-pZD%U>*u`-XFWDI&*z^`r5hTn-dDm$|3KGnu?_>rl73FtLvog;jYE3tsWV+
zQG@wduB6i%ah&8GMLB^BCu7H<v9i%;;;(<fkv2NHyWl7pO5=dL;ND7*ExsJ9EX472
zj3@CQ9Ea9dM=9YWqtgD;E#KZZ9=BbSQE+KCw{g-s`ADn<#>kQW9xEp?=fmV!lo}*~
zpznq6R#xa0b())`jRu=|l!S;8@GdQ1l|034KZ62G-9)(Mc(zwc8PtoR;}qn2$f`6j
z-rlevp<q${05;Bku9cM>dgw3lnc?G|s-MDUv~(n7LGUqvxp(2y@O%=a7jo!<UIsGI
zVnOF>Ji8Tt4qou<9=gwWvvl$2-BC^HPaY{f)q-MtQ|WczX>e2EkND~LXo)$(g)y6$
zob4I^nmMT5Zh^_;v`*u6edEfv+dejSu;%u*^6WKz^!@YXZ2INOS+YlnTY(|foM7ay
zS(i#p;hUI+j#1fZW;En31g|Q$Hz<VFZ$-5@KdAhYp`4H==q4|Qvl|a3(^I63z41so
zg_Koe4G6mXVFEuBS?{17a)1TAONikj*~isk!pQI@5a~KcKFE(42IK|3&}8!m;{Qxe
zCLy6vKrhRmrEYjt{WxQ%D*Tu8hugc~K3lX+I$U7M3ORN?2qSO<17gRK2bPFo4f?3m
zzSXyS_}oOW?$j0nLZBXTa&79Z*jfZ5O|jy3G^aqh$Tl3#v1C4B#>d!>9XU~gNCGMV
zt#yRVE%5u*$UK{P#nqQkN;Bd?rKlq#Gf(8~_?IfX=UEUdKmWpj8}jH(hZ{3B9^p_F
zsbw(l&LQ0y;5Rj6K~pa1hH?VO)l<`<Z}no7!lXib2azR5l89R7C9V_an(KPw>`_If
zA9aRw@@hCr!LoBSw!IydJZ%HHgIDf{HJWT&L%&%&Ozoy@xr$<{oNNtddeUZ8FxkRN
zsIhKKU7yEC<W@4s1DbGG+*r@SlCntoNaKuGf}fkCZbZk=n!aJG=~DPaCcvWc83=)&
z4Ac+PzwBu=l*!bM`TTVMaPsf(%}o&bU@+`8JY1}QHX6)M$vR!N<;aXntFSW_J~XIY
z_#0R(XpTniK@RquTh~McPBzaLO>8bj-Fjz(M=WN;6L2*mwgl?Pr8}|4$dK|I2$ncQ
z$%u>fdCI*b<)8{zNxk4gvt4w8i#uD19E!mdQ8y=t5QvSqd1V^#5-b(JJe}BMQM8!)
zn@w^~!w5&cCN1sX08^Cd^AGCZsypzMVVew2AHAib<ZFQK_O_?&{c{Pu<hZ@zT{L?t
zV}XR2{eJHFOi6Hdv4Ueqb->hgvhbVw#kx9;tl6w>$L_u(t0Q0Og6*T9x3{}DMs}z7
z{;4d|o99RNiT06({@=lYpeHm>{307pEIi#@`T2A1V+PHGb{QL}j8u-}sCmXC)bwEg
z9l~B?$`AED7V0CTG5XEM5V(=gv1ykT+1Mp5(;lR?3`bQT63*1Ctt_23qN`g`Iy#12
z_~h6<Q@UEKyP(X-iDFs@hI8x=$h@nO!Dtmuw^VMTX)2?ipU5hT$Wgy;V{>&cB1f$m
zwc*1=Z<h8wO~>%NRf8Yk{UM$`!%HCQb6E65kz~~o|2BOmTUg6*w{Cx-K73u!<Ln#V
zAY1NB45vc{i@TeB)KiSg94ql(r;vPuziNH{wke=K+jzp|{P2%vFRJU)lUtt8U4h%2
z2RU_tgq{_O)1VW20LT~}ip61d6<UZE+u||~B^hrMKC<Td_Okejo*e@zGg3Q%I(<Ki
z$$2alT!mBP^;z#E6{m~AfZ8a}GA>u)=dH{^rP7_$pMSk(CuJdW^Ze3cIus3QL`sci
zN|{VB0<4%<H{83~wo0pLLL7^bZ6RpfqnCP4`mJaB^L#k9ykXrMOnD&Q?$l&t^`D=w
z<zDx_7PlZn&Fvb?C0tZ}VAARp8uXN)dbJ%txV$1?$a5}ud{Fwtk8V)hr!7W`GhaN<
zaD09F>?BfPt;z9bW=zK{(4W>RYh<0`<nRv_vi28-BVs^}{`$>{N%ccCf(@fp%_SO+
zJ1LEg3A66(V?pzSgr@wXzy=BII3PilA|&FxoD6yETRsK!<g;W|gb3T`7~uGet3;WT
zQc%7Kul2Nu#`U}xY>k66yKb{;cezsNxBKH5s>{hql=xiIB0TU>{mfF&Yypo}U`_-1
zV-8!8xr}?8SycQjy@b8*UVLAF9ewWY#QG%sBAGemXMfuj7>zicb|PbXq43kQ7Y>;v
z4L4xsmkcFY;Gm8uke+O6Y43-pf#B<z7<wd?+k}>PzhT@fSL^r!?N5LMn9S*Q2bss~
zJb^}3KsE*Dytl~UwZ(_JDWMa1C`&cGJjB<aS9*OrMaYAn<&m_=h^*kpS(YDIAtm2_
zRTT!A*3yV234r*`lFH==VA+QJRf|)idE<_MY8Jn&qif0TG4aszTfK{^eQpy$#;e5$
zrg#F1#Bn#ShWq?r%#SHhs=?d>A&$F~EiK9#Hfjaw8yo`aZ?Go?0>P0;*}4fZkX^>g
zMN{QlEMysP*(or7{!|k$Ou(8eOCev&UdipD;~%smcH^|5XoQ;mHC!v`$F*GxkrgE&
zPq;Si`Sz_BKM4s<(>`8v$up>ee5*wJ&4yj+8kAY|c>UDd4<?_27?31Evl?~i1pS^p
zaL#>6&o>fiU7G{K!jB|yHjs0ORjTNgL&6UFm7{2Ma)BSDhIzjFexc9a^*{t}Y3$*g
znhr5(KK05HgA|c`&X4*0BSnMR(WEBJk#?=Z6cKz0rl&WMBHTyMP1C36Z1kBLYpHh0
zrg{7L!CW!n3EgN##S})>fGmdQ>iGDf<p|K`?!Caoe&p<#)6L2gT!8PFO^Guhe|nCD
zrx^V*uG*__e5m_}1wW`q-E8yv1TS7x#(ZMQ>Jr$>6PW+yee}S*2$7U~Ahi>q2E3MD
zl$t!nA29p9Yp&MYaSaOi?4vVNZn(PI{`RK0_u+*vZ>yCW?)w#{)%P`}Clj*_<}|?5
zC_FtzBcDi1=pr7ey+0uou57swsl2VL{8a?7&beglCX%h6Vj38pjJ<+y>7%J%ps4?~
zu8gYLXvX5K9U8Ls(%qi3^4KLhoId#zZU&kvk>ODc?*LiNdq@7Dbj|pH<D!l7Hc_eW
zZrgzB%J;vBn?3y`W(E&aOiBk#_8w@AhoT*jz}B_iBXDXx^^og5A+QbOPfok}dcN3C
zZM?AV@(sU9R@hZXjzmJm9XEw&tUzTld+?6i;a6!@LaV*8vRFVIe{12lY=s_4?T-@T
zCuZL=K@%u9Ku*ljp|rQX371knt*s_iOZV_#Vm)Tro(=4U`LaE{{CI0Ps2aW0_@Z6E
zNFiL+zx`C-G!Noj&kx970vfIQowNTUr{e4DjD0+_#Gd5!B+!J|g4&Vu+8bRm<_@}t
z((iFWyWHuZ%bpW8J1|-PvYHsxNtLxr$jGL+Cbte`o+Y7>_odl@xiN2!+1i^Q@LiGj
zKK3Ajn@>ETmr0MDFcOA<IzJASzwtM()A7bx{*Wvxk7fvp$3kD2G#ueF4{RX!Bwp{O
zyC0kEt*IZWw_(+;QD2IEuaH|ERlH-VuJ}A}Yw6@4lWvyQynCM_9NowOlgeCM_tJ4&
zHsK5ui$G0s@P)R6K6d#trlA>-g~>&C(d6;a!U9$*%?%;YY(eIQ!mO56d-&)@$}D7V
z^_z~q)u+B}P{uJcTPzJ|9Dj6RXnF6{HV7Q=jBB~`D({WgYRQIm@VSUr=Ke75_PWYn
zv_w9S?sTB|RJy(E_bm_;?Mr+=UOKzaBL(a%;H}lWH2k{8sOD5Q=<wuA4#NspI7<A%
zvW1(iKE*`NF*F0Vy$Z^XGT#R&#XN1QTQ|RyDd@3*VV75z+ON`_w=c%;1R)4H3LvIh
zJz1LOm+(%iJGC$GbeN16RH7th(68D@C!3bkgpY_$1R?*3R+SiW2xT2e7i$JvC~&M5
znSGdW%73iw=_d>l`Vm!vQlp*pc1QqWE?XnI9=b4R^Hb54v|hT*O=RuU1TI$ZH%rlA
zDQStlfAJvuCozoDFV`gAW?#r~l|43}ELpx&_unB;2%3dfOCZ1$-4!gW5JvT+r)!&(
zB7BJgXK6h?P`o15(i6X<agc>dT0S_?vrJxtUuWHxz5N|vIri--SAG8qnMF9r#Ow|E
z`D4|V#6PE2kGpU#;5AN!eV&j3u;ZoIE7{X04ZFO!GS=&F1pDen%8YyvZi&%CV8`8W
z90rjH(#_uNmjGjSIysoX*;+HPEdYLktD>GXFLc|>4REAm1-7t*%VH`Puc<d=H?!?z
zme-CgZ=zXnH(DS|1-pu5BLoePG4X<@c<|EJK4M#_T&y=YpSu_+MuAUXCYmEE&fCO)
z)qvHMl+3inHu&jC5t(rxhrUdj;nwlkoKeXu{?ZlF=9`k3$8dsH<A~_hQBfhiAatai
zIFyHDsT-xCSG=TY6$`bFn<rTRw<{5q+oW4ltjs!vlmL1`XTg-uCN67T_h1t;se#lO
zEMgK8Ld=}skh<nGF-#Hg)gg=T1+OPp;>t+g8AvhUGrdv@daKp_%QnqcU%zTqCPn=+
z?D8$f+rK+5*3{~^LM9RjKt5-~2nj4yEPnaU&N&UVVjd>k`Dx;RXknlj;)W4o1I8CG
zps=5TF4V=u*TO0|T*{iTOAmUd`FDm_mn0nms$A^CV`Tf_J5J8+w<9h2W`2;-XaCp;
zDZ1^+diSC8q=)Ps)%%tc_f8E_mjJAN_E3!xgzW7cmK5&=z#=9_*>r5&bi}4&SAz3d
zuSL@<zwFqI&aCkUmi#DAxA1r{w_Mz65P;PvS1rZ{-aw$f4CcqyDusuo>%NnP-o8SN
zbF2K6Dkt^G-U%~DhOmkRZ@ivHO4hW(TQkLNG72J9Q-Mz|S`1B|UmpuXZIV-Fv_-!N
z1!VZ`mjDjv_E_q!4;8FCZc*H~oYm3Ooz;sZz%&wBsrI-~v-PUE$@>fC>ARVM?BQ-0
zc-_G5=Ql0u`DZ%qc2f#*DZvOd6Qy12U;hfjFE<3KFl&gFOGqgQeg{IHt~Xy)Hh$IL
zoJ&{%H%CWD%GoI!%64lN?ViAQFMbYO0$4r*Uhs^bq~|edjFY492ggauEK&`buS8LI
zwx*G?NaX4rhz&jjK{ByKW(ixX@n*{@%2Ss|L(3YlGgm-GC`(yMwLcVKZcLy9q@Q5Y
zrX&&efID3~cp_#>3?BN%A7}a3Ts~qzZ!{cXELrQG^P60%scE3#V=}#zHuxO(M()aG
zZmxxksD2d}kB<rzQx2nM?VP<N)YhQ7axZ#TRnxO1Mfb@gF~{6h!2u3ieb)giKpdxb
zdFw}L^k}>S;kr53^5hz95~~GnUP*~)#}afB1yPuTmZ<SvG4%BmWs%fBJu}We=qF!Z
za@GOL?99we2V=@aBe%=kvRC}n40>B3wGK24Dq9vT!joj3AwiQ$)chbLh}88U@B_;?
z#B_-l1)G-hNqeJ@Cq1VQ9K@XmqR{+vM<Qyxfveyg#4r!r`w>^19&!J!(i6RS#jP>g
zjSJS~A$ckWnC+9L4h=eJCBd*pyX52>{bC8JaC^hZ#r=?)qC<E?`S*beM<Kion^c1l
zkzV>E^Tits$m7mV?<89_0>sJAD`n8ZN7*$O4O0PX`#5fD9z{GG4gAcepRqjE*-*@}
zy%o)*gwAi6;QN%;41!K)*Ukji;s1>0jfe9(Q3P8)OeH^pq+OXU0$tewC>tA}(wQ7t
zy*|CUm6K^)0~@3KdT(8jxx-_X`CUw#A%=of;Z~eJf@-SBvYR*4DGo4;k9j!bg#5uB
zUYE2lT7oAWDKGLMMHB4+&upmH9<PHloa>Go6j3uY5=I)xFY8q_IhpwhqkTap(|3S@
zc@<aeMu4ulP_o&?YtCRAY)Zh@pjc1+g0R@B-Rt>y3fU_m97y3C;xPX@mWzor+7Z0c
z$k-&Uyku92=X^b%v^VmrYo4Yt-`p4@MKU;cBmbJM$r|Dvz-(QS#+dPP_f;~#LtQbB
ze&EoL50HUIfvMS0pvDBB;S<ZqiVAb+{nUaM++H-<j;!*O<(`%i81Rf!&UEt$r+iwp
zSCs}0l4Qt6f3ze=ocp`)%(_{rQNEsax=pIan5{v{`bpjy0jLYuF>^-ZgI7Q$5mHrD
zR4;vY7H4HQ@(`~(0;08uREMzb4j;wL2ZIs;TUd?}TqD>5jS5J{hwuE)vup~hMN$dI
ztJkQ`@56EO1&XMwv74(*h)7#Vk<1m1*^Z`DH@of3fNlIEL<%a$@Z(RyV4BF<zG5jB
zXR>`*cSA3TXqaRBG<gUtyu2zQ*pb3(!@*w@5z>&~c}HsGQwJiZbm<r8c;nWsk?Kjm
zYD{5&isS-DYf$x)?aKZcnLlGPg6+Ldj^fF4VIPP<?H6z<f%^<O_CPU(`x3iRW;RVB
zQ8Vhwd;t?H&wxWfn(CQY(r}>fk%0(2l7Yj*>~ck8zf&{p_B(D%@G}dOuPOz8c~dPl
zbNa3XnlwGHEiYI`)<pIzb$HL1dlXAa#xvu0xmA!{7rHp*JrOHvj$)-ie|;ehw@8HT
z(&=A9LPA_sgRh>!ugkLXd0XMx?8;2~(G7^5VLw%hUUz)YRk$1W#j1#bZevCz{iAbc
z#FVtOYWHOb25Ppn=j+Yz+h=#_&TXvq4#3{aEJYY7x_^c@H_Wb^-qu{k==?q}lk8&K
zTXKrfLT(NU@=$jTQz@^RKhtKl7Es-LR-F-Q1mdTZ4PNyF0mW1f7^hxv3x%`Q6>MJp
zwR|)Ep~+kYAN#^d`oCbTo^CVn0D4!$vY3_3tqgpGDK~*z3c*5HwUGMfV2tM|&fz@d
zU=&c{*|26wkW_V&$2^Ig*6d2<=;UjuHY`8vI~WA>1Py%y$h(E4II@h)@!9+!<(h94
zc^w@+sT+$4-@m`A@E_s8df1pjj+|Ea#&CIY)>t&*D+hy5@HYhTNSgLD*c`_>+8z0;
zmFMUHGi+3!qs83pL%&xuXQsnW@=xo6T)JI>%&jSYm>AiQS>F_s7Js|;wECDhoVD6L
z^oxKfxga(rxn&Gll|cesA5kzOeKM$2J<*m(hDavVACLQ+Z-nGh7Nwg-+4z*m4mi$~
zOh-7SmtxQ5-OARBzGZWTWU+5%)cW1tu!TiMBwy<FH?+9VrH;P7*@o8{W$Pzd)JA(*
zmo@vpfo)i5PUamnG<ClBxYQfX$Zsuo_LL}&jko#6?fY88<?hExXDEc9lSD_7=J-_t
zUP|_4Gmf}<y`DzbWJw0}h$`9rdAAnK9%gB^okd)*SI$XnSv{5PTUeO--qdH|3a*2&
zkaW@kU1yH`vAT6|&LUL8ATTa;oa-;+e8E$<5J-|5nbXD^#rcX=o5~`%i6vwTHC6V=
za(-5M9@l(A;08w^a%1Lf>9hph>@zgjCo1;+8jXsewG#p@p4AF;?rmC$sNr0dMr=^G
zj})e@S&8VOh61IAim#>cM=r|jg2jg0TzgNg*wYdR?+%L<7q%h1>oFSWCIoUR;Reg-
z`N?DH1bOnF3xQTL)>WZnM3X$SiUl`rP9^y;_l@eeaRKGx-^(-gigI4dF__7##d0;O
zo-nG+><+P?=~n^SNP&vcS;b91)wQ&LGJJE3hs5@H!b}0}!&AJ@MCf`5eNWJ9`A!lR
z6uH)DIS_Gw2DzJy$P0b+svzar#X)v|1l{O45W;8ADZ0xaa7u3d`!QU!h^x1RjzrP`
zhxFnwOiSYYU#6Sapx0v|TH@S`Snrh8u`Dgo-)3gOCF$r0zXH^fzL2-uqGVYtamSy3
z3_m2Dd(beDU!K80{NoBIraxWPTKd|G`l5xOzZV^(No2d?K5fT`?KP%{mi7&%@Dx*q
zGW#elut~rRnD!y!ank?dj1b@$v~ofL{!{dYy77rUsN)CzEk2KPsM#z3zHxjS%h4^=
zoMtiIH$z`P2hO@(PD@455%(SLUo217fikI{Ln(efD|N)E{10gE2X-aQnjr&9#msff
zmXj0L-mYZbGWjOw^9|ZLuYB-eP&TMShS}Sg=}&eoF*8@H+y4o=FGbM5aU?La-FLdo
zLb#KH^KK<E#zl+&j+C~@*AWg}iW)HuWFMbU5qg|Bslv}roJhM+j%!l}FH&(k<Jf`s
z!4MFZ_IQtzShL9y?4%59rt*hpV$xwi;8iF!We1cPI3KFC`4Vc?`w(gx>O!4{jp4%i
zAV|W;pzZ1-g0U7tFeJ6|&)ZKUpvDN5G=(L7F>oa0AG{1I&)fwMViLrYLyY$wQ6G6T
z?7m^F39#ziUC1+X1B~1MOsjP|G)g#;joWuwu;%Zmsufj>LRMZ38G1k8vk)4W2<y(@
z6?SGzXD@O@Bj)`3-s^BCHeJ@PO!sBKBa2lKD2JxP*6YzQaN;asBi5=_mNw(#WES!C
z^n5OVy2<g7wh;@)eWs&aM1ZC`%_;cZU!1(gyye8_w2M})-bq!a^pz_Ya3V0j%`vZ1
zOtPGljy+0g94LE%#!J|lODRyBuUFusc$j0c-^#)QXP<)cw=#&ok&XLC`LRz)Ozd4P
z`j3=2pY@=upn()H&tSljy1!?v#c00*z+7F%zhXaFDK3!>U@jq}_E)qJmT~G^XTJCY
zV~JB+p<(x&_5aS)D4fJor|X21UkFZomymS~tc8sLnOIGY8a47c`y6mWpSCX&Qv98m
zZR&8iyqESFu1)+~;58^Sb%$V{C59}4(u3wf`OZJXpQA=YT52lzUJHfNfB6VIFEQEf
z-X|a`F-dG&uzV$y=raxSj@trV)*Th`$M<6spz)HuqMmap1abmjasunL_AtDTz}#fn
zK2ZRJ+QB>F@aAZ5s6KP2C{D2&0XQ$`^``S7yK<Wq2jRqnNci68BorL`%+ZUIrIg3>
z9)9qKSY*h7GTjd<?dVXZ9Fhtf&xb&-fx{7y)u2PM;?R|j;5<)TqlOYkirkcH6ZiX_
z(!i3M8^L#s6>!cW!uB+pNw}?Fb{rFB{@}$xIujD9VDmZQxUWlu@=*KLqJI&#iCXnv
z1RMFQt*EmT6@VutOrTPVg}}bL$X|hU_AgVr!XC8+A!|hoYH^IWt(a*yi~h|dym!fy
zvq(09d5M_@Bt^oW+3^(wW&+p<iE++bi^Wz7%q+P$?2n$|2{M5!=WTg{n;rW#nNY8x
z7X1r??R2r}j)+5+2IX?)-oi<*D^7YBQ0C)=ruXpjdY70osTiHbk}cbg`w8W6Vm}oa
z?i@!jk=O#qrQ{m&;A{l6KMvf03JAJ|Cip<1Njsp(h*eO()0Yr@<Awm+?|n`QW=r<m
z^%soK+pU{7K>y1aD1ZP;@yyeYT!W{nX)wg^JhEP+in;7x+YqP|;c|E^RG7M5FyS(P
zZH1tR#<`y2qKP3>|33mQ2#@P`r|uA$#!Rf3wrl76!=wXO1c1{5ftd39Gj_tChl54c
zC?%kLG&0>WUf7{VFL=L@Bv^LvB7E`P&mwt<RH{u%R)f#pSbNwl`8nXe!*p8hSp@yj
z_?#BC1YfEwg?+xjv428VUM7dagg16f@)dcNZmS)4gzDAGamz_eh%|}UwX)9+iSztT
zA=BI_V{0}C`#G$lRhss*ASZlK5<&QcJ<`kD>vRUvS<J3kPVDTN`&hz*Ta`^<Ud??d
zZuX>%w&3+w446yuLJTAv<Vt1%m?<v+#pqXNN4<6&Tb?4L#-6CqzI<Qe_iS!OTO{S=
zHr$zbm<K1Xwq)<qsZ`Bqk|UOk47#i%Jg)6+0S^-!?|GDdpE5%^)82eMDqR+w3DnM#
zL)hv2;5IkF=;1tJ8<hC|Pna=huJG2r8Xf~RX6}Oei}wm!Fxj6+&0YirhAf4G<F`VI
ziCf|D-N&%wYKW-eOrT8QT4|cENZU!E{T4D~V!BiuV;VbzEk7G9fS3ALp1uQ4Av12e
zY`<6pn5(SGR{b6VcFn(ci7{0317Y5|P~m;81eA|QrHT8o+d-;p-#brW>N;O&-ny-#
z<RR?TMdd-q+MAurlj7^O+EKXguWWOEjz#HJDmSf4^*L2RlS@RB1@GQ?i9hW@C#kX9
zN&py5I%TZv^M}NFZd0g|b>qoaY4|;bBsBqrwQ@Ob^Z_VufvjqL!;X75TZ*aKSdi?O
z*r$&pfSLOZkXZN-o7cZ$z+6m5wM^h!HVeR<z|S$sLxq}}FiUNRjdN}x@%)C_SV#<z
zu`@d-4?n5>5SUxw#6?aw1?e-r&+&pP^H^)U?<ap95SIQpAT-Ts;2bEN!O~?twaFpu
ze4H_qs@3XaP!gGLK?Fy`Ps8EfU8D2X;?uWa-U*||<HEUfP^0f8k<f!`9;@d0!?F7j
zpqn2c?9rxL$i#HX3%l`>eHleGNLAf_&0(XL_R;HHrHa1a3<GzcgWq=tWsLDGeW;Ov
zlbyNk+T*b0c8qZJIxXYqMb}NvaE@^HGMOGWUI>BTCd`C7UUfj@QCn$x&16r5fl7p?
zBEZf?fGub5vu9ANRk)yRY|Gq2&$V8!Z-jlQW^5h@0i>G@Fb6mZn5Re_bGJ31Vn>}c
z2{13B@YwCRzfy31$ezba!MVGH$E+=Na%+&OXk@0wJf+kGV78xBjqNpZiyAwC`5hSs
zI@7}b`Lcnz2s=yJY9ZF*<iYV}AD?o_osz}npHlx<YZ@5*?js4d9t;ZeX4~C3?lWht
zTD1z3bJxqLXKStbha~^9CoDZ&ID<J0oFB5MwhTC%;+zkLC&Qq?YfycTKNK9c0>-Y`
z1W75WA{&<oVM<Mbp|ci3{-OVh5Gn%EF6$0Mw@oL6O8QwX<V_-6YS;CL#sV6wo-V{p
zI^;<LjM;lR1DFeqMb?bpj|{vBMJGI~WJRyVZ~@>x*H74!DM?C@0`F@hD5t~T?505t
zHO43V-id?xJC8z_ufG+5oXN>cI+Ird%08W1O<CoRAvlNXHJS|`9v&aqn?;WL(}Ggs
z`OQVZOloj^|N4IsnAyG@kcAKxDbH%V@?G=9eqEtW*u?g}utTlggPqcp=C38D^Rb+V
zEPIXHvM;CDvKQj_U(5Ir6mbMFn>i+>OEA#)UNK<4BopdY&dI=>$R?Ho3eGn-*v^k_
zGyI7(P+&VlTZ&Wd%%rj|SFYS!IbN|w%-R28`hz`Tkmm11a6YCGoXIK7l!&C`hEq^$
z(gxUjIatILQwx6>3hIH=gbLdPv|bDLKuOA1J?<IHC3W<d8;%LjYLi1(hH4twwD+Y4
zFmP8;1~8k(`e@lcs4~M>0Cmv`K2QnYck?*|n}dxk+2ph)2g;<rrt8igAfr4;f(=3U
z1xs$wsIgteD7ZpYK+T#ps}oo<Xtp+JG&2#L*AN5F;xj2}cWh|X43*CA0+bzzq=0$9
z6M*?$W}&w1Y@H<lT}ma}&(8DkWKZgNg%c=EYz;tpwk%>PClsnNP0YnZX3WkKS_7L|
z(AfJpPGV7`aUd{z$T$@CeT9IzI7nyz3by9)??7NCUxQWTt*!8U%S+goZ5F^_2Q;bw
z&LC%EV9p$`Xxnu+sa@cswDWr+(v$p6fZ%YocB-*Nqylg@vFGDasWACiFbvvx1|Gyd
z7616i=oo0VXqO0|%Bb=*?)f^;#H2f}Jq+%1`~=9FZzG`odE05|K`h%W&1a!;o1pYx
zTZKKDoVz-&KLJZFh6$CmT<+^kj$V(`#r5va4j|+EZP%k=`i9-m;qz{aSh8iBO;1V|
zqS5T|^z^JudDcx1h6I=h${Lh@xV;I-BRll@<ODi-vokI`r^HG8VUIcin43u)FP>R^
zK`T-~CVqFVy|yw|z0PIlC?!r|l&P$!9ph6y-hUaWl&H>qq`Y!v!ekEdJ+gN1iptnh
zdpQu82?RDt^d|?g{M>ixO9tjLG5~wY+VAZ^U|wXp7k2!2Y-xGu8B<IAcc#lYt2xH(
ztIm<*HHuk&QQp?sZF}w~yZeWx`s|B@n1Il<bZ4+<@=B(VA*J9<j#XrPKJe%%oPPWi
z!jsZPZ1bh?Sorwg0~ujUg)_;s3|&<bTuY4i$y92xFsr#ek!6z&x*&sgab(Bkrfdg2
ze*eRcbFlV$1e}acQ)Wvxi&H)lVRZD$Iv}UQj^J2W=yx2x={pEK4F*Y;%#K}&l;Mj~
zZ)QrdY0TnvPg}dT7yC3kr+OyGElO;ou2`|4lYAa>Wfhz`u2PEK1Z5}Y*2XcVvP4lK
z`Dq+hGSNcDq4>+hTo=j0`Q&ER^EHL4=RS6hPfY(8p2+3EpC;Y*65||}QAv-ta^L7)
zPGZ%)t+q-^6JQT8n>qI-NnB$a?l=D>19JtCPK<KQ+CoVIFsHJnBvHl_dlA@?-~)`Q
zW2MY3(<S~pyJSKHOE}~YPDvXK8cjo$N~I<*Y)_-gFxRUL&O07M0l$#6KLQ@5-`pDk
ziInEi(d?PZ93Fg>s>mtKJRykyK9mcw=@5c{sh~%3$cT@L@TO9KZ4;i^#U^YKAyq{t
z5ZD?WwoHIcpN-#d5jJE>R#FD{qg0v=m+XVDx15H*Pv3(*A@Okj2`KWoHdkE}DARS>
zy`V8;$UE-D!jixs`1y}Np+Tb$K~>vb6rr#R#^$V8t35%P<aAo?3IpY|*6Gp>&-$j}
z^EVV1h{bHGo*OoNQ?J*T<Rm1oy(-!rFeVt0nqX)$FYdtO<&m*3XQ!n=HtH&aF^S0u
znTgcI`0{08e6k^5RRGRgZ8-2$k^zzIv<p%;&MW|PK@PRE)z<T~F!dz^vxkf(V}~^+
zsQ{Qs1-=|*8Q88jZUR#eh3A?}23)i2eAdWe6AP&ial-7Y)o5mGwc5|UG@6<;L6T=H
zGigUofEfksX>4-Tp@b%+rmR}EYJQ4gCC^zBlXp1Pb*639hx)QjF!%ll&;>k7Tf65G
zL<ELIvY&(1+q;F`*{Iq+sSunqSSh8oWL5Xkh$L8X<q?cKd=q+Y4}#XKk3a(iS;N9W
zP|x!hYHX6)DC&6u;ECTiTDo6k6Z_dW2&Npn1skr1!~U=YxPapc8?r)`wK+>B)wSJD
zUUWZcp9jgX<5mp(6L<#tjF<q8KWZWX*@oIW7UiL*UjKy3Ga5|Uy|mhkl-nAgu~J&K
z`UhMP-a&v)HEqY|?;QT#DmmLQJr9(+v$8SXIrl37%#`@xsKg(Zyo;+l*uH!ZoY#hC
z^ZaTtIH$|RIIFWbemxnLGO$|xJuCZusZiaXl}71AwT=R2-lvbm`I2q5woC}zivZ?M
zGUF`H;&W{7sa{{k&tRq!H8N|rLY?^E8Q^f+GBTD{IFatgN%9O%nj5^->Ooo$kB{nT
zG*#8rtCN#V5t<Yku=5hTCN;RZm_U~L)Il(1@7N+99v;Q@Zf@m7LI@9!5A?{;@%@Jy
zjiv)i4}9MTk2wS<=`jYCY9gM;G!p!7s$Q)gkFO)JPk-u*(gxpat5m5{u|tQ?Dy}+q
zz328@u}A$vlj8%z(o-`4I@EEh?Sqff6vaE+V$$cB-I5LX9J1+S2-bT-;$X+!81M;>
zf~~irU>m;f!q0m{<KR?e5?p+ej(v^$Dt73yVoN^3ELm~l5VQNY`@vJ#a`iFH*?v%D
z?rPZhBcZZ3<+-*ZY54q1qEes;#1nKH%~b^GL;_z=t@bHy|IVbYCZ{g^Oa&)WSk;}b
z!{6Ro1}|%#*96Y`nl($lY;Xo+W};OxEc7D>9<Qk#p2}Hio3m>x!~N?@IH#G~kJ%W%
z6|3xRwKS8e*J8iF!MW{Q2Ltmv?2u-w5nJx{l7V@g%s2zH2+SENIq@~GjN=uJ^R9w(
zZDL0hK~~x(a9{<rj7F2DPOa{Zlj<RyV8e0Zj6*hk8-dZ!Q>R;uljol}(GI{qy>Mdf
zhVmIss$HlyF24T?zwha((fo}42O@}%!hNUVK1;EW501B=avTdgBaVyv&_tcgMemKa
zMkz5({90`i?i+_=2IF!3RkdnNYxZ%Q(PREuyM4{coA<X~Lx8)NfGqEMpvj)sb}Af>
zFtX>Y0QB>DxQ)#BteMbfBLIV7-B~^ctF7sL$-&DWFs9EG_O$NIU6{1e2fqHPAJnZ|
z&j`r!j$J7Tm|u{$Giy84`2D}6x~A%6_&oS|d3jYbX<=xAM&VHu!^{<<?%~3#p;B`S
zskQ6Ys^yean|1=l2$?@@ZwDT0xRb%<rXy7EZ0DA0)3Z7LN_&7GjAi}~Ir-i#aU?MF
zezRoEBz+~c6V9&3OsaILw6JtuO|uKk+`qSswxch|$C3|n^6yVR8ikxT(a?m4K-&%{
z(s?*x9``gDs1SX$m%$Lvm8McyO__?X#CVeFy{RN0RSfcC@njLzfJ|a$gH$3m5>gn)
z!m-K5sd9IVY}lxAbdO&Kq>h@m0v7H*4&Il-gp(45^N_<*Mykkc0JRaI&Fs(F1Zjs!
z)U&u`0mxEn>rk__nb?o=SyMU2EtkV#p6_A!ZNdy_)xMLs&qf=vMp@_+y=pX*DD@?!
z!Zdk43)QtwcbC{R0{3_3;ZL4wbv0aI?ZNFy24g{s^#tsSA67gLXY$JV5`npcjOx}K
z98(b~m&`=yh(?p2!2##0mtpqHvpIe%nR`CWijz{blkXjQAm?>3Fl!~e{?k~)k@%8;
zxtc_5FEy)Kw6X}y<s`zKsGXJqMP5W~cJl8}cILV-V$LC3a3xXIN2BRWK#dcpFHXY8
z@cm_CI4I!=ju9x25x^re2{I*=#|EQB7@ob)B-}3w-$&zXEP`%4PSQ`s0)U-_3<`jO
z3M5eaM`Cvk8a9Scx_$|LhL4BItGC1QgBM`ywMf``H%{10$-zs2QWk-lGG!eKPlIET
zW&j=aa=@5`&V$a!W(F^FFeVoLAO-IQg7MV|SQKy)hRs?6UB2!K_3AgEMGj~@JTd{Y
zlEso(B<XbfsmO$7Vh{x6=Gf;dJ~yZEeGPL~Ou5)~TCFc-{_@1%oq*il#3C;ln5%&8
zT*|<9t?~{yj$CL;4BNEjBtphPYk-5!Rcg{+mCf<pK)OuiC@YI6sl~`+h4(HhD~?Fn
z0A|WmwoS%fpZcPKnHPz243y6MH3tDRnT+PicyV`>IA4mle((bRJHNcp$%mY^$bL*&
z!Ss6l2cBB37Xdbvhx9b6w7<p)`Fo8@^%G94KMFy1B#PJLHr(e6Yl7h0jY{)j|6g$8
z9*q6R;v_u>#T!BS2!g{+e2p^MB9$htAhj#S)e=w>U^i*e3O?)k0}T3W4$R&X2rG|W
zhppF1?HvcZ5vYwRCG7+1-JEZGe^{yrK{_7w0zleq{No(@M8|(F&$XF$K)fOl@4lA^
zJ8s9o`ZIS0GafQ+0d(#0Jv40eVa9?+Yf=4)?|B;4K^CPJ_4;^|)0V+HYmTJ^A=c7j
zdTKN}{9RAuF~(cklJQw6hrjhEF9c=+aD0|@IbPwodMm5({W2=Oz7DY6HkAmWNoAFK
zYo2s%38mBQ!rsk_89pe?*k#tgtPC*!V=?KzmIYvz@~|FkhiW~99mCqm+&ilN^eafm
zt#@}MF!R1$6nMJ7Xke}&6F!zEWx|0hlzn6;FsXY_b;aM1urH@b{6B~D?<@D;=>*c5
z&Q^i5@@6Y#(<s8TnnGC!wCmKVlb;;KXws!Z_gw5=cvh3pc9I$m8|E{KX&(}@ag!RI
zDp}#arHHNL=LQBNXrCnZEEy|nGm(V`v?>n)JR*0qP6sVowS%vE{UU&R*5*K1b^JPP
zy8H-y@5TwICnLC}J_mBv0DHGtQH*_IMq4y7*yC*LJ!MT4g0D$VG7wWmEE<0wgRyYZ
zGC#i%ljBx0N+S5)jumAWmmfF}<CboOUV}zJyDpytF0gpvB5gaS`-p(~$e_{8!q=gc
z$C|(u?_mr|n!!pYFMR!*LYu6bN!03E1i(068%xJ6TJ&kj@er9aE~eJiG&*<X_>X||
zZ!)S?it&BlPH%5ZaQt0jd;-A=c8tGVVyvs?c4jcf|29A=3<@hbu?kko(Pola-?w=D
zf_9Amv5czxdkg!r)WT`E9rvw(3?R*S0x-)}opJ^+e=p(eSct=zKqjvD9R~xmT&Yt^
zu2av(@uX^(N7?z``A1@`TVO{5o&RFXX~C$PQch)qjZ9Lc`li~vC=c}-O$ffmNiu2#
zY7z2-uLivV8TH5TB?2|sS10|u85Zq14eNvM301G}?I*DNexgu;TXiZk_hdG)R91Hr
zfF2Atf+>Yw3BZmt+Ja9o;F`qr9Rct$6A0rzhX{xtr3$;Tzxi=Oj4EjX!uN>{KY`6x
z!iD43f?dbq&n4@i&&Wy8xm!=6+NbL#W~`AZ!DwmA$G(@;Zf+{7G^WJ`6WN7HyMgyS
z$iQCLnQZ?W%?<3Yx0UV^e@i#)JDl@XXZoG%snw+soVVb(3D~bMdHerIfVl?97ha&)
z)6!rgAp)xh^Rn8FR_7%wCPXQf<|(kR!cu=3TbbShIH^zpC3Em(fPO<_Y`TUiN*Nhn
zZ!oi351#m6ml!{v3@{L2w>0ZtQN~MrvYo&6c8Rg59`IX^1ZLj9PZmPGvc;JBdCbl7
zI^XyAIXo#{hAoemxgNWLnfLozW<j>Va&gBREvf$w#f#gMJ*<~Z6oyxh|1S;Mb6o=!
zJ75oO!!x@k6+n21;IR#5h)ShuO`%vgxld!qG@I<&kjXx+Lcnqt_EkDY{RR!8MVt1}
z?WevlVBB;VyJS7g^4SZ^4_yN9i=o0^z5Qk^?7S0iWZ0|@&s1qCG&PfLmqL~T9wM`5
zp*+=l5x6sizY7p5^=FAdh>`DpkR-r&=bbn_Zj3no24up^4qgz9|Ifv1px>A&@I|lQ
z(7aV!s8_$f0ACNcT1FriDr$}7y^v5(rz1%IUaeZSO!baM=$lTrT(IZNi==e?4gM%!
zzI<U@zbF1qmFailRGT?0?9rugoGrM(dZ5$kn&o)KlirvC=MshCNc9+u3Njli#4(ms
zLh@TMCPAP=3)RfVFDhdrn`h_w)@1;e^(1G;dE1PcldZ2Uhw~I=7MYJ<>AHH#I9d^t
z)>vFylv(HtWnXH+>hL0bk4)p2WROdgiDRy4;V32rBAx8KcT%y#q-u3{0x-WT6FTK+
zU>?VdBo+Nuw9sLj@>vDPrD|W5oCM6Jn3YOtj;dJfQ&Q&MEwS_WSId|d2L6A+<vcj)
zPZr+YCIHask|^{_r`4{+iM+kLyE_#>c&ARCI%P<OF5+CZ+G~bqp;qQ;Ad}h2ECRRR
zr*S-Wx+ofxRks4jOzLj|ZXO;`uU>s<(yS%4?$AX5AZ5QAI(-35Smq5gz5QXq&ZDqo
z|2bj5ULSNHwp@;Ytv4UTwp&rKJviDZw_{*OaE$O4r`PQyxA1$4Wxg2+TW>su&6mSq
z{n@*)^5`}AXKxV9^*sX9as2U1Hp1X3^WeuJqv5k}e-fV4A2n-{5za*CX^JzZ^H;=*
z={}Nn0R^vJlwGtm1&~u0IsB1Rm!<kyWaQFnfA`dCAL-fSUT@5Q9fbXB=8!0_i2D}f
zOkU5aFDda2p8qZ!=O9w`%Ks78tOjM}3Tg77>{Jt3#WtJ4_>RQ{U&U<fhB83f&CYWz
zXmLEtw!tip^i5{8=8fv*USOLVmD?N0uRB4$=me!HEnor6md<mr3<AWANAmat7W)*$
zqWYU_CHOwuYO!)4V#8jUCSkAq(b2%nW6XMiz#PTEd7o|Yu?mk#&&3Z47aDd0Gw(ZD
z<{bX8a2%^A!|;3A`TG}_F=uR4YLfX+H=MjZaKaBW7-O2#gfo~{>x&crr^LLdb~LG3
z$xh9oGZdzi&tSBLJ_BV0WPBfivLAta0>#`?ViitW@*{%$RvOznh&=;qlWo>0?m{JQ
zV%bfaw}g+|c7V2>KZA~+e+^x`e=k(zJ^K6x-~BcedJP<gz&ZwgLQwy4@F?;5+W|wM
zJ8u8t``+;B*WZeQ5N$hs1}%}Xf7G-E)UV$lBXr5+q-C;~n?P8qP=rMO>L=u7uT`u6
z77lkB&3e3!6Xa=cN(^F_HZvLTQFqG1W>r0n+c+1t@S^uLhSc>hR;-wuiYTY8T<xCj
z?qv~}x6`@RGR7<a7g+Nc2?s5ETC4>y_m{D)sqH*hxk3qK6E7?Q%vo)uh8$^eE=6U$
z+U;q{<_=h_#@r{P#(cxhdsjh5HNMP>ebf=athWOovkS~w4HsIZ<bGxom~}Fae^)Kc
zK!atT7kmFZq}tyiqcJG{KMl&{5QdZU7LJEb#P^pFi25Nzu3<13-m71~{yPN7mg-Jo
z%;dCW#texO2I^I+?i8-$<>mD*v1^Zd^@@`N8m9*>BC?R_bYXfsJiztLvb6%ZRhfWW
zWd@}3;-0BLv2?rG@3U()#hFXRfv4-$>IJm0q5G(B*svT|cdCYql};!tvEO5pgO{f<
zt)>roPv@}VEltU0P#&0K%(WWLDe~aYk&WzJ!dn}Ui;Jh9UX>c*GJo2_?4Xk3C}8G^
zV7*NIY_Tky>tGqM_i_R-U$P7xb09DiD>`giP?*`5LnQW@nT7lIhKw^AX$0~)0hnKB
zP0OnY%!$0vE2{8XvIER?A9l!`&yQvcP^o)%)BJg{;~5wwV`tX=PlGZ}@KX)MbalF0
z_&OJXvp#_;0WSfmDUpR`Lm>OgU{tA6wy<0Hc`WW%8-Yi#YtF@Om8lUEM}T>3P~iP7
zSJp5qee6oKVkyS!J%V7i5AWGslY0KS<0D(f>u<_6kc;wt%=jZTZQAs01mjN(8cm>3
zaU1uG)TvaTlqpjtudUw<x3>}*-iSHl0s-&k5F1sa6gLs)tkKLO%|;gDn_mVvlY<PE
zAAFLHi7w6zm`j6na)otSJkKUF?7puV5Z!UW<V{TCV=L!Tlx^zSX=&_uRnH0lrAqAc
zMHcVfR2h(RcQi1Y*~=4NAz)5so9|S6SYmd7nfLD~W7;{%z8j^?{3C3cY;tGe_y0)7
z32o5-Bq&opZUl`V3}m}Ra6snxwVRt;Rl)9zRfgWOwJ&+{;y&BF^m<BA5`_DHOQ|4f
zUoOxg$GmdkvHd*F?9&$N@FW|+n2y^cZEZKRamN#YO0d}k!P<4YV6h;<dqB2dgB1|A
z60SrcWlJcZID*;t*k_kW<nsK!QFsq^w8*iwxM9Zn0RrPrw#yT9r^QjJ91=0cICcj-
z#!XM7NB4P+ySq-x)~wK+Q5k`Ggsx^yO^#Qfc!h#LZY5S}-Us`0Tc`7+RguSPE;B~I
zES_Uo88+$7jDr};5oXa@Wm9C2{?f*I6k@OMglsHgXd-TFr#(^>g2>{%>nw9lKUwr2
zAklY?9mgdHxPuDsOCKi!b38j#kx#+rQeN~nj{lyFGvhiLU@nGoM#f}9kqz}_v{ys3
z`1=#!OBKY}3U-vE{7*Ddq<{(`Xf#1M!Bf?%+Qg8F?K1n4^wK3(Z7>4lK>`U~{rVL=
zJUrgzq!zMCD=1|oGS2<%^khmknTEjh06z!dHh;Y_4XI^1%G-F(GjaPZgAMgDZoh&3
zHejDKmTXqAQjO*TZr_Cc{>0DU>WxJ{#^CEQs%dOqDv`X=DMZXNTnS%8^tEd@Autq$
zLo}L62(b75uf3~*k)tfbx7YTfjgf$83T=hT^`x}D?e2Wv?Cei_g}Z7L8c<p_)<{x~
zVy#W^4-48}!H6LmC<0=%+F}u@kwgR(VrgP2f>0A_L5b8KVys5MtF}t3^n9M#ciO$}
z&fo6Rc8~W-CT(YDzWKhn>ptJ}{?^UupLi#O*=%-d+&jU0n~QsQ_?5k^eb&yKXXBKs
z?{jwDzxWZ|)?UYeyf(xdoXdLb+)Q+JK=BbFoRv7X$(PvvkS~eDa{ho2`QsA6@;Vvk
zYVoO!G&pDit~5En2@)t3Hui3bh^FtHm9y@Ub9-eiheCp&4vP{W5tU3c{Gyn7ER*Y=
z694T18UJvI(mf~vO3%m!s2noxgCT3%*U03Y;@$O05MS8X->3^fS{3r1d2VCMXMbEQ
z3?mW8zNjFq(P}Y`krc-ZvWfeh5aMPWAHgxL$@e#1es*DVzkM{m_Vv{<bLJdB6SJm8
zP0qhZ{LEqhcYZyt{LFrBWe_XK<cIiDUsb78PG#+6nxCUoa;?$^sof3|`vnwMnSo&>
zWtwJFm`;m$_DGG&Wz_N$nAhrjJ`dsTl}WJP*ub*qaqbEs!tD*!Hcje|b2<IEQlfHO
zP&7q8KZx_|=mV$kT-JRWec+svHRi#ZA}j1+%*tq+gaF4B`2c}_lLb3SU=lgK!ec{{
zqt_iQg7l>jNG!==%|j%7Y)<~ib;g;eslu(}e6GX>7Owj&)7@HC%>=uhvEp2kE>tHG
zLHDv?gA^v9|M^!!a8JvhJLUYw(Q2{&{<`}wlgRD$bqDiFuW!b`Tr>8vh_M;XJf%*p
zRpiU=JL2biOiaj6$+24ks_v69mZb1IGBxS~99PK~^8*dW-zDenkzDBu!*Wn1|9V)W
znd{fbb1PeTZ%p4>6EXHDYE7iFu3H;idvg;J^=HW1*GC-eq%{yRMt{uxwFlGJuA^l}
zHfZzG<o!nctk;FSzndjrIg{Z3)r}!@zDdSk74iA?t&peuZr>6y_L<|wd_4(dlLdKw
znfa^yH_fJO8yRJ8ty9Y+kgXsbkEA9_d2-S@&<sve3sSS#Web1aMIxmsT$KAMp5xr@
z9Ze5n$E(}u3uVt?{C#(WG%ZGZe~Q;|9NB=BsE~u^AI#hJ&*5{<z24-G^92z8Uu($q
zMXd8u%;!qn|Hm;!KCI<fgEeDx<J#r;?9ajT@c9jFI1xm$$C5KtJl@NHY1*z-i-Syz
zQMj*V#CNG0;l2J`*KJEhoDzPfm^XvUdOGR%TOx$dlC-J;`Ldob|K|Bg9kdpzQP#tr
zD@8{Z%6cmD#XY6P@q0v7Wf_Eq<9r#vEYBR@QLhTcNrDM(e?NnKJ}8mA6MK7m-<U=j
zF{K8?^d%6;J4os@eS>sTnW{j33#oo3E$caq^;JJzt4fwrgMt|JwFX_Yq%lK@r0o+c
zQ?hE*G&?7O%r-FBno-a-YBPgz7~FPPIxFp_nx@JRG1q69w_R&u$Me=Oc*`eUYxmTZ
z#=L>$O^@6?JlxG@Bp8F;!ua{NitF|zjdrf!efoi2#xPxNs8K!ada#lg-o?Fac*0E+
zPPK)6sPvP#H53YkLeU(U%X&J^wfvJL%@n94rt1JyeKwaHVqP-8tV!x=Ntpx(!nq%$
zbqM6O%NTP7&h?R$soHC!xN-jLLT>y09OwlLX0Wz17O+(Osz-gk#yncc=RMZ`4$RBJ
zI4r{9vcQSw@%l%os3o|nA#nYYq6C8Z&v)HTRJ~lY>p1WC`&1wGHSfV^#ad-a62|#!
zJr-E8_U}~HZ!MP-o2B?pXwHTbUdMORmB0*Mwstn2^(0*kg~7qL)xYLilB#`$LZMKk
z0KZ)6PZi~sAt8sQGKGQngO~?s@}}v!oPunEFL{v7rzK)~8>@*e0NFy7oh`*J#watA
z42h9`U*=Skbn)ySY$(=yW7YEC9M`>!V^L8bLnKhKVC;=060<Q6(MK(tlZIeqy31CZ
z()XGTAxP#y3KKhZVGVn|AVAD<*3=j0klgT1Am>A#F>8fj6TvU!;<|speGg;9GApUt
zE*Wz%bI`H2rCsecL1(%;qzjcop-^-TYIA6Xkkh8aOmgPTIcM?W#U!V0F*m3Avd*~q
z{Cp4@Bc^}A^qySRk9k&@>Sh`ei1A-GpI=7OrD>H_u|QZmy`%nVD(_pFswIRwIYfnC
z><3j@`?DagIBcQ}V#9U2j}Wu9Kjx+&h<fI`#9FRm$x+!LJR$v$d+MwMGw}I#-2Vtm
zZKl`=WiaMfaNkSJSx(_<;0EOLIJVFNp=7F1C={K6rqmA!IWT*Rf=fm0Vm@a7=M7B7
zp=nqOn1q?qCxCc&u?rIKB{A~3VDlo&T-KPdchZ#1&!beZ-{aca=NQdRVwU>Rp`fBK
z3NaT%G2{71?(th`8uL8{YO(v1$>o+eB2YYQ0E+v!c=iWor!f07unz1057VHq33^k~
zpBdc~nCrLj%nzk;Qz#S)g`&eSJUkqjnY+7E1_MdJ*fk84V)rBx4T(9*L_0V*_y(6j
zP=&%fnFk#79=1?~N20l{9f3Ohn2`STIA17;^iC2v)ubB}y^LpXkrJg;%y&@P*Alak
z;CT$xDplum7q4lwVPT{=HW=T=x~C<5ciag1dDzxIT+HWt)0E1jPaVfirD}r<Rm}>8
zLh&k4+=;=|D4LORe3mMcs*=9yIJ0g(pLgh^r2?c6n(B`S$ZCf~YQGG!yOR;tjKWS5
zgvMebBs)pRIz5KOHyj~mW4^|E(v1``2>x<hbAZhyu*QXrN@+?bt{WLKou=HSU$n&9
z7pc0XR(V&7doPV@h@ns@6pB|TCeZha<2@u*R{J6$Cdrou5iP>Cmv9V;h^ATCf?W4W
z2dv+-4t1qcc?%=8lWZ7@*=(-hI9r+G6&H*}zqLeUk76#X!+hZ+Yh3eyU$M(|*M=!^
zjN#C{oHWW>NdN6vFLRndoF;foHUqC=1bHE!@9*k>@|p^TLZLVgpvnU=I3x+0nfdRe
zMNCL!^b0eOH^^%SseZu^$a3A6@b_yO5GKCgo}}{u;cjG2=s2RowYP|W`4EH8_#Cby
zMBQJ6Iqhdt3#j{<A=ZEl##)4HXC(~+Bgwlg{b|f?X^NE8kn<F%_(iQYxKJn*3dQ(9
zM$FbEp^O9~B~@<SLCtL;<?cdnFG=;6;`7~s&+`oUN=rKI#KekLeSLkArfm9z<ykMV
z)TK1%Xx!77CU!QmfSRYdIxJ_|PoXLl`jZq53El(L_<i&<b7Rm<Fc)*gOVz-*N%||P
zP$(3N0At!6ri8B&sWut?45He{<_%QK(i|dfbofQ{LF(eO4e#D$?e|O7f+X}wGl%-k
zQO{zZWcFxgt?wvv^?ZCLInPN;bPi*4@F!XjhK7bx*RH0@#^z?m!s=!~1Hlvug+kF5
zbhA8XsZe;Ck<}~!BI!|+(+)(E1v#5QiANCgPf5(4<7}pRx?C=w8AWVNzbZJ+)0pSI
zLgEb-Doy!(c2cu6*1H6AdEVx7gK+_CVOR>KEtUnX;H6L~6pGftR4JCeWalO~pT8hY
zz}GQj_4iM6v)MlSizEEq8K~b!{i<V7!1FxsY^Hg|s&Qk!$Xsb-j2qKwD<hkN*!g3u
zoKMWwE}lJmb}LN_Ce{|2Q79A&g`#<4Hs*bPg)d{)f{>@D3HYi9BdZxmC230y6(p57
zp7|TLZN#(QMgMY=mX>U;;a2_3?{<@Qd5R@TKLE^_y{_Y2!cv`Gtv8fVVpb>=3Ptmf
zh7dn08uR$PS+izJ1+ddv8I$T)>U~cNQ`Kw_2}0b%bR$*@OJaH^>0_?Xc&>XTbG6$+
zg2UBrRZlYVn?7}ID4|d&6p9myQmHhD{f$A6?`2SxRM%>WoY)A1q#0()c5}Hb2=?DN
zzDrVOL6W3OmFZYGHdB?exJo<T0o3vq%wa)I6B30&p-?DJ2r>o7S#6EEpXpO1$+Q))
zV$hImnfr^)z+o2lkTj{pL08ssRzPWQXZg)`Ro%h{VTCm4I71b)LZMJ7P8b;J4E6bw
zqP2`jK1I@_x?kz%vO-tEn13)=I;nrTX3hh+_c4|VtyC(fwqtV=)B%^=>u&wcP$(1%
z#R&n(?Lv^!disJH_!LwCd!+%j%o^2ONrY6YT`6*<S=U<%f|zF0o5CQK$253Lp-?Ck
z#~*&s7fWz@UY>-MwpMg202$u{V*Ml)uLN<WB2OsphZv!aV~YMH6$*tyF<#X2IR#^u
zQz0^nI!#xmR=|KQDCVDMv)LSpwH#7jGYX!ycY~D|NUKU!xC(_rq3C!p=<EETzj32>
zi?0+wrZX8;O+wBVi&G_nI~DxSRMrki5ft?aD-;TaqO-wf4ItyWBsKb#k7ol0YzW@w
z8uL*;yV*)x1#7QyUAHJcW^K8sP$(3N&IY5PrIS+Tc$u&RrS3Y;QmE$h*gLuzGq$go
zjag}onG+N;(VwV7p-?Es3rK3m%@j;!&bEzy1+PNk_01OZfLdO<(Ap_dp-fHL3WY+U
zP&5NSqB@)H<KI*COg>h1=W>R5$I{VBiCLjgC=`ljFgiM#5r1}f3l+99l5gB4W_XRt
sRwxt-g`!1d+CZooRm%#6LUHop|J8kk7=q}x_5c6?07*qoM6N<$f-Hpy1poj5

literal 0
HcmV?d00001

diff --git a/manual/README.md b/manual/README.md
index 049ddc8c8e9..71e2104d37c 100644
--- a/manual/README.md
+++ b/manual/README.md
@@ -21,16 +21,16 @@ under the License.
 
 Driver modules:
 
-* [Core](core/): the main entry point, deals with connectivity and query execution.
-* [Query builder](query_builder/): a fluent API to create CQL queries programmatically.
-* [Mapper](mapper/): generates the boilerplate to execute queries and convert the results into
+* [Core](core/README.md): the main entry point, deals with connectivity and query execution.
+* [Query builder](query_builder/README.md): a fluent API to create CQL queries programmatically.
+* [Mapper](mapper/README.md): generates the boilerplate to execute queries and convert the results into
   application-level objects.
-* [Developer docs](developer/): explains the codebase and internal extension points for advanced
+* [Developer docs](developer/README.md): explains the codebase and internal extension points for advanced
   customization.
 
 Common topics:
 
-* [API conventions](api_conventions/)
-* [Case sensitivity](case_sensitivity/)
-* [OSGi](osgi/)
-* [Cloud](cloud/)
+* [API conventions](api_conventions/README.md)
+* [Case sensitivity](case_sensitivity/README.md)
+* [OSGi](osgi/README.md)
+* [Cloud](cloud/README.md)
diff --git a/manual/cloud/README.md b/manual/cloud/README.md
index 9116b03dac3..79b6bee4f51 100644
--- a/manual/cloud/README.md
+++ b/manual/cloud/README.md
@@ -146,5 +146,5 @@ public class Main {
 [Create an Astra database - AWS/Azure/GCP]: https://docs.datastax.com/en/astra/docs/creating-your-astra-database.html
 [Access an Astra database - AWS/Azure/GCP]: https://docs.datastax.com/en/astra/docs/obtaining-database-credentials.html#_sharing_your_secure_connect_bundle
 [Download the secure connect bundle - AWS/Azure/GCP]: https://docs.datastax.com/en/astra/docs/obtaining-database-credentials.html
-[minimal project structure]: ../core/integration/#minimal-project-structure
-[driver documentation]: ../core/configuration/
+[minimal project structure]: ../core/integration/README.md#minimal-project-structure
+[driver documentation]: ../core/configuration/README.md
diff --git a/manual/core/README.md b/manual/core/README.md
index 5ca4cd7872f..b706eda5ee3 100644
--- a/manual/core/README.md
+++ b/manual/core/README.md
@@ -30,7 +30,7 @@ following coordinates:
 </dependency>
 ```
 
-(For more details on setting up your build tool, see the [integration](integration/) page.)
+(For more details on setting up your build tool, see the [integration](integration/README.md) page.)
 
 ### Quick start
 
@@ -69,14 +69,14 @@ variants that return a `CompletionStage`).
 
 [CqlSession#builder()] provides a fluent API to create an instance programmatically. Most of the
 customization is done through the driver configuration (refer to the
-[corresponding section](configuration/) of this manual for full details).
+[corresponding section](configuration/README.md) of this manual for full details).
 
-We recommend that you take a look at the [reference configuration](configuration/reference/) for the
+We recommend that you take a look at the [reference configuration](configuration/reference/README.md) for the
 list of available options, and cross-reference with the sub-sections in this manual for more
 explanations.
 
 By default, `CqlSession.builder().build()` fails immediately if the cluster is not available. If you
-want to retry instead, you can set the [reconnect-on-init](reconnection/#at-init-time) option in the
+want to retry instead, you can set the [reconnect-on-init](reconnection/README.md#at-init-time) option in the
 configuration.
 
 ##### Contact points
@@ -91,7 +91,7 @@ This is fine for a quick start on a developer workstation, but you'll quickly wa
 specific addresses. There are two ways to do this:
 
 * via [SessionBuilder.addContactPoint()] or [SessionBuilder.addContactPoints()];
-* in the [configuration](configuration/) via the `basic.contact-points` option.
+* in the [configuration](configuration/README.md) via the `basic.contact-points` option.
 
 As soon as there are explicit contact points, you also need to provide the name of the local
 datacenter. All contact points must belong to it (as reported in their system tables:
@@ -123,7 +123,7 @@ datastax-java-driver {
 ```
 
 For more details about the local datacenter, refer to the [load balancing
-policy](load_balancing/#local-only) section.
+policy](load_balancing/README.md#datacenter-locality) section.
 
 ##### Keyspace
 
@@ -135,7 +135,7 @@ session.execute("SELECT * FROM my_keyspace.my_table WHERE id = 1");
 ```
 
 You can also specify a keyspace at construction time, either through the
-[configuration](configuration/):
+[configuration](configuration/README.md):
 
 ```
 datastax-java-driver {
@@ -203,7 +203,7 @@ ResultSet rs = session.execute("SELECT release_version FROM system.local");
 ```
 
 As shown here, the simplest form is to pass a query string directly. You can also pass a
-[Statement](statements/) instance.
+[Statement](statements/README.md) instance.
 
 #### Processing rows
 
@@ -218,7 +218,7 @@ for (Row row : rs) {
 
 This will return **all results** without limit (even though the driver might use multiple queries in
 the background). To handle large result sets, you might want to use a `LIMIT` clause in your CQL
-query, or use one of the techniques described in the [paging](paging/) documentation.
+query, or use one of the techniques described in the [paging](paging/README.md) documentation.
 
 When you know that there is only one row (or are only interested in the first one), the driver
 provides a convenience method:
@@ -257,10 +257,10 @@ See [AccessibleByName] for an explanation of the conversion rules.
 | blob               | getByteBuffer  | java.nio.ByteBuffer  |                                   |
 | boolean            | getBoolean     | boolean              |                                   |
 | counter            | getLong        | long                 |                                   |
-| date               | getLocalDate   | java.time.LocalDate  | [Temporal types](temporal_types/) |
+| date               | getLocalDate   | java.time.LocalDate  | [Temporal types](temporal_types/README.md) |
 | decimal            | getBigDecimal  | java.math.BigDecimal |                                   |
 | double             | getDouble      | double               |                                   |
-| duration           | getCqlDuration | [CqlDuration]        | [Temporal types](temporal_types/) |
+| duration           | getCqlDuration | [CqlDuration]        | [Temporal types](temporal_types/README.md) |
 | float              | getFloat       | float                |                                   |
 | inet               | getInetAddress | java.net.InetAddress |                                   |
 | int                | getInt         | int                  |                                   |
@@ -269,19 +269,19 @@ See [AccessibleByName] for an explanation of the conversion rules.
 | set                | getSet         | java.util.Set<T>     |                                   |
 | smallint           | getShort       | short                |                                   |
 | text               | getString      | java.lang.String     |                                   |
-| time               | getLocalTime   | java.time.LocalTime  | [Temporal types](temporal_types/) |
-| timestamp          | getInstant     | java.time.Instant    | [Temporal types](temporal_types/) |
+| time               | getLocalTime   | java.time.LocalTime  | [Temporal types](temporal_types/README.md) |
+| timestamp          | getInstant     | java.time.Instant    | [Temporal types](temporal_types/README.md) |
 | timeuuid           | getUuid        | java.util.UUID       |                                   |
 | tinyint            | getByte        | byte                 |                                   |
-| tuple              | getTupleValue  | [TupleValue]         | [Tuples](tuples/)                 |
-| user-defined types | getUDTValue    | [UDTValue]           | [User-defined types](udts/)       |
+| tuple              | getTupleValue  | [TupleValue]         | [Tuples](tuples/README.md)                 |
+| user-defined types | getUDTValue    | [UDTValue]           | [User-defined types](udts/README.md)       |
 | uuid               | getUuid        | java.util.UUID       |                                   |
 | varchar            | getString      | java.lang.String     |                                   |
 | varint             | getBigInteger  | java.math.BigInteger |                                   |
-| vector             | getVector      | [CqlVector]          | [Custom Codecs](custom_codecs/)   |
+| vector             | getVector      | [CqlVector]          | [Custom Codecs](custom_codecs/README.md)   |
 
 Sometimes the driver has to infer a CQL type from a Java type (for example when handling the values 
-of [simple statements](statements/simple/)); for those that have multiple CQL equivalents, it makes
+of [simple statements](statements/simple/README.md)); for those that have multiple CQL equivalents, it makes
 the following choices:
 
 * `java.lang.String`: `text`
@@ -289,7 +289,7 @@ the following choices:
 * `java.util.UUID`: `uuid`
 
 In addition to these default mappings, you can register your own types with
-[custom codecs](custom_codecs/).
+[custom codecs](custom_codecs/README.md).
 
 ##### Primitive types
 
diff --git a/manual/core/address_resolution/README.md b/manual/core/address_resolution/README.md
index 5b2536feb18..ad983f7275a 100644
--- a/manual/core/address_resolution/README.md
+++ b/manual/core/address_resolution/README.md
@@ -109,7 +109,7 @@ public class MyAddressTranslator implements AddressTranslator {
 }
 ```
 
-Then reference this class from the [configuration](../configuration/):
+Then reference this class from the [configuration](../configuration/README.md):
 
 ```
 datastax-java-driver.advanced.address-translator.class = com.mycompany.MyAddressTranslator
@@ -125,7 +125,7 @@ nodes are exposed via one hostname pointing to AWS Endpoint), you can configure
 `FixedHostNameAddressTranslator` to always translate all node addresses to that same proxy hostname, no matter what IP
 address a node has but still using its native transport port.
 
-To use it, specify the following in the [configuration](../configuration):
+To use it, specify the following in the [configuration](../configuration/README.md):
 
 ```
 datastax-java-driver.advanced.address-translator.class = FixedHostNameAddressTranslator
@@ -146,7 +146,7 @@ datacenter that node belongs to by checking its IP address against the given dat
 For such scenarios you can use `SubnetAddressTranslator` to translate node IPs to the datacenter proxy address
 associated with it. 
 
-To use it, specify the following in the [configuration](../configuration):
+To use it, specify the following in the [configuration](../configuration/README.md):
 ```
 datastax-java-driver.advanced.address-translator {
   class = SubnetAddressTranslator
@@ -176,7 +176,7 @@ However, this is not always the most cost-effective: if a client and a node are
 to connect over the private IP. Ideally, you'd want to pick the best address in each case.
 
 The driver provides `Ec2MultiRegionAddressTranslator` which does exactly that.  To use it, specify the following in
-the [configuration](../configuration/):
+the [configuration](../configuration/README.md):
 
 ```
 datastax-java-driver.advanced.address-translator.class = Ec2MultiRegionAddressTranslator
diff --git a/manual/core/async/README.md b/manual/core/async/README.md
index 5b4bac3dccf..1f69e39727a 100644
--- a/manual/core/async/README.md
+++ b/manual/core/async/README.md
@@ -64,7 +64,7 @@ resultStage.whenComplete(
 The driver uses two internal thread pools: one for request I/O and one for administrative tasks
 (such as metadata refreshes, schema agreement or processing server events). Note that you can
 control the size of these pools with the `advanced.netty` options in the
-[configuration](../configuration).
+[configuration](../configuration/README.md).
 
 When you register a callback on a completion stage, it will execute on a thread in the corresponding
 pool:
@@ -82,7 +82,7 @@ resultStage.thenAccept(resultSet -> System.out.println(Thread.currentThread().ge
 
 As long as you use the asynchronous API, the driver will behave in a non-blocking manner: its 
 internal threads will almost never block. There are a few exceptions to the rule though: see the 
-manual page on [non-blocking programming](../non_blocking) for details. 
+manual page on [non-blocking programming](../non_blocking/README.md) for details. 
 
 Because the asynchronous API is non-blocking, you can safely call a driver method from inside a 
 callback, even when the callback's execution is triggered by a future returned by the driver:
@@ -221,7 +221,7 @@ be handled anywhere. Either add a `try/catch` block in the callback, or don't ig
 Unlike previous versions of the driver, the asynchronous API never triggers synchronous behavior,
 even when iterating through the results of a request. `session.executeAsync` returns a dedicated
 [AsyncResultSet] that only iterates the current page, the next pages must be fetched explicitly.
-This greatly simplifies asynchronous paging; see the [paging](../paging/#asynchronous-paging)
+This greatly simplifies asynchronous paging; see the [paging](../paging/README.md#asynchronous-paging)
 documentation for more details and an example. 
 
 [CompletionStage]: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletionStage.html
diff --git a/manual/core/authentication/README.md b/manual/core/authentication/README.md
index 516e47f558f..ae3536ba2c6 100644
--- a/manual/core/authentication/README.md
+++ b/manual/core/authentication/README.md
@@ -36,7 +36,7 @@ This can be done in two ways:
 
 ### In the configuration
 
-Define an `auth-provider` section in the [configuration](../configuration/):
+Define an `auth-provider` section in the [configuration](../configuration/README.md):
 
 ```
 datastax-java-driver {
@@ -255,4 +255,4 @@ session.execute(statement);
 [ProxyAuthentication.executeAs]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/dse/driver/api/core/auth/ProxyAuthentication.html#executeAs-java.lang.String-StatementT-
 [SessionBuilder.withAuthCredentials]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/session/SessionBuilder.html#withAuthCredentials-java.lang.String-java.lang.String-
 [SessionBuilder.withAuthProvider]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/session/SessionBuilder.html#withAuthProvider-com.datastax.oss.driver.api.core.auth.AuthProvider-
-[reference.conf]: ../configuration/reference/
+[reference.conf]: ../configuration/reference/README.md
diff --git a/manual/core/bom/README.md b/manual/core/bom/README.md
index 235edcf632c..c5307082189 100644
--- a/manual/core/bom/README.md
+++ b/manual/core/bom/README.md
@@ -60,8 +60,8 @@ in its POM. The driver artifacts are always in sync, however they were pulled in
 
 ### BOM and mapper processor
 
-If you are using the driver's [object mapper](../../mapper), our recommendation is to declare the
-mapper processor in the [annotationProcessorPaths](../../mapper/config/#maven) section of the
+If you are using the driver's [object mapper](../../mapper/README.md), our recommendation is to declare the
+mapper processor in the [annotationProcessorPaths](../../mapper/config/README.md#maven) section of the
 compiler plugin configuration. Unfortunately, `<dependencyManagement>` versions don't work there,
 this is a known Maven issue ([MCOMPILER-391]).
 
diff --git a/manual/core/compression/README.md b/manual/core/compression/README.md
index 9f7ae3c4854..7f60e996859 100644
--- a/manual/core/compression/README.md
+++ b/manual/core/compression/README.md
@@ -36,7 +36,7 @@ you have larger payloads, such as:
 * requests with many values, or very large values; 
 * responses with many rows, or many columns per row, or very large columns.
 
-To enable compression, set the following option in the [configuration](../configuration):
+To enable compression, set the following option in the [configuration](../configuration/README.md):
 
 ```
 datastax-java-driver {
@@ -55,7 +55,7 @@ better performance and compression ratios over Snappy.
 Both implementations rely on third-party libraries, declared by the driver as *optional*
 dependencies; if you enable compression, you need to explicitly depend on the corresponding library
 to pull it into your project (see the [Integration>Driver
-dependencies](../integration/#driver-dependencies) section for more details).
+dependencies](../integration/README.md#driver-dependencies) section for more details).
 
 ### LZ4
 
@@ -78,7 +78,7 @@ LZ4-java has three internal implementations (from fastest to slowest):
 * pure Java using only "safe" classes.
 
 It will pick the best implementation depending on what's possible on your platform. To find out
-which one was chosen, [enable INFO logs](../logging/) on the category
+which one was chosen, [enable INFO logs](../logging/README.md) on the category
 `com.datastax.oss.driver.internal.core.protocol.Lz4Compressor` and look for the following message:
 
 ```
@@ -97,7 +97,7 @@ Dependency:
 </dependency>
 ```
 
-**Important: Snappy is not supported when building a [GraalVM native image](../graalvm).**
+**Important: Snappy is not supported when building a [GraalVM native image](../graalvm/README.md).**
 
 Always double-check the exact Snappy version needed; you can find it in the driver's [parent POM].
 
diff --git a/manual/core/configuration/README.md b/manual/core/configuration/README.md
index deefadbe3d4..7e5b3da2e49 100644
--- a/manual/core/configuration/README.md
+++ b/manual/core/configuration/README.md
@@ -552,6 +552,6 @@ config.getDefaultProfile().getInt(MyCustomOption.AWESOMENESS_FACTOR);
 
 [Typesafe Config]: https://github.com/typesafehub/config
 [config standard behavior]: https://github.com/typesafehub/config#standard-behavior
-[reference.conf]: reference/
+[reference.conf]: ./reference/README.md
 [HOCON]: https://github.com/typesafehub/config/blob/master/HOCON.md
-[API conventions]: ../../api_conventions
+[API conventions]: ../../api_conventions/README.md
diff --git a/manual/core/configuration/reference/README.md b/manual/core/configuration/reference/README.md
new file mode 100644
index 00000000000..b86ac9a46ce
--- /dev/null
+++ b/manual/core/configuration/reference/README.md
@@ -0,0 +1,32 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you 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.
+-->
+
+## Reference configuration
+
+The following is a copy of the ``reference.conf`` file matching the version of this documentation.
+It is packaged in the ``java-driver-core`` JAR artifact, and used at runtime to provide the default
+values for all configuration options (in the sources, it can be found under
+``core/src/main/resources``).
+
+See the [configuration](../README.md) page for more explanations.
+
+```conf
+{% include 'manual/core/configuration/reference/reference.conf' %}
+```
+
diff --git a/manual/core/configuration/reference/README.rst b/manual/core/configuration/reference/README.rst
deleted file mode 100644
index d4989ecf641..00000000000
--- a/manual/core/configuration/reference/README.rst
+++ /dev/null
@@ -1,34 +0,0 @@
-..
-   Licensed to the Apache Software Foundation (ASF) under one
-   or more contributor license agreements.  See the NOTICE file
-   distributed with this work for additional information
-   regarding copyright ownership.  The ASF licenses this file
-   to you 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.
-
-Reference configuration
------------------------
-
-The following is a copy of the ``reference.conf`` file matching the version of this documentation.
-It is packaged in the ``java-driver-core`` JAR artifact, and used at runtime to provide the default
-values for all configuration options (in the sources, it can be found under
-``core/src/main/resources``).
-
-See the `configuration page <../>`_ for more explanations.
-
-.. raw:: html
-
-   <style>span.comment { color: grey; font-style: italic; } </style>
-
-.. include:: core/src/main/resources/reference.conf
-   :code: properties
diff --git a/manual/core/configuration/reference/reference.conf b/manual/core/configuration/reference/reference.conf
new file mode 120000
index 00000000000..bbfcb9bf3e4
--- /dev/null
+++ b/manual/core/configuration/reference/reference.conf
@@ -0,0 +1 @@
+../../../../core/src/main/resources/reference.conf
\ No newline at end of file
diff --git a/manual/core/control_connection/README.md b/manual/core/control_connection/README.md
index 38544797aed..a7dc94fbc4d 100644
--- a/manual/core/control_connection/README.md
+++ b/manual/core/control_connection/README.md
@@ -21,25 +21,25 @@ under the License.
 
 The control connection is a dedicated connection used for administrative tasks:
 
-* querying system tables to learn about the cluster's [topology](../metadata/node/) and
-  [schema](../metadata/schema/);
-* checking [schema agreement](../metadata/schema/#schema-agreement);
+* querying system tables to learn about the cluster's [topology](../metadata/node/README.md) and
+  [schema](../metadata/schema/README.md);
+* checking [schema agreement](../metadata/schema/README.md#schema-agreement);
 * reacting to server events, which are used to notify the driver of external topology or schema
   changes.
 
 When the driver starts, the control connection is established to the first contacted node. If that
-node goes down, a [reconnection](../reconnection/) is started to find another node; it is governed
+node goes down, a [reconnection](../reconnection/README.md) is started to find another node; it is governed
 by the same policy as regular connections (`advanced.reconnection-policy` options in the
-[configuration](../configuration/)), and tries the nodes according to a query plan from the
-[load balancing policy](../load_balancing/). 
+[configuration](../configuration/README.md)), and tries the nodes according to a query plan from the
+[load balancing policy](../load_balancing/README.md). 
 
-The control connection is managed independently from [regular pooled connections](../pooling/), and
+The control connection is managed independently from [regular pooled connections](../pooling/README.md), and
 used exclusively for administrative requests. It shows up in [Node.getOpenConnections], as well as
-the `pool.open-connections` [metric](../metrics); for example, if you've configured a pool size of
+the `pool.open-connections` [metric](../metrics/README.md); for example, if you've configured a pool size of
 2, the control node will show 3 connections.
 
 There are a few options to fine tune the control connection behavior in the
-`advanced.control-connection` and `advanced.metadata` sections; see the [metadata](../metadata/)
-pages and the [reference configuration](../configuration/reference/) for all the details.
+`advanced.control-connection` and `advanced.metadata` sections; see the [metadata](../metadata/README.md)
+pages and the [reference configuration](../configuration/reference/README.md) for all the details.
 
 [Node.getOpenConnections]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/metadata/Node.html#getOpenConnections--
diff --git a/manual/core/custom_codecs/README.md b/manual/core/custom_codecs/README.md
index 3a32164c3a4..596c816b62e 100644
--- a/manual/core/custom_codecs/README.md
+++ b/manual/core/custom_codecs/README.md
@@ -40,7 +40,7 @@ Define custom Java to CQL mappings.
 
 -----
 
-Out of the box, the driver comes with [default CQL to Java mappings](../#cql-to-java-type-mapping).
+Out of the box, the driver comes with [default CQL to Java mappings](../README.md#cql-to-java-type-mapping).
 For example, if you read a CQL `text` column, it is mapped to its natural counterpart
 `java.lang.String`:
 
@@ -247,7 +247,7 @@ be of type `int`.
 
     If you really want to use integer codes for storage efficiency, implement an explicit mapping
     (for example with a `toCode()` method on your enum type). It is then fairly straightforward to
-    implement a codec with [MappingCodec](#creating-custom-java-to-cql-mappings-with-mapping-codec),
+    implement a codec with [MappingCodec](#creating-custom-java-to-cql-mappings-with-mappingcodec),
     using `TypeCodecs#INT` as the "inner" codec.
 
 For example, assuming the following enum:
@@ -625,7 +625,7 @@ Coordinates coordinates = row.get("coordinates", Coordinates.class);
 ``` 
 
 Note: if you need even more advanced mapping capabilities, consider adopting
-the driver's [object mapping framework](../../mapper/).
+the driver's [object mapping framework](../../mapper/README.md).
 
 ### Subtype polymorphism
 
diff --git a/manual/core/detachable_types/README.md b/manual/core/detachable_types/README.md
index 7968835dd8a..b9c433bc428 100644
--- a/manual/core/detachable_types/README.md
+++ b/manual/core/detachable_types/README.md
@@ -31,7 +31,7 @@ specific circumstances, they can lose that reference, and you might need to reat
 
 Namely, these components are:
 
-* all [DataType] instances, in particular [tuples](../tuples/) and [UDTs](../udts/);
+* all [DataType] instances, in particular [tuples](../tuples/README.md) and [UDTs](../udts/README.md);
 * [result rows][Row], and their [column definitions][ColumnDefinition].
 
 Detachable types are an advanced topic, that should only be a concern for 3rd-party tool developers.
@@ -41,7 +41,7 @@ them. See the [bottom line](#bottom-line) at the end of this page for details.
 ### Rationale
 
 Detachable components are those that encode or decode their fields themselves. For example, when you
-set a field on a [tuple value](../tuples):
+set a field on a [tuple value](../tuples/README.md):
 
 ```java
 tupleValue = tupleValue.setString(0, "foo");
@@ -53,8 +53,8 @@ reuse the tuple instance in multiple requests.
 
 Encoding requires session-specific information:
 
-* the [CodecRegistry] instance (in case it contains [custom codecs](../custom_codecs/));
-* the [protocol version](../native_protocol/) (because the binary format can change across
+* the [CodecRegistry] instance (in case it contains [custom codecs](../custom_codecs/README.md));
+* the [protocol version](../native_protocol/README.md) (because the binary format can change across
   versions).
 
 Therefore the tuple value needs a reference to the session to access those two objects. 
@@ -83,7 +83,7 @@ There is no way to detach an object explicitly. This can only happen when:
 
 * deserializing a previously serialized instance (we're referring here to [Java serialization]);
 * attaching an object to another session;
-* creating a [tuple](../tuples/) or [UDT](../udts/) definition manually:
+* creating a [tuple](../tuples/README.md) or [UDT](../udts/README.md) definition manually:
 
     ```java
     TupleType tupleType = DataTypes.tupleOf(DataTypes.INT, DataTypes.TEXT, DataTypes.FLOAT);
@@ -148,7 +148,7 @@ create tuple or UDT types manually.
 
 Even then, the defaults used by detached objects might be good enough for you:
 
-* the default codec registry works if you don't have any [custom codec](../custom_codecs/);
+* the default codec registry works if you don't have any [custom codec](../custom_codecs/README.md);
 * the binary encoding format is stable across modern protocol versions. The last changes were for
   collection encoding from v2 to v3; Java Driver 4 only supports v3 and above. When in doubt, check
   the "Changes" section of the [protocol specifications].
diff --git a/manual/core/dse/README.md b/manual/core/dse/README.md
index 75abeafb3d7..8617c3952a3 100644
--- a/manual/core/dse/README.md
+++ b/manual/core/dse/README.md
@@ -21,10 +21,10 @@ under the License.
 
 Some driver features only work with DataStax Enterprise:
 
-* [Graph](graph/);
-* [Geospatial types](geotypes/);
-* Proxy and GSSAPI authentication (covered in the [Authentication](../authentication/) page).
+* [Graph](graph/README.md);
+* [Geospatial types](geotypes/README.md);
+* Proxy and GSSAPI authentication (covered in the [Authentication](../authentication/README.md) page).
 
 Note that, if you don't use these features, you might be able to exclude certain dependencies in
 order to limit the number of JARs in your classpath. See the
-[Integration](../integration/#driver-dependencies) page.
+[Integration](../integration/README.md#driver-dependencies) page.
diff --git a/manual/core/dse/geotypes/README.md b/manual/core/dse/geotypes/README.md
index eb414de4f8d..dc0fa40eec6 100644
--- a/manual/core/dse/geotypes/README.md
+++ b/manual/core/dse/geotypes/README.md
@@ -25,7 +25,7 @@ The driver comes with client-side representations of the DSE geospatial data typ
 Note: geospatial types require the [ESRI] library version 1.2 to be present on the classpath. The
 DSE driver has a non-optional dependency on that library, but if your application does not use
 geotypes at all, it is possible to exclude it to minimize the number of runtime dependencies (see
-the [Integration>Driver dependencies](../../integration/#driver-dependencies) section for
+the [Integration>Driver dependencies](../../integration/README.md#driver-dependencies) section for
 more details). If the library cannot be found at runtime, geospatial types won't be available and a
 warning will be logged, but the driver will otherwise operate normally (this is also valid for OSGi
 deployments).
diff --git a/manual/core/dse/graph/README.md b/manual/core/dse/graph/README.md
index 6bcacd44c4e..398c01ec4fb 100644
--- a/manual/core/dse/graph/README.md
+++ b/manual/core/dse/graph/README.md
@@ -29,7 +29,7 @@ modeling, refer to the [DSE developer guide].*
 Note: graph capabilities require the [Apache TinkerPop™] library to be present on the classpath. The
 driver has a non-optional dependency on that library, but if your application does not use graph at
 all, it is possible to exclude it to minimize the number of runtime dependencies (see the
-[Integration>Driver dependencies](../../integration/#driver-dependencies) section for more
+[Integration>Driver dependencies](../../integration/README.md#driver-dependencies) section for more
 details). If the library cannot be found at runtime, graph queries won't be available and a warning
 will be logged, but the driver will otherwise operate normally (this is also valid for OSGi
 deployments).
@@ -44,7 +44,7 @@ your application, let the driver pull it transitively.
 There are 3 ways to execute graph requests:
 
 1. Passing a Gremlin script directly in a plain Java string. We'll refer to this as the
-   [script API](script/):
+   [script API](script/README.md):
 
     ```java
     CqlSession session = CqlSession.builder().build();
@@ -61,8 +61,8 @@ There are 3 ways to execute graph requests:
     }
     ```
     
-2. Building a traversal with the [TinkerPop fluent API](fluent/), and [executing it
-   explicitly](fluent/explicit/) with the session:
+2. Building a traversal with the [TinkerPop fluent API](fluent/README.md), and [executing it
+   explicitly](fluent/explicit/README.md) with the session:
    
     ```java
     import static com.datastax.dse.driver.api.core.graph.DseGraph.g;
@@ -77,7 +77,7 @@ There are 3 ways to execute graph requests:
     ```
 
 3. Building a connected traversal with the fluent API, and [executing it
-   implicitly](fluent/implicit/) by invoking a terminal step:
+   implicitly](fluent/implicit/README.md) by invoking a terminal step:
    
     ```java
     GraphTraversalSource g = DseGraph.g
@@ -86,9 +86,9 @@ There are 3 ways to execute graph requests:
     List<Vertex> vertices = g.V().has("name", "marko").toList();
     ```
 
-All executions modes rely on the same set of [configuration options](options/).
+All executions modes rely on the same set of [configuration options](options/README.md).
 
-The script and explicit fluent API return driver-specific [result sets](results/). The implicit
+The script and explicit fluent API return driver-specific [result sets](results/README.md). The implicit
 fluent API returns Apache TinkerPop™ types directly.
 
 [Apache TinkerPop™]: http://tinkerpop.apache.org/
diff --git a/manual/core/dse/graph/fluent/README.md b/manual/core/dse/graph/fluent/README.md
index c1645fdb234..4f824c9b586 100644
--- a/manual/core/dse/graph/fluent/README.md
+++ b/manual/core/dse/graph/fluent/README.md
@@ -34,9 +34,9 @@ GraphTraversal<Vertex, Vertex> traversal = g.V().has("name", "marko");
 
 There are two ways to execute fluent traversals:
 
-* [explicitly](explicit/) by wrapping a traversal into a statement and passing it to
+* [explicitly](explicit/README.md) by wrapping a traversal into a statement and passing it to
   `session.execute`;
-* [implicitly](implicit/) by building the traversal from a connected source, and calling a
+* [implicitly](implicit/README.md) by building the traversal from a connected source, and calling a
   terminal step.
 
 ### Common topics
@@ -52,7 +52,7 @@ fluent API:
 * configuration;
 * DSE graph schema queries.
 
-You'll have to use the [script API](../script) for those use cases.
+You'll have to use the [script API](../script/README.md) for those use cases.
 
 #### Performance considerations
 
diff --git a/manual/core/dse/graph/fluent/explicit/README.md b/manual/core/dse/graph/fluent/explicit/README.md
index 163180a4a8a..caa6048a884 100644
--- a/manual/core/dse/graph/fluent/explicit/README.md
+++ b/manual/core/dse/graph/fluent/explicit/README.md
@@ -42,7 +42,7 @@ for (GraphNode node : result) {
 As shown above, [FluentGraphStatement.newInstance] creates a statement from a traversal directly.
 
 The default implementation returned by the driver is **immutable**; if you call additional methods
-on the statement -- for example to set [options](../../options/) -- each method call will create a
+on the statement -- for example to set [options](../../options/README.md) -- each method call will create a
 new copy:
 
 ```java
@@ -122,7 +122,7 @@ added in a future version.
 
 -----
 
-See also the [parent page](../) for topics common to all fluent traversals. 
+See also the [parent page](../README.md) for topics common to all fluent traversals. 
 
 [FluentGraphStatement]:             https://docs.datastax.com/en/drivers/java/4.17/com/datastax/dse/driver/api/core/graph/FluentGraphStatement.html
 [FluentGraphStatement.newInstance]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/dse/driver/api/core/graph/FluentGraphStatement.html#newInstance-org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal-
diff --git a/manual/core/dse/graph/fluent/implicit/README.md b/manual/core/dse/graph/fluent/implicit/README.md
index f838c376022..dc720f0f7e7 100644
--- a/manual/core/dse/graph/fluent/implicit/README.md
+++ b/manual/core/dse/graph/fluent/implicit/README.md
@@ -42,7 +42,7 @@ completely *detached*: even though they contain the complete data, modifications
 not be reflected on the server side.
 
 Traversal sources with different configurations can easily be created through execution profiles in
-the [configuration](../../../../configuration/):
+the [configuration](../../../../configuration/README.md):
 
 ```
 datastax-java-driver {
@@ -66,6 +66,6 @@ GraphTraversalSource a = AnonymousTraversalSource.traversal().withRemote(
 
 -----
 
-See also the [parent page](../) for topics common to all fluent traversals. 
+See also the [parent page](../README.md) for topics common to all fluent traversals. 
 
 [terminal step]: http://tinkerpop.apache.org/docs/current/reference/#terminal-steps
diff --git a/manual/core/dse/graph/options/README.md b/manual/core/dse/graph/options/README.md
index e4649ff34f3..d47d4ab71ca 100644
--- a/manual/core/dse/graph/options/README.md
+++ b/manual/core/dse/graph/options/README.md
@@ -19,7 +19,7 @@ under the License.
 
 ## Graph options
 
-There are various [configuration](../../../configuration/) options that control the execution of
+There are various [configuration](../../../configuration/README.md) options that control the execution of
 graph statements. They can also be overridden programmatically on individual statements.
 
 ### Setting options
@@ -157,7 +157,7 @@ its own versioning scheme.
 unset by default, and you should almost never have to change it: the driver sets it automatically
 based on the information it knows about the server.
 
-There is one exception: if you use the [script API](../script/) against a legacy DSE version (5.0.3
+There is one exception: if you use the [script API](../script/README.md) against a legacy DSE version (5.0.3
 or older), the driver infers the wrong protocol version. This manifests as a `ClassCastException`
 when you try to deserialize complex result objects, such as vertices:
 
diff --git a/manual/core/dse/graph/results/README.md b/manual/core/dse/graph/results/README.md
index 3b4d25fa012..eb8ac71e3ba 100644
--- a/manual/core/dse/graph/results/README.md
+++ b/manual/core/dse/graph/results/README.md
@@ -19,7 +19,7 @@ under the License.
 
 ## Handling graph results
 
-[Script queries](../script/) and [explicit fluent traversals](../fluent/explicit/) return graph
+[Script queries](../script/README.md) and [explicit fluent traversals](../fluent/explicit/README.md) return graph
 result sets, which are essentially iterables of [GraphNode].
 
 ### Synchronous / asynchronous result
@@ -39,7 +39,7 @@ was executed.
 * `session.executeAsync` returns an [AsyncGraphResultSet]. It only holds the current page of
    results, accessible via the `currentPage()` method. If the query is paged, the next pages must be
    fetched explicitly using the `hasMorePages()` and `fetchNextPage()` methods. See [Asynchronous
-   paging](../../../paging/#asynchronous-paging) for more details about how to work with async
+   paging](../../../paging/README.md#asynchronous-paging) for more details about how to work with async
    types.
 
 *Note: at the time of writing (DSE 6.0), graph queries are never paged. Results are always returned
diff --git a/manual/core/dse/graph/script/README.md b/manual/core/dse/graph/script/README.md
index cec8e4e94ef..70a43e45844 100644
--- a/manual/core/dse/graph/script/README.md
+++ b/manual/core/dse/graph/script/README.md
@@ -38,7 +38,7 @@ As demonstrated above, the simplest way to create a script statement is to pass
 string to [ScriptGraphStatement.newInstance].
 
 The default implementation returned by the driver is **immutable**; if you call additional methods
-on the statement -- for example to set [options](../options/) -- each method call will create a new
+on the statement -- for example to set [options](../options/README.md) -- each method call will create a new
 copy:
 
 ```java
@@ -112,7 +112,7 @@ Alternatively, `withQueryParams` takes multiple parameters as a map.
 
 Building requests as Java strings can be unwieldy, especially for long scripts. Besides, the script
 API is a bit less performant on the server side. Therefore we recommend the
-[Fluent API](../fluent/) instead for graph traversals.
+[Fluent API](../fluent/README.md) instead for graph traversals.
 
 Note however that some types of queries can only be performed through the script API:
 
diff --git a/manual/core/graalvm/README.md b/manual/core/graalvm/README.md
index 5fcaaff9178..b260ac2879f 100644
--- a/manual/core/graalvm/README.md
+++ b/manual/core/graalvm/README.md
@@ -24,14 +24,14 @@ under the License.
 * [GraalVM native images](https://www.graalvm.org/reference-manual/native-image/) can be built with 
   no additional configuration starting with driver 4.13.0.
 * But extra configurations are required in a few cases:
-    * When using [reactive programming](../reactive);
-    * When using [Jackson](../integration#Jackson);
-    * When using LZ4 [compression](../compression/);
-    * Depending on the [logging backend](../logging) in use.
+    * When using [reactive programming](../reactive/README.md);
+    * When using [Jackson](../integration/README.md#jackson);
+    * When using LZ4 [compression](../compression/README.md);
+    * Depending on the [logging backend](../logging/README.md) in use.
 * DSE-specific features:
-    * [Geospatial types](../dse/geotypes) are supported.
-    * [DSE Graph](../dse/graph) is not officially supported, although it may work.
-* The [shaded jar](../shaded_jar) is not officially supported, although it may work.
+    * [Geospatial types](../dse/geotypes/README.md) are supported.
+    * [DSE Graph](../dse/graph/README.md) is not officially supported, although it may work.
+* The [shaded jar](../shaded_jar/README.md) is not officially supported, although it may work.
 
 -----
 
@@ -113,7 +113,7 @@ registered for reflection.
 
 ### Configuration resources 
 
-The default driver [configuration](../configuration) mechanism is based on the TypeSafe Config
+The default driver [configuration](../configuration/README.md) mechanism is based on the TypeSafe Config
 library. TypeSafe Config looks for a few classpath resources when initializing the configuration: 
 `reference.conf`, `application.conf`, `application.json`, `application.properties`. _These classpath 
 resources are all automatically included in the native image: you should not need to do it 
@@ -124,7 +124,7 @@ resources are handled in native images.
 
 ### Configuring the logging backend
 
-When configuring [logging](../logging), the choice of a backend must be considered carefully, as 
+When configuring [logging](../logging/README.md), the choice of a backend must be considered carefully, as 
 most logging backends resort to reflection during their configuration phase. 
 
 By default, GraalVM native images provide support for the java.util.logging (JUL) backend. See 
@@ -135,7 +135,7 @@ native images are supported.
 
 ### Using reactive-style programming
 
-The [reactive execution model](../reactive) is compatible with GraalVM native images, but the
+The [reactive execution model](../reactive/README.md) is compatible with GraalVM native images, but the
 following configurations must be added:
 
 1. Create the following reflection.json file, or add the entry to an existing file:
@@ -151,7 +151,7 @@ following configurations must be added:
 
 ### Using the Jackson JSON library
 
-[Jackson](https://github.com/FasterXML/jackson) is used in [a few places](../integration#jackson) in 
+[Jackson](https://github.com/FasterXML/jackson) is used in [a few places](../integration/README.md#jackson) in 
 the driver, but is an optional dependency; if you intend to use Jackson, the following 
 configurations must be added:
 
@@ -178,7 +178,7 @@ images, see below for more details – replace the above entries with the below
 
 ### Enabling compression
 
-When using [compression](../compression/), only LZ4 can be enabled in native images. **Snappy
+When using [compression](../compression/README.md), only LZ4 can be enabled in native images. **Snappy
 compression is not supported.**
 
 In order for LZ4 compression to work in a native image, the following additional GraalVM
@@ -242,7 +242,7 @@ configuration is required:
 
 ### Native calls
 
-The driver performs a few [native calls](../integration#native-libraries) using 
+The driver performs a few [native calls](../integration/README.md#native-libraries) using 
 [JNR](https://github.com/jnr).
 
 Starting with driver 4.7.0, native calls are also possible in a GraalVM native image, without any
@@ -252,7 +252,7 @@ extra configuration.
 
 #### DSE Geospatial types
 
-DSE [Geospatial types](../dse/geotypes) are supported on GraalVM native images; the following
+DSE [Geospatial types](../dse/geotypes/README.md) are supported on GraalVM native images; the following
 configurations must be added:
 
 1. Create the following reflection.json file, or add the entry to an existing file:
@@ -277,7 +277,7 @@ images, as stated above – replace the above entry with the below one:
 
 #### DSE Graph
 
-**[DSE Graph](../dse/graph) is not officially supported on GraalVM native images.**
+**[DSE Graph](../dse/graph/README.md) is not officially supported on GraalVM native images.**
 
 The following configuration can be used as a starting point for users wishing to build a native
 image for a DSE Graph application. DataStax does not guarantee however that the below configuration
@@ -327,7 +327,7 @@ will work in all cases. If the native image build fails, a good option is to use
 
 ### Using the shaded jar
 
-**The [shaded jar](../shaded_jar) is not officially supported in a GraalVM native image.**
+**The [shaded jar](../shaded_jar/README.md) is not officially supported in a GraalVM native image.**
 
 However, it has been reported that the shaded jar can be included in a GraalVM native image as a
 drop-in replacement for the regular driver jar for simple applications, without any extra GraalVM
diff --git a/manual/core/idempotence/README.md b/manual/core/idempotence/README.md
index be784dfa40b..c350306f4e0 100644
--- a/manual/core/idempotence/README.md
+++ b/manual/core/idempotence/README.md
@@ -39,13 +39,13 @@ For example:
   
 Idempotence matters because the driver sometimes re-runs requests automatically:
 
-* [retries](../retries): if we're waiting for a response from a node and the connection gets
+* [retries](../retries/README.md): if we're waiting for a response from a node and the connection gets
   dropped, the default retry policy automatically retries on another node. But we can't know what
   went wrong with the first node: maybe it went down, or maybe it was just a network issue; in any
   case, it might have applied the changes already. Therefore non-idempotent requests are never
   retried.
 
-* [speculative executions](../speculative_execution): if they are enabled and a node takes too long
+* [speculative executions](../speculative_execution/README.md): if they are enabled and a node takes too long
   to respond, the driver queries another node to get the response faster. But maybe both nodes will
   eventually apply the changes. Therefore non-idempotent requests are never speculatively executed.
 
@@ -63,7 +63,7 @@ SimpleStatement statement =
         .build();
 ```
 
-If you don't, they default to the value defined in the [configuration](../configuration/) by the
+If you don't, they default to the value defined in the [configuration](../configuration/README.md) by the
 `basic.request.default-idempotence` option; out of the box, it is set to `false`.
 
 When you prepare a statement, its idempotence carries over to bound statements:
@@ -77,7 +77,7 @@ assert bs.isIdempotent();
 ```
 
 The query builder tries to infer idempotence automatically; refer to
-[its manual](../../query_builder/idempotence/) for more details.
+[its manual](../../query_builder/idempotence/README.md) for more details.
 
 [Statement.setIdempotent]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/cql/Statement.html#setIdempotent-java.lang.Boolean-
 [StatementBuilder.setIdempotence]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/cql/StatementBuilder.html#setIdempotence-java.lang.Boolean-
diff --git a/manual/core/integration/README.md b/manual/core/integration/README.md
index e2c7bc218ee..8279ace8be3 100644
--- a/manual/core/integration/README.md
+++ b/manual/core/integration/README.md
@@ -25,7 +25,7 @@ under the License.
 * explanations about [driver dependencies](#driver-dependencies) and when they can be manually
   excluded.
 
-Note: guidelines to build a GraalVM native image can be found [here](../graalvm).
+Note: guidelines to build a GraalVM native image can be found [here](../graalvm/README.md).
 
 -----
 
@@ -177,7 +177,7 @@ dependencies, and tell Maven that we're going to use Java 8:
 ##### Application configuration
 
 `application.conf` is not stricly necessary, but it illustrates an important point about the
-driver's [configuration](../configuration/): you override any of the driver's default options here.
+driver's [configuration](../configuration/README.md): you override any of the driver's default options here.
 
 ```
 datastax-java-driver {
@@ -189,7 +189,7 @@ In this case, we just specify a custom name for our session, it will appear in t
 
 ##### Logging configuration
 
-For this example, we choose Logback as our [logging framework](../logging/) (we added the dependency
+For this example, we choose Logback as our [logging framework](../logging/README.md) (we added the dependency
 in `pom.xml`). `logback.xml` configures it to send the driver's `INFO` logs to the console.
 
 ```xml
@@ -211,7 +211,7 @@ dependency, or this file; but the default behavior is a bit verbose.
 
 ##### Main class
 
-`Main.java` is the canonical example introduced in our [quick start](../#quick-start); it connects
+`Main.java` is the canonical example introduced in our [quick start](../README.md#quick-start); it connects
 to Cassandra, queries the server version and prints it:
 
 ```java
@@ -357,17 +357,17 @@ Here's a rundown of what you can customize:
 
 [Netty](https://netty.io/) is the NIO framework that powers the driver's networking layer.
 
-It is a required dependency, but we provide a a [shaded JAR](../shaded_jar/) that relocates it to a
+It is a required dependency, but we provide a a [shaded JAR](../shaded_jar/README.md) that relocates it to a
 different Java package; this is useful to avoid dependency hell if you already use Netty in another
 part of your application.
 
 #### Typesafe config
 
 [Typesafe config](https://lightbend.github.io/config/) is used for our file-based
-[configuration](../configuration/).
+[configuration](../configuration/README.md).
 
 It is a required dependency if you use the driver's built-in configuration loader, but this can be
-[completely overridden](../configuration/#bypassing-typesafe-config) with your own implementation,
+[completely overridden](../configuration/README.md#bypassing-typesafe-config) with your own implementation,
 that could use a different framework or an ad-hoc solution.
 
 In that case, you can exclude the dependency:
@@ -390,7 +390,7 @@ In that case, you can exclude the dependency:
 
 The driver performs native calls with [JNR](https://github.com/jnr). This is used in two cases:
 
-* to access a microsecond-precision clock in [timestamp generators](../query_timestamps/);
+* to access a microsecond-precision clock in [timestamp generators](../query_timestamps/README.md);
 * to get the process ID when generating [UUIDs][Uuids].
 
 In both cases, this is completely optional; if system calls are not available on the current
@@ -420,11 +420,11 @@ The driver supports compression with either [LZ4](https://github.com/yawkat/lz4-
 [Snappy](http://google.github.io/snappy/).
 
 These dependencies are optional; you have to add them explicitly in your application in order to
-enable compression. See the [Compression](../compression/) page for more details.
+enable compression. See the [Compression](../compression/README.md) page for more details.
 
 #### Metrics
 
-The driver exposes [metrics](../metrics/) through the
+The driver exposes [metrics](../metrics/README.md) through the
 [Dropwizard](http://metrics.dropwizard.io/4.1.2/) library.
 
 The dependency is declared as required, but metrics are optional. If you've disabled all metrics, or
@@ -449,7 +449,7 @@ In addition, when using Dropwizard, "timer" metrics use
 [HdrHistogram](http://hdrhistogram.github.io/HdrHistogram/) to record latency percentiles. At the
 time of writing, these metrics are: `cql-requests`, `throttling.delay` and `cql-messages`; you can
 also identify them by reading the comments in the [configuration
-reference](../configuration/reference/) (look for "exposed as a Timer").
+reference](../configuration/reference/README.md) (look for "exposed as a Timer").
 
 If all of these metrics are disabled, or if you use a different metrics library, you can remove the
 dependency:
@@ -472,9 +472,9 @@ dependency:
 
 [Jackson](https://github.com/FasterXML/jackson) is used:
 
-* when connecting to [DataStax Astra](../../cloud/);
+* when connecting to [DataStax Astra](../../cloud/README.md);
 * when Insights monitoring is enabled;
-* when [Json codecs](../custom_codecs) are being used. 
+* when [Json codecs](../custom_codecs/README.md) are being used. 
  
 Jackson is declared as a required dependency, but the driver can operate normally without it. If you
 don't use any of the above features, you can safely exclude the dependency:
@@ -495,7 +495,7 @@ don't use any of the above features, you can safely exclude the dependency:
 
 #### Esri
 
-Our [geospatial types](../dse/geotypes/) implementation is based on the [Esri Geometry
+Our [geospatial types](../dse/geotypes/README.md) implementation is based on the [Esri Geometry
 API](https://github.com/Esri/geometry-api-java).
 
 For driver versions >= 4.4.0 and < 4.14.0 Esri is declared as a required dependency,
@@ -534,7 +534,7 @@ guaranteed to be fully compatible with DSE.
 
 #### TinkerPop
 
-[Apache TinkerPop™](http://tinkerpop.apache.org/) is used in our [graph API](../dse/graph/),
+[Apache TinkerPop™](http://tinkerpop.apache.org/) is used in our [graph API](../dse/graph/README.md),
 introduced in the OSS driver in version 4.4.0 (it was previously a feature only available in the
 now-retired DSE driver).
 
@@ -601,7 +601,7 @@ Here are the recommended TinkerPop versions for each driver version:
 #### Reactive Streams
 
 [Reactive Streams](https://www.reactive-streams.org/) types are referenced in our [reactive
-API](../reactive/).
+API](../reactive/README.md).
 
 The Reactive Streams API is declared as a required dependency, but the driver can operate normally
 without it. If you never call any of the `executeReactive` methods, you can exclude the dependency:
@@ -674,7 +674,7 @@ The remaining core driver dependencies are the only ones that are truly mandator
 * `java-driver-guava-shaded`, a shaded version of [Guava](https://github.com/google/guava). It is
   relocated to a different package, and only used by internal driver code, so it should be
   completely transparent to third-party code;
-* the [SLF4J](https://www.slf4j.org/) API for [logging](../logging/).
+* the [SLF4J](https://www.slf4j.org/) API for [logging](../logging/README.md).
 
 [central_oss]: https://search.maven.org/#search%7Cga%7C1%7Ccom.datastax.oss
 [maven_pom]: https://maven.apache.org/guides/introduction/introduction-to-the-pom.html
diff --git a/manual/core/load_balancing/README.md b/manual/core/load_balancing/README.md
index 3f391c14f56..aea950e4e9d 100644
--- a/manual/core/load_balancing/README.md
+++ b/manual/core/load_balancing/README.md
@@ -35,7 +35,7 @@ abbreviated LBP) is a central component that determines:
 * which nodes the driver will communicate with;
 * for each new query, which coordinator to pick, and which nodes to use as failover.
 
-It is defined in the [configuration](../configuration/):
+It is defined in the [configuration](../configuration/README.md):
 
 ```
 datastax-java-driver.basic.load-balancing-policy {
@@ -50,7 +50,7 @@ datastax-java-driver.basic.load-balancing-policy {
 For each node, the policy computes a *distance* that determines how connections will be established:
 
 * `LOCAL` and `REMOTE` are "active" distances, meaning that the driver will keep open connections to
-  this node. [Connection pools](../pooling/) can be sized independently for each distance.
+  this node. [Connection pools](../pooling/README.md) can be sized independently for each distance.
 * `IGNORED` means that the driver will never attempt to connect.
 
 Typically, the distance will reflect network topology (e.g. local vs. remote datacenter), although
@@ -63,7 +63,7 @@ datacenter traffic (see below to understand how to change this behavior).
 
 Each time the driver executes a query, it asks the policy to compute a *query plan*, in other words
 a list of nodes. The driver then tries each node in sequence, moving down the plan according to the
-[retry policy](../retries/) and [speculative execution policy](../speculative_execution/).
+[retry policy](../retries/README.md) and [speculative execution policy](../speculative_execution/README.md).
 
 The contents and order of query plans are entirely implementation-specific, but policies typically
 return plans that:
@@ -225,7 +225,7 @@ this option to any value greater than zero will have the following effects:
 - The load balancing policies will assign the `REMOTE` distance to that many nodes *in each remote
   datacenter*.
 - The driver will then attempt to open connections to those nodes. The actual number of connections
-  to open to each one of those nodes is configurable, see [Connection pools](../pooling/) for
+  to open to each one of those nodes is configurable, see [Connection pools](../pooling/README.md) for
   more details. By default, the driver opens only one connection to each node.
 - Those remote nodes (and only those) will then become eligible for inclusion in query plans,
   effectively enabling cross-datacenter failover.
@@ -280,11 +280,11 @@ replicas that own the data being queried.
 
 ##### Providing routing information
 
-First make sure that [token metadata](../metadata/token/#configuration) is enabled.
+First make sure that [token metadata](../metadata/token/README.md#configuration) is enabled.
 
 Then your statements need to provide:
 
-* a keyspace: if you use a [per-query keyspace](../statements/per_query_keyspace/), then it will be
+* a keyspace: if you use a [per-query keyspace](../statements/per_query_keyspace/README.md), then it will be
   used for routing as well. Otherwise, the driver relies on [getRoutingKeyspace()];
 * a routing key: it can be provided either by [getRoutingKey()] \(raw binary data) or
   [getRoutingToken()] \(already hashed as a token).
@@ -297,7 +297,7 @@ CREATE TABLE testKs.sensor_data(id int, year int, ts timestamp, data double,
                                 PRIMARY KEY ((id, year), ts));
 ```
 
-For [simple statements](../statements/simple/), routing information is never computed
+For [simple statements](../statements/simple/README.md), routing information is never computed
 automatically:
 
 ```java
@@ -320,7 +320,7 @@ statement = statement.setRoutingKey(
 session.execute(statement);
 ```
 
-For [bound statements](../statements/prepared/), the keyspace is always available; the routing key
+For [bound statements](../statements/prepared/README.md), the keyspace is always available; the routing key
 is only available if all components of the partition key are bound as variables:
 
 ```java
@@ -341,7 +341,7 @@ assert statement2.getRoutingKeyspace() != null;
 assert statement2.getRoutingKey() == null;
 ```
 
-For [batch statements](../statements/batch/), the routing information of each child statement is
+For [batch statements](../statements/batch/README.md), the routing information of each child statement is
 inspected; the first non-null keyspace is used as the keyspace of the batch, and the first non-null
 routing key as its routing key (the idea is that all children should have the same routing
 information, since batches are supposed to operate on a single partition). If no child has any
@@ -410,7 +410,7 @@ that you wish to modify – but keep in mind that it may be simpler to just star
 
 ### Using multiple policies
 
-The load balancing policy can be overridden in [execution profiles](../configuration/#profiles):
+The load balancing policy can be overridden in [execution profiles](../configuration/README.md#execution-profiles):
 
 ```
 datastax-java-driver {
diff --git a/manual/core/logging/README.md b/manual/core/logging/README.md
index e3f8bfa7777..d3428b3ee6b 100644
--- a/manual/core/logging/README.md
+++ b/manual/core/logging/README.md
@@ -25,7 +25,7 @@ under the License.
 * config file examples for Logback and Log4J. 
 
 **If you're looking for information about the request logger, see the [request
-tracker](../request_tracker/#request-logger) page.**
+tracker](../request_tracker/README.md#request-logger) page.**
 
 -----
 
diff --git a/manual/core/metadata/README.md b/manual/core/metadata/README.md
index 73609ee0542..2a456f31108 100644
--- a/manual/core/metadata/README.md
+++ b/manual/core/metadata/README.md
@@ -33,9 +33,9 @@ under the License.
 The driver exposes metadata about the Cassandra cluster via the [Session#getMetadata] method. It
 returns a [Metadata] object, which contains three types of information:
 
-* [node metadata](node/)
-* [schema metadata](schema/)
-* [token metadata](token/)
+* [node metadata](node/README.md)
+* [schema metadata](schema/README.md)
+* [token metadata](token/README.md)
 
 Metadata is mostly **immutable** (except for the fields of the [Node] class, see the "node metadata"
 link above for details). Each call to `getMetadata()` will return a **new copy** if something has
@@ -73,7 +73,7 @@ This is a big improvement over previous versions of the driver, where it was pos
 new keyspace in the schema metadata before the token metadata was updated.
 
 Schema and node state events are debounced. This allows you to control how often the metadata gets
-refreshed. See the [Performance](../performance/#debouncing) page for more details.
+refreshed. See the [Performance](../performance/README.md#debouncing) page for more details.
 
 [Session#getMetadata]:                          https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/session/Session.html#getMetadata--
 [Metadata]:                                     https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/metadata/Metadata.html
diff --git a/manual/core/metadata/node/README.md b/manual/core/metadata/node/README.md
index fea04e5f262..7583a370dc5 100644
--- a/manual/core/metadata/node/README.md
+++ b/manual/core/metadata/node/README.md
@@ -134,7 +134,7 @@ context.getEventBus().fire(TopologyEvent.forceUp(node1.getConnectAddress()));
 
 As shown by the imports above, forcing a node down requires the *internal* driver API, which is 
 reserved for expert usage and subject to the disclaimers in
-[API conventions](../../../api_conventions/).
+[API conventions](../../../api_conventions/README.md).
 
 #### Using a custom topology monitor
 
diff --git a/manual/core/metadata/schema/README.md b/manual/core/metadata/schema/README.md
index 20521d1def4..9a5d9bb6125 100644
--- a/manual/core/metadata/schema/README.md
+++ b/manual/core/metadata/schema/README.md
@@ -48,7 +48,7 @@ for (TableMetadata table : system.getTables().values()) {
 
 Schema metadata is fully immutable (both the map and all the objects it contains). It represents a
 snapshot of the database at the time of the last metadata refresh, and is consistent with the
-[token map](../token/) of its parent `Metadata` object. Keep in mind that `Metadata` is itself
+[token map](../token/README.md) of its parent `Metadata` object. Keep in mind that `Metadata` is itself
 immutable; if you need to get the latest schema, be sure to call
 `session.getMetadata().getKeyspaces()` again (and not just `getKeyspaces()` on a stale `Metadata`
 reference).
@@ -207,7 +207,7 @@ a few filters:
 If an element is malformed, or if its regex has a syntax error, a warning is logged and that single
 element is ignored.
 
-The default configuration (see [reference.conf](../../configuration/reference/)) excludes all
+The default configuration (see [reference.conf](../../configuration/reference/README.md)) excludes all
 Cassandra and DSE system keyspaces.
 
 Try to use only exact name inclusions if possible. This allows the driver to filter on the server
@@ -331,14 +331,14 @@ changes at the same time.
 
 ### Relation to token metadata
 
-Some of the data in the [token map](../token/) relies on keyspace metadata (any method that takes a
+Some of the data in the [token map](../token/README.md) relies on keyspace metadata (any method that takes a
 `CqlIdentifier` argument). If schema metadata is disabled or filtered, token metadata will also be
 unavailable for the excluded keyspaces.
 
 ### Performing schema updates from the client
 
 If you issue schema-altering requests from the driver (e.g. `session.execute("CREATE TABLE ..")`),
-take a look at the [Performance](../../performance/#schema-updates) page for a few tips.
+take a look at the [Performance](../../performance/README.md#schema-updates) page for a few tips.
 
 [Metadata#getKeyspaces]:             https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/metadata/Metadata.html#getKeyspaces--
 [SchemaChangeListener]:              https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/metadata/schema/SchemaChangeListener.html
diff --git a/manual/core/metadata/token/README.md b/manual/core/metadata/token/README.md
index 4d7cd9252df..165a7fd5c6b 100644
--- a/manual/core/metadata/token/README.md
+++ b/manual/core/metadata/token/README.md
@@ -184,7 +184,7 @@ keep the value of the last refresh, and token-aware routing might operate on sta
 #### Relation to schema metadata
 
 The keyspace-specific information in `TokenMap` (all methods with a `CqlIdentifier` argument) relies
-on [schema metadata](../schema/). If schema metadata is disabled or filtered, token metadata will
+on [schema metadata](../schema/README.md). If schema metadata is disabled or filtered, token metadata will
 also be unavailable for the excluded keyspaces.
 
 
diff --git a/manual/core/metrics/README.md b/manual/core/metrics/README.md
index ef5d9b453f0..7ebb793fd33 100644
--- a/manual/core/metrics/README.md
+++ b/manual/core/metrics/README.md
@@ -365,4 +365,4 @@ CSV files, SLF4J logs and Graphite. Refer to their [manual][Dropwizard manual] f
 [Micrometer Metrics]: https://micrometer.io/docs
 [Micrometer JMX]: https://micrometer.io/docs/registry/jmx
 [MicroProfile Metrics]: https://github.com/eclipse/microprofile-metrics
-[reference configuration]: ../configuration/reference/
+[reference configuration]: ../configuration/reference/README.md
diff --git a/manual/core/native_protocol/README.md b/manual/core/native_protocol/README.md
index 42146e63f42..b1c7422a669 100644
--- a/manual/core/native_protocol/README.md
+++ b/manual/core/native_protocol/README.md
@@ -73,7 +73,7 @@ ProtocolVersion currentVersion = session.getContext().getProtocolVersion();
 ```
 
 The protocol version cannot be changed at runtime. However, you can force a particular version in
-the [configuration](../configuration/):
+the [configuration](../configuration/README.md):
 
 ```
 datastax-java-driver {
@@ -117,7 +117,7 @@ force the protocol version manually anymore.
 
 ### Debugging protocol negotiation
 
-You can observe the negotiation process in the [logs](../logging/).
+You can observe the negotiation process in the [logs](../logging/README.md).
  
 The versions tried while negotiating with the first node are logged at level `DEBUG` in the category
 `com.datastax.oss.driver.internal.core.channel.ChannelFactory`:
@@ -142,13 +142,13 @@ If you want to see the details of mixed cluster negotiation, enable `DEBUG` leve
 #### v3 to v4
 
 * [query warnings][ExecutionInfo.getWarnings]
-* [unset values in bound statements](../statements/prepared/#unset-values)
+* [unset values in bound statements](../statements/prepared/README.md#unset-values)
 * [custom payloads][Request.getCustomPayload]
 
 #### v4 to v5
 
-* [per-query keyspace](../statements/per_query_keyspace)
-* [improved prepared statement resilience](../statements/prepared/#prepared-statements-and-schema-changes)
+* [per-query keyspace](../statements/per_query_keyspace/README.md)
+* [improved prepared statement resilience](../statements/prepared/README.md#prepared-statements-and-schema-changes)
   in the face of schema changes
 
 [protocol spec]: https://github.com/datastax/native-protocol/tree/1.x/src/main/resources
diff --git a/manual/core/non_blocking/README.md b/manual/core/non_blocking/README.md
index f320ffd13d2..7498b3222ba 100644
--- a/manual/core/non_blocking/README.md
+++ b/manual/core/non_blocking/README.md
@@ -37,7 +37,7 @@ These guarantees and their exceptions are detailed below. A final chapter explai
 driver with BlockHound.
 
 The developer guide also has more information on driver internals and its 
-[concurrency model](../../developer/common/concurrency).
+[concurrency model](../../developer/common/concurrency/README.md).
 
 ### Definition of "non-blocking"
 
@@ -61,8 +61,8 @@ The driver offers many execution models. For the built-in ones, the lock-free gu
 follows:
 
 * The synchronous API is blocking and does not offer any lock-free guarantee.
-* The [asynchronous](../async) API is implemented in lock-free algorithms.
-* The [reactive](../reactive) API is implemented in lock-free algorithms (it's actually wait-free).
+* The [asynchronous](../async/README.md) API is implemented in lock-free algorithms.
+* The [reactive](../reactive/README.md) API is implemented in lock-free algorithms (it's actually wait-free).
 
 For example, calling any synchronous method declared in [`SyncCqlSession`], such as [`execute`], 
 will block until the result is available. These methods should never be used in non-blocking 
@@ -119,7 +119,7 @@ thread, and partially asynchronously on an internal driver thread.
   the driver admin thread performing the initialization tasks must be allowed to block, at least
   temporarily.
 
-[driver context]: ../../developer/common/context
+[driver context]: ../../developer/common/context/README.md
 
 For the reasons above, the initialization phase obviously doesn't qualify as lock-free. For 
 non-blocking applications, it is generally advised to trigger session initialization during 
@@ -155,7 +155,7 @@ should not be used if strict lock-freedom is enforced.
 The `RateLimitingRequestThrottler` is currently blocking. The `ConcurrencyLimitingRequestThrottler`
 is lock-free.
 
-See the section about [throttling](../throttling) for details about these components. Depending on
+See the section about [throttling](../throttling/README.md) for details about these components. Depending on
 how many requests are being executed in parallel, the thread contention on these locks can be high:
 in short, if your application enforces strict lock-freedom, then you should not use the
 `RateLimitingRequestThrottler`.
@@ -182,12 +182,12 @@ this reason, it is advised that this method be called once during application st
 safe to use it afterwards in a non-blocking context.
 
 Alternatively, it's possible to disable the usage of client-side timestamp generation, and/or the
-usage of native libraries. See the manual sections on [query timestamps](../query_timestamps) and 
-[integration](../integration) for more information.
+usage of native libraries. See the manual sections on [query timestamps](../query_timestamps/README.md) and 
+[integration](../integration/README.md) for more information.
 
 One component, the codec registry, can block when its [`register`] method is called; it is 
 therefore advised that codecs should be registered during application startup exclusively. See the
-[custom codecs](../custom_codecs) section for more details about registering codecs.
+[custom codecs](../custom_codecs/README.md) section for more details about registering codecs.
 
 [`register`]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/type/codec/registry/MutableCodecRegistry.html#register-com.datastax.oss.driver.api.core.type.codec.TypeCodec-
 
@@ -243,7 +243,7 @@ Beware that a hot-reloading of the default configuration mechanism is performed
 admin thread. If hot-reloading is enabled, then this might be reported by lock-freedom infringement 
 detectors. If that is the case, it is advised to disable hot-reloading by setting the 
 `datastax-java-driver.basic.config-reload-interval` option to 0. See the manual page on 
-[configuration](../configuration) for more information.
+[configuration](../configuration/README.md) for more information.
 
 [`DriverConfigLoader`]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/config/DriverConfigLoader.html
 [hot-reloading]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/config/DriverConfigLoader.html#supportsReloading--
@@ -264,8 +264,8 @@ The driver has its own mechanism for detecting blocking calls happening on an in
 thread. This mechanism is capable of detecting and reporting blatant cases of misuse of the 
 asynchronous and reactive APIs, e.g. when the synchronous API is invoked inside a future or callback
 produced by the asynchronous execution of a statement. See the core manual page on the 
-[asynchronous](../async) API or the developer manual page on 
-[driver concurrency](../../developer/common/concurrency) for details.
+[asynchronous](../async/README.md) API or the developer manual page on 
+[driver concurrency](../../developer/common/concurrency/README.md) for details.
 
 The driver is not capable, however, of detecting low-level lock-freedom infringements, such as the
 usage of locks. You must use an external tool to achieve that. See below how to use BlockHound for 
diff --git a/manual/core/paging/README.md b/manual/core/paging/README.md
index 2df92bd69d1..c5f445ef311 100644
--- a/manual/core/paging/README.md
+++ b/manual/core/paging/README.md
@@ -50,7 +50,7 @@ datastax-java-driver.basic.request.page-size = 5000
 
 It can be changed at runtime (the new value will be used for requests issued after the change). If
 you have categories of queries that require different page sizes, use
-[configuration profiles](../configuration#profiles).
+[configuration profiles](../configuration/README.md#execution-profiles).
 
 Note that the page size is merely a hint; the server will not always return the exact number of
 rows, it might decide to return slightly more or less.
@@ -153,7 +153,7 @@ private CompletionStage<Integer> countRows(AsyncResultSet resultSet, int previou
 }
 ```
 
-See [Asynchronous programming](../async/) for more tips about the async API.
+See [Asynchronous programming](../async/README.md) for more tips about the async API.
 
 ### Saving and reusing the paging state
 
@@ -199,7 +199,7 @@ to reinject it in the wrong statement. This allows you to detect the error early
 roundtrip to the server.
 
 Note that, if you use a simple statement and one of the bound values requires a [custom
-codec](../custom_codecs), you have to provide a reference to the session when reinjecting the paging
+codec](../custom_codecs/README.md), you have to provide a reference to the session when reinjecting the paging
 state:
 
 ```java
@@ -249,7 +249,7 @@ rs = session.execute(query);
 OffsetPager.Page<Row> page5 = pager.getPage(rs, 5);
 ```
 
-Note that `getPage` can also process the entity iterables returned by the [mapper](../../mapper/).
+Note that `getPage` can also process the entity iterables returned by the [mapper](../../mapper/README.md).
 
 #### Establishing application-level guardrails
 
diff --git a/manual/core/performance/README.md b/manual/core/performance/README.md
index 3afb321968e..97a892e6b89 100644
--- a/manual/core/performance/README.md
+++ b/manual/core/performance/README.md
@@ -26,7 +26,7 @@ easy reference if you're benchmarking your application or diagnosing performance
 
 ### Statements
 
-[Statements](../statements/) are some of the driver types you'll use the most. Every request needs
+[Statements](../statements/README.md) are some of the driver types you'll use the most. Every request needs
 one -- even `session.execute(String)` creates a `SimpleStatement` under the hood.
 
 #### Immutability and builders
@@ -47,7 +47,7 @@ initialized statically and stored as constants.
 
 #### Prepared statements
 
-[Prepared statements](../statements/prepared) allow Cassandra to cache parsed query strings
+[Prepared statements](../statements/prepared/README.md) allow Cassandra to cache parsed query strings
 server-side, but that's not their only benefit for performance:
 
 * the driver also caches the response metadata, which can then be skipped in subsequent responses.
@@ -91,34 +91,34 @@ By default, the driver opens 1 connection per node, and allows 1024 concurrent r
 connection. In our experience this is enough for most scenarios. 
 
 If your application generates a very high throughput (hundreds of thousands of requests per second), 
-you might want to experiment with different settings. See the [tuning](../pooling/#tuning) section
+you might want to experiment with different settings. See the [tuning](../pooling/README.md#tuning) section
 in the connection pooling page.
 
 #### Compression
 
-Consider [compression](../compression/) if your queries return large payloads; it might help to
+Consider [compression](../compression/README.md) if your queries return large payloads; it might help to
 reduce network traffic.
 
 #### Timestamp generation
 
-Each query is assigned a [timestamp](../query_timestamps/) to order them relative to each other.
+Each query is assigned a [timestamp](../query_timestamps/README.md) to order them relative to each other.
 
 By default, this is done driver-side with
-[AtomicTimestampGenerator](../query_timestamps/#atomic-timestamp-generator). This is a very simple
+[AtomicTimestampGenerator](../query_timestamps/README.md#atomictimestampgenerator). This is a very simple
 operation so unlikely to be a bottleneck, but note that there are other options, such as a
-[thread-local](../query_timestamps/#thread-local-timestamp-generator) variant that creates slightly
+[thread-local](../query_timestamps/README.md#threadlocaltimestampgenerator) variant that creates slightly
 less contention, writing your own implementation or letting the server assign timestamps.
 
 #### Tracing
 
-[Tracing](../tracing/) should be used for only a small percentage of your queries. It consumes
+[Tracing](../tracing/README.md) should be used for only a small percentage of your queries. It consumes
 additional resources on the server, and fetching each trace requires background requests.
 
 Do not enable tracing for every request; it's a sure way to bring your performance down.
 
 #### Request trackers
 
-[Request trackers](../request_tracker/) are on the hot path (that is, invoked on I/O threads, each
+[Request trackers](../request_tracker/README.md) are on the hot path (that is, invoked on I/O threads, each
 time a request is executed), and users can plug custom implementations.
 
 If you experience throughput issues, check if any trackers are configured, and what they are doing.
@@ -126,7 +126,7 @@ They should avoid blocking calls, as well as any CPU-intensive computations.
 
 #### Metrics
 
-Similarly, some of the driver's [metrics](../metrics/) are updated for every request (if the metric
+Similarly, some of the driver's [metrics](../metrics/README.md) are updated for every request (if the metric
 is enabled).
 
 By default, the driver ships with all metrics disabled. Enable them conservatively, and if you're
@@ -135,7 +135,7 @@ cause.
 
 #### Throttling
 
-[Throttling](../throttling/) can help establish more predictable server performance, by controlling
+[Throttling](../throttling/README.md) can help establish more predictable server performance, by controlling
 how much load each driver instance is allowed to put on the cluster. The throttling algorithm itself
 incurs a bit of overhead in the driver, but that shouldn't be a problem since the goal is to stay
 under reasonable rates in the first place.
@@ -151,7 +151,7 @@ private fields or constants to alleviate GC pressure.
 
 #### Identifiers
 
-The driver uses [CqlIdentifier] to deal with [case sensitivity](../../case_sensitivity). When you
+The driver uses [CqlIdentifier] to deal with [case sensitivity](../../case_sensitivity/README.md). When you
 call methods that take raw strings, the driver generally wraps them under the hood:
 
 ```java
@@ -182,7 +182,7 @@ pst.bind().setInt("age", 25);
 #### Type tokens
 
 [GenericType] is used to express complex generic types -- such as
-[nested collections](../#collection-types) -- in getters and setters. These objects are immutable
+[nested collections](../README.md#collection-types) -- in getters and setters. These objects are immutable
 and stateless, so they are good candidates for constants:
 
 ```java
@@ -196,7 +196,7 @@ to store yours.
 
 #### Built queries
 
-Similarly, [built queries](../../query_builder/) are immutable and don't need a reference to a live
+Similarly, [built queries](../../query_builder/README.md) are immutable and don't need a reference to a live
 driver instance. If you create them statically, they can be stored as constants:
 
 ```java
@@ -209,7 +209,7 @@ already happens at initialization time.
 
 #### Derived configuration profiles
 
-The configuration API allows you to build [derived profiles](../configuration/#derived-profiles) at
+The configuration API allows you to build [derived profiles](../configuration/README.md#derived-profiles) at
 runtime.
 
 ```java
@@ -224,7 +224,7 @@ of recreating them each time.
 
 ### Metadata
 
-The driver maintains [metadata](../metadata/) about the state of the Cassandra cluster. This work is
+The driver maintains [metadata](../metadata/README.md) about the state of the Cassandra cluster. This work is
 done on dedicated "admin" threads (see the [thread pooling](#thread-pooling) section below), so it's
 not in direct competition with regular requests. 
 
@@ -245,12 +245,12 @@ This will save CPU and memory resources, but you lose some driver features:
 * if schema is disabled, `session.getMetadata().getKeyspaces()` will always be empty: your
   application won't be able to inspect the database schema dynamically.
 * if the token map is disabled, `session.getMetadata().getTokenMap()` will always be empty, and you
-  lose the ability to use [token-aware routing](../load_balancing/#token-aware).
+  lose the ability to use [token-aware routing](../load_balancing/README.md#token-aware).
 
 Note that disabling the schema implicitly disables the token map (because computing the token map
 requires the keyspace replication settings).
 
-Perhaps more interestingly, metadata can be [filtered](../metadata/schema/#filtering) to a specific
+Perhaps more interestingly, metadata can be [filtered](../metadata/schema/README.md#filtering) to a specific
 subset of keyspaces. This is handy if you connect to a shared cluster that holds data for multiple
 applications:
 
@@ -260,7 +260,7 @@ datastax-java-driver.advanced.metadata {
 }
 ```
 
-To get a sense of the time spent on metadata refreshes, enable [debug logs](../logging/) and look
+To get a sense of the time spent on metadata refreshes, enable [debug logs](../logging/README.md) and look
 for entries like this:
 
 ```
@@ -319,7 +319,7 @@ You should group your schema changes as much as possible.
 
 Every change made from a client will be pushed to all other clients, causing them to refresh their
 metadata. If you have multiple client instances, it might be a good idea to
-[deactivate the metadata](../metadata/schema/#enabling-disabling) on all clients while you apply the
+[deactivate the metadata](../metadata/schema/README.md#enablingdisabling) on all clients while you apply the
 updates, and reactivate it at the end (reactivating will trigger an immediate refresh, so you might
 want to ramp up clients to avoid a "thundering herd" effect).
 
@@ -327,7 +327,7 @@ Schema changes have to replicate to all nodes in the cluster. To minimize the ch
 disagreement errors:
 
 * apply your changes serially. The driver handles this automatically by checking for
-  [schema agreement](../metadata/schema/#schema-agreement) after each DDL query. Run them from the
+  [schema agreement](../metadata/schema/README.md#schema-agreement) after each DDL query. Run them from the
   same application thread, and, if you use the asynchronous API, chain the futures properly.
 * send all the changes to the same coordinator. This is one of the rare cases where we recommend
   using [Statement.setNode()].  
@@ -346,7 +346,7 @@ The driver architecture is designed around two code paths:
     * the driver's "timer" thread for request timeouts and speculative executions. See
       `datastax-java-driver.advanced.netty.timer`.
 * the **cold path** is for all administrative tasks: managing the
-  [control connection](../control_connection), parsing [metadata](../metadata/), reacting to cluster
+  [control connection](../control_connection/README.md), parsing [metadata](../metadata/README.md), reacting to cluster
   events (node going up/down, getting added/removed, etc), and scheduling periodic events
   (reconnections, reloading the configuration). Comparatively, these tasks happen less often, and
   are less critical (for example, stale schema metadata is not a blocker for request execution).
@@ -359,7 +359,7 @@ every case is different, but you might want to try lowering I/O threads, especia
 application already creates a lot of threads on its side. 
 
 Note that you can gain more fine-grained control over thread pools via the
-[internal](../../api_conventions) API (look at the `NettyOptions` interface). In particular, it is
+[internal](../../api_conventions/README.md) API (look at the `NettyOptions` interface). In particular, it is
 possible to reuse the same event loop group for I/O, admin tasks, and even your application code
 (the driver's internal code is fully asynchronous so it will never block any thread). The timer is
 the only one that will have to stay on a separate thread.
diff --git a/manual/core/pooling/README.md b/manual/core/pooling/README.md
index 578de6b4abd..423b4e3433f 100644
--- a/manual/core/pooling/README.md
+++ b/manual/core/pooling/README.md
@@ -52,7 +52,7 @@ You don't need to manage connections yourself. You simply interact with a [CqlSe
 takes care of it.
 
 **For a given session, there is one connection pool per connected node** (a node is connected when
-it is up and not ignored by the [load balancing policy](../load_balancing/)).
+it is up and not ignored by the [load balancing policy](../load_balancing/README.md)).
 
 The number of connections per pool is configurable (this will be described in the next section).
 There are up to 32768 stream ids per connection.
@@ -65,7 +65,7 @@ There are up to 32768 stream ids per connection.
 
 ### Configuration
 
-Pool sizes are defined in the `connection` section of the [configuration](../configuration/). Here
+Pool sizes are defined in the `connection` section of the [configuration](../configuration/README.md). Here
 are the relevant options with their default values:
 
 ```
@@ -112,7 +112,7 @@ the change.
 
 ### Monitoring
 
-The driver exposes node-level [metrics](../metrics/) to monitor your pools (note that all metrics
+The driver exposes node-level [metrics](../metrics/README.md) to monitor your pools (note that all metrics
 are disabled by default, you'll need to change your configuration to enable them):
 
 ```
@@ -166,7 +166,7 @@ improvement: the server is only going to service so many requests at a time anyw
 requests are just going to pile up.
 
 Lowering the value is not a good idea either. If your goal is to limit the global throughput of the
-driver, a [throttler](../throttling) is a better solution.
+driver, a [throttler](../throttling/README.md) is a better solution.
 
 #### Number of connections per node 
 
diff --git a/manual/core/query_timestamps/README.md b/manual/core/query_timestamps/README.md
index 4498afe21c4..f2d2e5c2daa 100644
--- a/manual/core/query_timestamps/README.md
+++ b/manual/core/query_timestamps/README.md
@@ -51,7 +51,7 @@ session.execute("INSERT INTO my_table(c1, c2) values (1, 1) " +
 The driver has a timestamp generator that gets invoked for every outgoing request; it either assigns
 a client-side timestamp to the request, or indicates that the server should assign it. 
 
-The timestamp generator is defined in the [configuration](../configuration/).
+The timestamp generator is defined in the [configuration](../configuration/README.md).
 
 #### AtomicTimestampGenerator
 
@@ -148,7 +148,7 @@ implementation class from the configuration.
 
 #### Using multiple generators
 
-The timestamp generator can be overridden in [execution profiles](../configuration/#profiles):
+The timestamp generator can be overridden in [execution profiles](../configuration/README.md#execution-profiles):
 
 ```
 datastax-java-driver {
diff --git a/manual/core/reactive/README.md b/manual/core/reactive/README.md
index 37a2e3411b8..a84e133132f 100644
--- a/manual/core/reactive/README.md
+++ b/manual/core/reactive/README.md
@@ -33,7 +33,7 @@ Notes:
 * For historical reasons, reactive-related driver types reside in a package prefixed with `dse`;
   however, reactive queries also work with regular Cassandra.
 * The reactive execution model is implemented in a non-blocking fashion: see the manual page on 
-  [non-blocking programming](../non_blocking) for details.
+  [non-blocking programming](../non_blocking/README.md) for details.
 
 ### Overview
 
@@ -399,8 +399,8 @@ more fine-grained control of what should be retried, and how, is required.
 [ReactiveRow.getExecutionInfo]:     https://docs.datastax.com/en/drivers/java/4.17/com/datastax/dse/driver/api/core/cql/reactive/ReactiveRow.html#getExecutionInfo--
 [ReactiveRow.wasApplied]:           https://docs.datastax.com/en/drivers/java/4.17/com/datastax/dse/driver/api/core/cql/reactive/ReactiveRow.html#wasApplied--
 
-[built-in retry mechanism]: ../retries/
-[request throttling]: ../throttling/
+[built-in retry mechanism]: ../retries/README.md
+[request throttling]: ../throttling/README.md
 
 [Managing concurrency in asynchronous query execution]: https://docs.datastax.com/en/devapp/doc/devapp/driverManagingConcurrency.html]
 [Publisher]: https://www.reactive-streams.org/reactive-streams-1.0.2-javadoc/org/reactivestreams/Publisher.html
diff --git a/manual/core/reconnection/README.md b/manual/core/reconnection/README.md
index 3eb6dad9c05..0d875e3eff8 100644
--- a/manual/core/reconnection/README.md
+++ b/manual/core/reconnection/README.md
@@ -36,17 +36,17 @@ When a connection is lost, try to reestablish it at configured intervals.
 If a running session loses a connection to a node, it tries to re-establish it according to a
 configurable policy. This is used in two places:
 
-* [connection pools](../pooling/): for each node, a session has a fixed-size pool of connections to
+* [connection pools](../pooling/README.md): for each node, a session has a fixed-size pool of connections to
   execute user requests. If one or more connections drop, a reconnection gets started for the pool;
   each attempt tries to reopen the missing number of connections. This goes on until the pool is
   back to its expected size;
-* [control connection](../control_connection/): a session uses a single connection to an arbitrary
+* [control connection](../control_connection/README.md): a session uses a single connection to an arbitrary
   node for administrative requests. If that connection goes down, a reconnection gets started; each
   attempt iterates through all active nodes until one of them accepts a connection. This goes on
   until we have a control node again.
 
 The reconnection policy controls the interval between each attempt. It is defined in the
-[configuration](../configuration/):
+[configuration](../configuration/README.md):
 
 ```
 datastax-java-driver {
@@ -84,7 +84,7 @@ is the exponential one with the default values, and the control connection is in
 * [t = 2.2], node3's pool tries to open its missing connection, which succeeds. The pool is back to
   its expected size, node3's reconnection stops;
 * [t = 2.5] the control connection tries to find a new node. It invokes the
-  [load balancing policy](../load_balancing/) to get a query plan, which happens to start with
+  [load balancing policy](../load_balancing/README.md) to get a query plan, which happens to start with
   node4. The connection succeeds, node4 is now the control node and the reconnection stops;
 * [t = 3] node2's pool tries to open the last missing connection, which succeeds. The pool is back
   to its expected size, node2's reconnection stops.
diff --git a/manual/core/request_id/README.md b/manual/core/request_id/README.md
index a766a4419af..ea22aaba516 100644
--- a/manual/core/request_id/README.md
+++ b/manual/core/request_id/README.md
@@ -34,7 +34,7 @@ Usage:
 
 ### Request Id Generator Configuration
 
-Request ID generator can be declared in the [configuration](../configuration/) as follows:
+Request ID generator can be declared in the [configuration](../configuration/README.md) as follows:
 
 ```
 datastax-java-driver.advanced.request-id.generator {
diff --git a/manual/core/request_tracker/README.md b/manual/core/request_tracker/README.md
index c135abfe53f..a70e6b219ee 100644
--- a/manual/core/request_tracker/README.md
+++ b/manual/core/request_tracker/README.md
@@ -35,7 +35,7 @@ every application request. The driver comes with an optional implementation that
 
 ### Configuration
 
-Request trackers can be declared in the [configuration](../configuration/) as follows:
+Request trackers can be declared in the [configuration](../configuration/README.md) as follows:
 
 ```
 datastax-java-driver.advanced.request-tracker {
diff --git a/manual/core/retries/README.md b/manual/core/retries/README.md
index e92f8e214aa..2afa5585217 100644
--- a/manual/core/retries/README.md
+++ b/manual/core/retries/README.md
@@ -26,7 +26,7 @@ What to do when a request failed on a node: retry (same or other node), rethrow,
 * `advanced.retry-policy` in the configuration. Default policy retries at most once, in cases that
   have a high chance of success; you can also write your own.
 * can have per-profile policies. 
-* only kicks in if the query is [idempotent](../idempotence).
+* only kicks in if the query is [idempotent](../idempotence/README.md).
 
 -----
 
@@ -60,7 +60,7 @@ use this retry policy if you understand the consequences.**
 
 Since `DefaultRetryPolicy` is already the driver's default retry policy, no special configuration
 is required to activate it. To use `ConsistencyDowngradingRetryPolicy` instead, the following 
-option must be declared in the driver [configuration](../configuration/):
+option must be declared in the driver [configuration](../configuration/README.md):
                  
 ```
 datastax-java-driver.advanced.retry-policy.class = ConsistencyDowngradingRetryPolicy
@@ -78,7 +78,7 @@ The policy has several methods that cover different error cases. Each method ret
 what to do next. There are four possible retry decisions:
 
 * retry on the same node;
-* retry on the next node in the [query plan](../load_balancing/) for this statement;
+* retry on the next node in the [query plan](../load_balancing/README.md) for this statement;
 * rethrow the exception to the user code (from the `session.execute` call, or as a failed future if
   using the asynchronous API);
 * ignore the exception. That is, mark the request as successful, and return an empty result set.
@@ -144,7 +144,7 @@ mutation was applied or not on the non-answering replica.
 
 If the policy rethrows the error, the user code will get a [WriteTimeoutException].
 
-This method is only invoked for [idempotent](../idempotence/) statements. Otherwise, the driver
+This method is only invoked for [idempotent](../idempotence/README.md) statements. Otherwise, the driver
 bypasses the retry policy and always rethrows the error.
 
 The default policy triggers a maximum of one retry (to the same node), and only for a `BATCH_LOG`
@@ -173,10 +173,10 @@ cases:
 
 * if the connection was closed due to an external event. This will manifest as a
   [ClosedConnectionException] \(network failure) or [HeartbeatException] \(missed
-  [heartbeat](../pooling/#heartbeat));
+  [heartbeat](../pooling/README.md#heartbeat));
 * if there was an unexpected error while decoding the response (this can only be a driver bug).
 
-This method is only invoked for [idempotent](../idempotence/) statements. Otherwise, the driver
+This method is only invoked for [idempotent](../idempotence/README.md) statements. Otherwise, the driver
 bypasses the retry policy and always rethrows the error.
 
 Both the default policy and `ConsistencyDowngradingRetryPolicy` retry on the next node if the 
@@ -188,7 +188,7 @@ The coordinator replied with an error other than `READ_TIMEOUT`, `WRITE_TIMEOUT`
 Namely, this covers [OverloadedException], [ServerError], [TruncateException],
 [ReadFailureException] and [WriteFailureException].
 
-This method is only invoked for [idempotent](../idempotence/) statements. Otherwise, the driver
+This method is only invoked for [idempotent](../idempotence/README.md) statements. Otherwise, the driver
 bypasses the retry policy and always rethrows the error.
 
 Both the default policy and `ConsistencyDowngradingRetryPolicy` rethrow read and write failures, 
@@ -200,14 +200,14 @@ There are a few cases where retrying is always the right thing to do. These are
 `RetryPolicy`, but instead hard-coded in the driver:
 
 * **any error before a network write was attempted**: to send a query, the driver selects a node,
-  borrows a connection from the host's [connection pool](../pooling/), and then writes the message
+  borrows a connection from the host's [connection pool](../pooling/README.md), and then writes the message
   to the connection. Errors can occur before the write was even attempted, for example if the
   connection pool is saturated, or if the node went down right after we borrowed. In those cases, it
   is always safe to retry since the request wasn't sent, so the driver will transparently move to
   the next node in the query plan.
 * **re-preparing a statement**: when the driver executes a prepared statement, it may find out that
   the coordinator doesn't know about it, and need to re-prepare it on the fly (this is described in
-  detail [here](../statements/prepared/)). The query is then retried on the same node.
+  detail [here](../statements/prepared/README.md)). The query is then retried on the same node.
 * **trying to communicate with a node that is bootstrapping**: this is a rare edge case, as in
   practice the driver should never try to communicate with a bootstrapping node (the only way is if
   it was specified as a contact point). It is again safe to assume that the query was not executed
@@ -222,7 +222,7 @@ directly to the user. These include:
 
 ### Using multiple policies
 
-The retry policy can be overridden in [execution profiles](../configuration/#profiles):
+The retry policy can be overridden in [execution profiles](../configuration/README.md#execution-profiles):
 
 ```
 datastax-java-driver {
diff --git a/manual/core/shaded_jar/README.md b/manual/core/shaded_jar/README.md
index 8e183c0efb5..4272683ff63 100644
--- a/manual/core/shaded_jar/README.md
+++ b/manual/core/shaded_jar/README.md
@@ -20,11 +20,11 @@ under the License.
 ## Using the shaded JAR
 
 The default `java-driver-core` JAR depends on a number of [third party
-libraries](../integration/#driver-dependencies). This can create conflicts if your application
+libraries](../integration/README.md#driver-dependencies). This can create conflicts if your application
 already uses other versions of those same dependencies.
 
-To avoid this, we provide an alternative core artifact that shades [Netty](../integration/#netty),
-[Jackson](../integration/#jackson) and [ESRI](../integration/#esri). To use it, replace the
+To avoid this, we provide an alternative core artifact that shades [Netty](../integration/README.md#netty),
+[Jackson](../integration/README.md#jackson) and [ESRI](../integration/README.md#esri). To use it, replace the
 dependency to `java-driver-core` by:
 
 ```xml
diff --git a/manual/core/speculative_execution/README.md b/manual/core/speculative_execution/README.md
index 5666d6a1363..828e07af2ba 100644
--- a/manual/core/speculative_execution/README.md
+++ b/manual/core/speculative_execution/README.md
@@ -91,12 +91,12 @@ details and how to enable them.
 
 ### Query idempotence
 
-If a query is [not idempotent](../idempotence/), the driver will never schedule speculative
+If a query is [not idempotent](../idempotence/README.md), the driver will never schedule speculative
 executions for it, because there is no way to guarantee that only one node will apply the mutation.
 
 ### Configuration
 
-Speculative executions are controlled by a policy defined in the [configuration](../configuration/).
+Speculative executions are controlled by a policy defined in the [configuration](../configuration/README.md).
 The default implementation never schedules an execution:
 
 ```
@@ -138,7 +138,7 @@ referencing your implementation class from the configuration.
 
 ### How speculative executions affect retries
 
-Turning on speculative executions doesn't change the driver's [retry](../retries/) behavior. Each
+Turning on speculative executions doesn't change the driver's [retry](../retries/README.md) behavior. Each
 parallel execution will trigger retries independently:
 
 ```ditaa
@@ -183,7 +183,7 @@ executions increase the pressure on the cluster.
 
 If you use speculative executions to avoid unhealthy nodes, a good-behaving node should rarely hit
 the threshold. We recommend running a benchmark on a healthy platform (all nodes up and healthy) and
-monitoring the request percentiles with the `cql-requests` [metric](../metrics/). Then use the
+monitoring the request percentiles with the `cql-requests` [metric](../metrics/README.md). Then use the
 latency at a high percentile (for example p99.9) as the threshold.
 
 Alternatively, maybe low latency is your absolute priority, and you are willing to take the
@@ -191,27 +191,27 @@ increased throughput as a tradeoff. In that case, set the threshold to 0 and pro
 accordingly. 
 
 You can monitor the number of speculative executions triggered by each node with the
-`speculative-executions` [metric](../metrics/).
+`speculative-executions` [metric](../metrics/README.md).
 
 #### Stream id exhaustion
 
 One side-effect of speculative executions is that many requests get cancelled, which can lead to a
 phenomenon called *stream id exhaustion*: each TCP connection can handle multiple simultaneous
-requests, identified by a unique number called *stream id* (see also the [pooling](../pooling/)
+requests, identified by a unique number called *stream id* (see also the [pooling](../pooling/README.md)
 section). When a request gets cancelled, we can't reuse its stream id immediately because we might
 still receive a response from the server later. If this happens often, the number of available
 stream ids diminishes over time, and when it goes below a given threshold we close the connection
 and create a new one. If requests are often cancelled, you will see connections being recycled at a
 high rate.
 
-The best way to monitor this is to compare the `pool.orphaned-streams` [metric](../metrics/) to the
+The best way to monitor this is to compare the `pool.orphaned-streams` [metric](../metrics/README.md) to the
 total number of available stream ids (which can be computed from the configuration:
 `pool.local.size * max-requests-per-connection`). The `pool.available-streams` and `pool.in-flight`
 metrics will also give you an idea of how many stream ids are left for active queries.
 
 #### Request ordering
 
-Note: ordering issues are only a problem with [server-side timestamps](../query_timestamps/), which
+Note: ordering issues are only a problem with [server-side timestamps](../query_timestamps/README.md), which
 are not the default anymore in driver 4+. So unless you've explicitly enabled
 `ServerSideTimestampGenerator`, you can skip this section.
 
@@ -235,12 +235,12 @@ The workaround is to either specify a timestamp in your CQL queries:
 
     insert into my_table (k, v) values (1, 1) USING TIMESTAMP 1432764000;
     
-Or use a client-side [timestamp generator](../query_timestamps/).
+Or use a client-side [timestamp generator](../query_timestamps/README.md).
 
 ### Using multiple policies
 
 The speculative execution policy can be overridden in [execution
-profiles](../configuration/#profiles):
+profiles](../configuration/README.md#execution-profiles):
 
 ```
 datastax-java-driver {
diff --git a/manual/core/ssl/README.md b/manual/core/ssl/README.md
index 913c7bc6c9a..9587ce77218 100644
--- a/manual/core/ssl/README.md
+++ b/manual/core/ssl/README.md
@@ -102,7 +102,7 @@ already be the case if you've followed the steps for inter-node encryption).
 By default, the driver's SSL support is based on the JDK's built-in implementation: JSSE (Java
 Secure Socket Extension).
 
-To enable it, you need to define an engine factory in the [configuration](../configuration/).
+To enable it, you need to define an engine factory in the [configuration](../configuration/README.md).
 
 #### JSSE, property-based
 
@@ -225,7 +225,7 @@ CqlSession session = CqlSession.builder()
 
 Netty supports native integration with OpenSSL / boringssl. The driver does not provide this out of
 the box, but with a bit of custom development it is fairly easy to add. See
-[SslHandlerFactory](../../developer/netty_pipeline/#ssl-handler-factory) in the developer docs.
+[SslHandlerFactory](../../developer/netty_pipeline/README.md#sslhandlerfactory) in the developer docs.
 
 
 [dsClientToNode]: https://docs.datastax.com/en/cassandra/3.0/cassandra/configuration/secureSSLClientToNode.html
diff --git a/manual/core/statements/README.md b/manual/core/statements/README.md
index 394e81ae00e..2e7c3506b2d 100644
--- a/manual/core/statements/README.md
+++ b/manual/core/statements/README.md
@@ -33,22 +33,22 @@ To execute a CQL query, you  create a [Statement] instance and pass it to
 [Session#execute][execute] or [Session#executeAsync][executeAsync]. The driver provides various
 implementations:
 
-* [SimpleStatement](simple/): a simple implementation built directly from a character string. 
+* [SimpleStatement](simple/README.md): a simple implementation built directly from a character string. 
   Typically used for queries that are executed only once or a few times.
-* [BoundStatement (from PreparedStatement)](prepared/): obtained by binding values to a prepared
+* [BoundStatement (from PreparedStatement)](prepared/README.md): obtained by binding values to a prepared
   query. Typically used for queries that are executed often, with different values.
-* [BatchStatement](batch/): a statement that groups multiple statements to be executed as a batch.
+* [BatchStatement](batch/README.md): a statement that groups multiple statements to be executed as a batch.
 
 All statement types share a [common set of execution attributes][StatementBuilder], that can be set
 through either setters or a builder:
 
-* [execution profile](../configuration/) name, or the profile itself if it's been built dynamically.
-* [idempotent flag](../idempotence/).
-* [tracing flag](../tracing/).
-* [query timestamp](../query_timestamps/).
-* [page size and paging state](../paging/).
-* [per-query keyspace](per_query_keyspace/) (Cassandra 4 or above).
-* [token-aware routing](../load_balancing/#token-aware) information (keyspace and key/token).
+* [execution profile](../configuration/README.md) name, or the profile itself if it's been built dynamically.
+* [idempotent flag](../idempotence/README.md).
+* [tracing flag](../tracing/README.md).
+* [query timestamp](../query_timestamps/README.md).
+* [page size and paging state](../paging/README.md).
+* [per-query keyspace](per_query_keyspace/README.md) (Cassandra 4 or above).
+* [token-aware routing](../load_balancing/README.md#token-aware) information (keyspace and key/token).
 * normal and serial consistency level.
 * query timeout.
 * custom payload to send arbitrary key/value pairs with the request (you should only need this if
@@ -74,7 +74,7 @@ such as [ErrorProne](https://errorprone.info/) -- can check correct usage at bui
 mistakes as compiler errors.
 
 Note that some attributes can either be set programmatically, or inherit a default value defined in
-the [configuration](../configuration/). Namely, these are: idempotent flag, query timeout,
+the [configuration](../configuration/README.md). Namely, these are: idempotent flag, query timeout,
 consistency levels and page size. We recommended the configuration approach whenever possible (you
 can create execution profiles to capture common combinations of those options).
 
diff --git a/manual/core/statements/per_query_keyspace/README.md b/manual/core/statements/per_query_keyspace/README.md
index 9a7ffa338c9..8b1b550ddac 100644
--- a/manual/core/statements/per_query_keyspace/README.md
+++ b/manual/core/statements/per_query_keyspace/README.md
@@ -33,7 +33,7 @@ switching the whole session to that keyspace either. For example, you might have
 setup where identical requests are executed against different keyspaces.
 
 **This feature is only available with Cassandra 4.0 or above** ([CASSANDRA-10145]). Make sure you
-are using [native protocol](../../native_protocol/) v5 or above to connect.
+are using [native protocol](../../native_protocol/README.md) v5 or above to connect.
 
 If you try against an older version, you will get an error:
 
@@ -57,7 +57,7 @@ SimpleStatement statement =
 session.execute(statement);
 ```
 
-You can do this on [simple](../simple/), [prepared](../prepared) or [batch](../batch/) statements.
+You can do this on [simple](../simple/README.md), [prepared](../prepared/README.md) or [batch](../batch/README.md) statements.
 
 If the session is connected to another keyspace, the per-query keyspace takes precedence:
 
diff --git a/manual/core/statements/prepared/README.md b/manual/core/statements/prepared/README.md
index 5a87b238cbc..3ce3031f0b5 100644
--- a/manual/core/statements/prepared/README.md
+++ b/manual/core/statements/prepared/README.md
@@ -101,11 +101,11 @@ the `PREPARED` response also contains useful metadata about the CQL query:
 * the CQL types of the bound variables. This allows bound statements' `set` methods to perform
   better checks, and fail fast (without a server round-trip) if the types are wrong.
 * which bound variables are part of the partition key. This allows bound statements to automatically
-  compute their [routing key](../../load_balancing/#token-aware).
+  compute their [routing key](../../load_balancing/README.md#token-aware).
 * more optimizations might get added in the future. For example, [CASSANDRA-10813] suggests adding
-  an "[idempotent](../../idempotence)" flag to the response.
+  an "[idempotent](../../idempotence/README.md)" flag to the response.
 
-If you have a unique query that is executed only once, a [simple statement](../simple/) will be more
+If you have a unique query that is executed only once, a [simple statement](../simple/README.md) will be more
 efficient. But note that this should be pretty rare: most client applications typically repeat the
 same queries over and over, and a parameterized version can be extracted and prepared.  
 
@@ -150,8 +150,8 @@ Note that caching is based on:
   but different consistency levels will yield two distinct prepared statements (that each produce
   bound statements with their respective consistency level).
 
-The size of the cache is exposed as a session-level [metric](../../metrics/)
-`cql-prepared-cache-size`. The cache uses [weak values]([guava eviction]) eviction, so this
+The size of the cache is exposed as a session-level [metric](../../metrics/README.md)
+`cql-prepared-cache-size`. The cache uses [weak values][guava eviction] eviction, so this
 represents the number of `PreparedStatement` instances that your application has created, and is
 still holding a reference to.
 
@@ -217,7 +217,7 @@ parameters.
 
 #### Unset values
 
-With [native protocol](../../native_protocol/) V3, all variables must be bound. With native protocol
+With [native protocol](../../native_protocol/README.md) V3, all variables must be bound. With native protocol
 V4 (Cassandra 2.2 / DSE 5) or above, variables can be left unset, in which case they will be ignored
 (no tombstones will be generated). If you're reusing a bound statement, you can use the `unset`
 method to unset variables that were previously set:
@@ -314,14 +314,14 @@ achieve this:
       |<------------------------------|                              |
     ```
 
-You can customize these strategies through the [configuration](../../configuration/):
+You can customize these strategies through the [configuration](../../configuration/README.md):
 
 * `datastax-java-driver.advanced.prepared-statements.prepare-on-all-nodes` controls whether
   statements are initially re-prepared on other hosts (step 1 above);
 * `datastax-java-driver.advanced.prepared-statements.reprepare-on-up` controls how statements are
   re-prepared on a node that comes back up (step 2 above).
 
-Read the [reference configuration](../../configuration/reference/) for a detailed description of each
+Read the [reference configuration](../../configuration/reference/README.md) for a detailed description of each
 of those options.
 
 ### Prepared statements and schema changes 
@@ -344,7 +344,7 @@ To avoid this, do not create prepared statements for `SELECT *` queries if you p
 changes involving adding or dropping columns. Instead, always list all columns of interest in your
 statement, i.e.: `SELECT b, c FROM foo`.
 
-With Cassandra 4 and [native protocol](../../native_protocol/) v5, this issue is fixed
+With Cassandra 4 and [native protocol](../../native_protocol/README.md) v5, this issue is fixed
 ([CASSANDRA-10786]): the server detects that the driver is operating on stale metadata and sends the
 new version with the response; the driver updates its local cache transparently, and the client can
 observe the new columns in the result set.
diff --git a/manual/core/statements/simple/README.md b/manual/core/statements/simple/README.md
index 13ddbb7a389..05aa2e676cd 100644
--- a/manual/core/statements/simple/README.md
+++ b/manual/core/statements/simple/README.md
@@ -63,7 +63,7 @@ client                             driver                Cassandra
 ```
 
 If you execute the same query often (or a similar query with different column values), consider a
-[prepared statement](../prepared/) instead.
+[prepared statement](../prepared/README.md) instead.
 
 ### Creating an instance
 
@@ -147,7 +147,7 @@ session.execute(
 ### Type inference
 
 Another consequence of not parsing query strings is that the driver has to guess how to serialize 
-values, based on their Java type (see the [default type mappings](../../#cql-to-java-type-mapping)).
+values, based on their Java type (see the [default type mappings](../../README.md#cql-to-java-type-mapping)).
 This can be tricky, in particular for numeric types:
 
 ```java
@@ -198,7 +198,7 @@ session.execute(
         .build());
 ```
 
-Or you could also use [prepared statements](../prepared/), which don't have this limitation since
+Or you could also use [prepared statements](../prepared/README.md), which don't have this limitation since
 parameter types are known in advance. 
 
 [SimpleStatement]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/cql/SimpleStatement.html
diff --git a/manual/core/throttling/README.md b/manual/core/throttling/README.md
index 275c0cb5b40..e533ebcd00f 100644
--- a/manual/core/throttling/README.md
+++ b/manual/core/throttling/README.md
@@ -53,14 +53,14 @@ Note that the following requests are also affected by throttling:
 
 * preparing a statement (either directly, or indirectly when the driver reprepares on other nodes,
   or when a node comes back up -- see
-  [how the driver prepares](../statements/prepared/#how-the-driver-prepares));
+  [how the driver prepares](../statements/prepared/README.md#how-the-driver-prepares));
 * fetching the next page of a result set (which happens in the background when you iterate the
   synchronous variant `ResultSet`).
-* fetching a [query trace](../tracing/).
+* fetching a [query trace](../tracing/README.md).
 
 ### Configuration
 
-Request throttling is parameterized in the [configuration](../configuration/) under
+Request throttling is parameterized in the [configuration](../configuration/README.md) under
 `advanced.throttler`. There are various implementations, detailed in the following sections:
 
 #### Pass through
@@ -77,7 +77,7 @@ This is a no-op implementation: requests are simply allowed to proceed all the t
 
 Note that you will still hit a limit if all your connections run out of stream ids. In that case,
 requests will fail with an [AllNodesFailedException], with the `getErrors()` method returning a
-[BusyConnectionException] for each node. See the [connection pooling](../pooling/) page.
+[BusyConnectionException] for each node. See the [connection pooling](../pooling/README.md) page.
 
 #### Concurrency-based
 
@@ -103,8 +103,8 @@ with [BusyConnectionException] instead of being throttled. The total number of s
 function of the number of connected nodes and the `connection.pool.*.size` and
 `connection.max-requests-per-connection` configuration options. Keep in mind that aggressive
 speculative executions and timeout options can inflate stream id consumption, so keep a safety
-margin. One good way to get this right is to track the `pool.available-streams` [metric](../metrics)
-on every node, and make sure it never reaches 0. See the [connection pooling](../pooling/) page.
+margin. One good way to get this right is to track the `pool.available-streams` [metric](../metrics/README.md)
+on every node, and make sure it never reaches 0. See the [connection pooling](../pooling/README.md) page.
 
 #### Rate-based
 
@@ -129,14 +129,14 @@ does not necessarily mean that the rate is back to normal. So instead the thrott
 rate periodically and dequeues when possible, this is controlled by the `drain-interval` option.
 Picking the right interval is a matter of balance: too low might consume too many resources and only
 dequeue a few requests at a time, but too high will delay your requests too much; start with a few
-milliseconds and use the `cql-requests` [metric](../metrics/) to check the impact on your latencies.
+milliseconds and use the `cql-requests` [metric](../metrics/README.md) to check the impact on your latencies.
 
 Like with the concurrency-based throttler, you should make sure that your target rate is in line
 with the pooling options; see the recommendations in the previous section.
 
 ### Monitoring
 
-Enable the following [metrics](../metrics/) to monitor how the throttler is performing:
+Enable the following [metrics](../metrics/README.md) to monitor how the throttler is performing:
 
 ```
 datastax-java-driver {
diff --git a/manual/core/tracing/README.md b/manual/core/tracing/README.md
index f9beca8e49b..660ffddccba 100644
--- a/manual/core/tracing/README.md
+++ b/manual/core/tracing/README.md
@@ -42,7 +42,7 @@ results.
 ### Enabling tracing
 
 Set the tracing flag on the `Statement` instance. There are various ways depending on how you build
-it (see [statements](../statements/) for more details):
+it (see [statements](../statements/README.md) for more details):
 
 ```java
 // Setter-based:
diff --git a/manual/core/tuples/README.md b/manual/core/tuples/README.md
index d0684b77569..43c8f8eefae 100644
--- a/manual/core/tuples/README.md
+++ b/manual/core/tuples/README.md
@@ -32,7 +32,7 @@ Ordered set of anonymous, typed fields, e.g. `tuple<int, text, float>`, `(1, 'a'
 -----
 
 [CQL tuples][cql_doc] are ordered sets of anonymous, typed fields. They can be used as a column type
-in tables, or a field type in [user-defined types](../udts/):
+in tables, or a field type in [user-defined types](../udts/README.md):
 
 ```
 CREATE TABLE ks.collect_things (
@@ -77,7 +77,7 @@ ways to get it:
     TupleType tupleType = (TupleType) ps.getVariableDefinitions().get("v").getType();
     ```
 
-* from the driver's [schema metadata](../metadata/schema/):
+* from the driver's [schema metadata](../metadata/schema/README.md):
 
     ```java
     TupleType tupleType =
@@ -102,7 +102,7 @@ ways to get it:
     TupleType tupleType = DataTypes.tupleOf(DataTypes.INT, DataTypes.TEXT, DataTypes.FLOAT);
     ```
 
-    Note that the resulting type is [detached](../detachable_types).
+    Note that the resulting type is [detached](../detachable_types/README.md).
   
 Once you have the type, call `newValue()` and set the fields:
 
diff --git a/manual/core/udts/README.md b/manual/core/udts/README.md
index a22057030ae..9a4dcc114eb 100644
--- a/manual/core/udts/README.md
+++ b/manual/core/udts/README.md
@@ -93,7 +93,7 @@ various ways to get it:
     UserDefinedType udt = (UserDefinedType) ps.getVariableDefinitions().get("v").getType();
     ```
 
-* from the driver's [schema metadata](../metadata/schema/):
+* from the driver's [schema metadata](../metadata/schema/README.md):
 
     ```java
     UserDefinedType udt =
@@ -113,7 +113,7 @@ Note that the driver's official API does not expose a way to build [UserDefinedT
 manually. This is because the type's internal definition must precisely match the database schema;
 if it doesn't (for example if the fields are not in the same order), you run the risk of inserting
 corrupt data, that you won't be able to read back. There is still a way to do it with the driver,
-but it's part of the [internal API](../../api_conventions/):
+but it's part of the [internal API](../../api_conventions/README.md):
 
 ```java
 // Advanced usage: make sure you understand the risks
@@ -127,7 +127,7 @@ UserDefinedType udt =
         .build();
 ```
 
-Note that a manually created type is [detached](../detachable_types).
+Note that a manually created type is [detached](../detachable_types/README.md).
 
  
 Once you have the type, call `newValue()` and set the fields:
diff --git a/manual/developer/README.md b/manual/developer/README.md
index b6e0bda16ed..1bef958ef7a 100644
--- a/manual/developer/README.md
+++ b/manual/developer/README.md
@@ -24,15 +24,15 @@ This section explains how driver internals work. The intended audience is:
 * driver developers and contributors;
 * framework authors, or architects who want to write advanced customizations and integrations. 
 
-Most of this material will involve "internal" packages; see [API conventions](../api_conventions/)
+Most of this material will involve "internal" packages; see [API conventions](../api_conventions/README.md)
 for more explanations.
 
-We recommend reading about the [common infrastructure](common/) first. Then the documentation goes
+We recommend reading about the [common infrastructure](common/README.md) first. Then the documentation goes
 from lowest to highest level:
 
-* [Native protocol layer](native_protocol/): binary encoding of the TCP payloads;
-* [Netty pipeline](netty_pipeline/): networking and low-level stream management;
-* [Request execution](request_execution/): higher-level handling of user requests and responses;
-* [Administrative tasks](admin/): everything else (cluster state and metadata).
+* [Native protocol layer](native_protocol/README.md): binary encoding of the TCP payloads;
+* [Netty pipeline](netty_pipeline/README.md): networking and low-level stream management;
+* [Request execution](request_execution/README.md): higher-level handling of user requests and responses;
+* [Administrative tasks](admin/README.md): everything else (cluster state and metadata).
 
 If you're reading this on GitHub, the `.nav` file in each directory contains a suggested order.
diff --git a/manual/developer/admin/README.md b/manual/developer/admin/README.md
index 0ebd9e2d746..bbc4b5ea18f 100644
--- a/manual/developer/admin/README.md
+++ b/manual/developer/admin/README.md
@@ -19,7 +19,7 @@ under the License.
 
 ## Administrative tasks
 
-Aside from the main task of [executing user requests](../request_execution), the driver also needs
+Aside from the main task of [executing user requests](../request_execution/README.md), the driver also needs
 to track cluster state and metadata. This is done with a number of administrative components:
 
 ```ditaa
@@ -48,7 +48,7 @@ node info|     |                  schema |         +------------+ EventBus |
                                metadata changed events
 ```
 
-Note: the event bus is covered in the [common infrastructure](../common/event_bus) section.
+Note: the event bus is covered in the [common infrastructure](../common/event_bus/README.md) section.
 
 ### Control connection
 
@@ -74,7 +74,7 @@ writing, the session also references the control connection directly, but that's
 ### Metadata manager
 
 This component is responsible for maintaining the contents of
-[session.getMetadata()](../../core/metadata/).
+[session.getMetadata()](../../core/metadata/README.md).
 
 One big improvement in driver 4 is that the `Metadata` object is immutable and updated atomically;
 this guarantees a consistent view of the cluster at a given point in time. For example, if a
@@ -85,7 +85,7 @@ keyspace name is referenced in the token map, there will always be a correspondi
 managed by a `MetadataRefresh` object that computes the new metadata, along with an optional list of
 events to publish on the bus (e.g. table created, keyspace removed, etc.) The new metadata is then
 written back to the volatile field. `MetadataManager` follows the [confined inner
-class](../common/concurrency/#cold-path) pattern to ensure that all refreshes are applied serially,
+class](../common/concurrency/README.md#cold-path) pattern to ensure that all refreshes are applied serially,
 from a single admin thread. This guarantees that two refreshes can't start from the same initial
 state and overwrite each other.
 
@@ -323,7 +323,7 @@ service instead of relying on system tables and gossip (see
 [JAVA-1082](https://datastax-oss.atlassian.net/browse/JAVA-1082)).
 
 A custom implementation can be plugged by [extending the
-context](../common/context/#overriding-a-context-component) and overriding `buildTopologyMonitor`.
+context](../common/context/README.md#overriding-a-context-component) and overriding `buildTopologyMonitor`.
 It should:
 
 * implement the methods of `TopologyMonitor` by querying the discovery service;
@@ -338,5 +338,5 @@ information returned by the topology monitor.
 It's less likely that this will be overridden directly. But the schema querying and parsing logic is
 abstracted behind two factories that handle the differences between Cassandra versions:
 `SchemaQueriesFactory` and `SchemaParserFactory`. These are pluggable by [extending the
-context](../common/context/#overriding-a-context-component) and overriding the corresponding
+context](../common/context/README.md#overriding-a-context-component) and overriding the corresponding
 `buildXxx` methods.
diff --git a/manual/developer/common/README.md b/manual/developer/common/README.md
index 13ad8639e62..b4db64c8474 100644
--- a/manual/developer/common/README.md
+++ b/manual/developer/common/README.md
@@ -21,8 +21,8 @@ under the License.
 
 This covers utilities or concept that are shared throughout the codebase:
 
-* the [context](context/) is what glues everything together, and your primary entry point to extend
+* the [context](context/README.md) is what glues everything together, and your primary entry point to extend
   the driver.
-* we explain the two major approaches to deal with [concurrency](concurrency/) in the driver.
-* the [event bus](event_bus/) is used to decouple some of the internal components through
+* we explain the two major approaches to deal with [concurrency](concurrency/README.md) in the driver.
+* the [event bus](event_bus/README.md) is used to decouple some of the internal components through
   asynchronous messaging.
diff --git a/manual/developer/common/concurrency/README.md b/manual/developer/common/concurrency/README.md
index fb493930d6e..9265985a316 100644
--- a/manual/developer/common/concurrency/README.md
+++ b/manual/developer/common/concurrency/README.md
@@ -97,7 +97,7 @@ fields, and methods are guaranteed to always run in isolation, eliminating subtl
 ### Non-blocking
 
 Whether on the hot or cold path, internal code is almost 100% lock-free. The driver guarantees on
-lock-freedom are [detailed](../../../core/non_blocking) in the core manual.
+lock-freedom are [detailed](../../../core/non_blocking/README.md) in the core manual.
 
 If an internal component needs to execute a query, it does so asynchronously, and registers 
 callbacks to process the results. Examples of this can be found in `ReprepareOnUp` and 
diff --git a/manual/developer/native_protocol/README.md b/manual/developer/native_protocol/README.md
index b96553fc51b..6211443253d 100644
--- a/manual/developer/native_protocol/README.md
+++ b/manual/developer/native_protocol/README.md
@@ -186,12 +186,12 @@ The driver initializes its `FrameCodec` in `DefaultDriverContext.buildFrameCodec
 ### Extension points
 
 The default frame codec can be replaced by [extending the
-context](../common/context/#overriding-a-context-component) to override `buildFrameCodec`. This
+context](../common/context/README.md#overriding-a-context-component) to override `buildFrameCodec`. This
 can be used to add or remove a protocol version, or replace a particular codec.
 
 If protocol versions change, `ProtocolVersionRegistry` will likely be affected as well.
 
 Also, depending on the nature of the protocol changes, the driver's [request
-processors](../request_execution/#request-processors) might require some adjustments: either replace
+processors](../request_execution/README.md#request-processors) might require some adjustments: either replace
 them, or introduce separate ones (possibly with new `executeXxx()` methods on a custom session
 interface).
diff --git a/manual/developer/netty_pipeline/README.md b/manual/developer/netty_pipeline/README.md
index b596832e202..dea38ad307c 100644
--- a/manual/developer/netty_pipeline/README.md
+++ b/manual/developer/netty_pipeline/README.md
@@ -19,7 +19,7 @@ under the License.
 
 ## Netty pipeline
 
-With the [protocol layer](../native_protocol) in place, the next step is to build the logic for a
+With the [protocol layer](../native_protocol/README.md) in place, the next step is to build the logic for a
 single server connection.
 
 We use [Netty](https://netty.io/) for network I/O (to learn more about Netty, [this
@@ -81,7 +81,7 @@ See also the [Extension points](#extension-points) section below.
 ### FrameEncoder and FrameDecoder
 
 This is where we integrate the protocol layer, as explained
-[here](../native_protocol/#integration-in-the-driver).
+[here](../native_protocol/README.md#integration-in-the-driver).
 
 Unlike the other pipeline stages, we use separate handlers for incoming and outgoing messages.
 
@@ -121,7 +121,7 @@ with each other.
 
 In particular, a big difference from driver 3 is that stream ids are assigned within the event loop,
 instead of from client code before writing to the channel (see also [connection
-pooling](../request_execution/#connection_pooling)). `StreamIdGenerator` is not thread-safe.
+pooling](../request_execution/README.md#connection-pooling)). `StreamIdGenerator` is not thread-safe.
 
 All communication between the handler and the outside world must be done through messages or channel
 events. There are 3 exceptions to this rule: `getAvailableIds`, `getInflight` and `getOrphanIds`,
@@ -145,11 +145,11 @@ Once the initialization is complete, `ProtocolInitHandler` removes itself from t
 
 #### NettyOptions
 
-The `advanced.netty` section in the [configuration](../../core/configuration/reference/) exposes a
+The `advanced.netty` section in the [configuration](../../core/configuration/reference/README.md) exposes a
 few high-level options.
 
 For more elaborate customizations, you can [extend the
-context](../common/context/#overriding-a-context-component) to plug in a custom `NettyOptions`
+context](../common/context/README.md#overriding-a-context-component) to plug in a custom `NettyOptions`
 implementation. This allows you to do things such as:
  
 * reusing existing event loops;
@@ -158,7 +158,7 @@ implementation. This allows you to do things such as:
 
 #### SslHandlerFactory
 
-The [user-facing API](../../core/ssl/) (`advanced.ssl-engine-factory` in the configuration, or
+The [user-facing API](../../core/ssl/README.md) (`advanced.ssl-engine-factory` in the configuration, or
 `SessionBuilder.withSslContext` / `SessionBuilder.withSslEngineFactory`) only supports Java's
 default SSL implementation.
 
@@ -172,7 +172,7 @@ boringssl. This requires a bit of custom development against the internal API:
   * the constructor will create a Netty [SslContext] with [SslContextBuilder.forClient], and store
     it in a field;
   * `newSslHandler` will delegate to one of the [SslContext.newHandler] methods;  
-* [extend the context](../common/context/#overriding-a-context-component) and override
+* [extend the context](../common/context/README.md#overriding-a-context-component) and override
   `buildSslHandlerFactory` to plug your custom implementation.
 
 [SslContext]: https://netty.io/4.1/api/io/netty/handler/ssl/SslContext.html
diff --git a/manual/developer/request_execution/README.md b/manual/developer/request_execution/README.md
index 38a0a55fbd7..e706644bd98 100644
--- a/manual/developer/request_execution/README.md
+++ b/manual/developer/request_execution/README.md
@@ -19,7 +19,7 @@ under the License.
 
 ## Request execution
 
-The [Netty pipeline](../netty_pipeline/) gives us the ability to send low-level protocol messages on
+The [Netty pipeline](../netty_pipeline/README.md) gives us the ability to send low-level protocol messages on
 a single connection.
 
 The request execution layer builds upon that to:
@@ -73,7 +73,7 @@ will be explained in [Request processors](#request-processors).
 ```
 
 `DefaultSession` contains the session implementation. It follows the [confined inner
-class](../common/concurrency/#cold-path) pattern to simplify concurrency.
+class](../common/concurrency/README.md#cold-path) pattern to simplify concurrency.
 
 ### Connection pooling
 
@@ -91,7 +91,7 @@ class](../common/concurrency/#cold-path) pattern to simplify concurrency.
 ```
 
 `ChannelPool` handles the connections to a given node, for a given session. It follows the [confined
-inner class](../common/concurrency/#cold-path) pattern to simplify concurrency. There are a few
+inner class](../common/concurrency/README.md#cold-path) pattern to simplify concurrency. There are a few
 differences compared to the 3.x implementation:
 
 #### Fixed size
@@ -112,12 +112,12 @@ sales), then a manual configuration change is good enough.
 
 To get a connection to a node, client code calls `ChannelPool.next()`. This returns the less busy
 connection, based on the the `getAvailableIds()` counter exposed by
-[InFlightHandler](netty_pipeline/#in-flight-handler).
+[InFlightHandler](../netty_pipeline/README.md#inflighthandler).
 
 If all connections are busy, there is no queuing; the driver moves to the next node immediately. The
 rationale is that it's better to try another node that might be ready to reply, instead of
 introducing an additional wait for each node. If the user wants queuing when all nodes are busy,
-it's better to do it at the session level with a [throttler](../../core/throttling/), which provides
+it's better to do it at the session level with a [throttler](../../core/throttling/README.md), which provides
 more intuitive configuration.
 
 Before 4.5.0, there was also no preemptive acquisition of the stream id outside of the event loop:
@@ -231,7 +231,7 @@ registry to find the processor that matches the request and result types.
 
 A processor is responsible for:
 
-* converting the user request into [protocol-level messages](../native_protocol/);
+* converting the user request into [protocol-level messages](../native_protocol/README.md);
 * selecting a coordinator node, and obtaining a channel from its connection pool;
 * writing the request to the channel;
 * handling timeouts, retries and speculative executions;
@@ -261,7 +261,7 @@ public interface CqlSession extends Session {
 #### RequestProcessorRegistry
 
 You can customize the set of request processors by [extending the
-context](../common/context/#overriding-a-context-component) and overriding
+context](../common/context/README.md#overriding-a-context-component) and overriding
 `buildRequestProcessorRegistry`.
 
 This can be used to either:
diff --git a/manual/mapper/README.md b/manual/mapper/README.md
index 27005b671ad..4996ddd4625 100644
--- a/manual/mapper/README.md
+++ b/manual/mapper/README.md
@@ -23,7 +23,7 @@ The mapper generates the boilerplate to execute queries and convert the results
 application-level objects.
 
 It is published as two artifacts: `org.apache.cassandra:java-driver-mapper-processor` and
-`org.apache.cassandra:java-driver-mapper-runtime`. See [Integration](config/) for detailed instructions
+`org.apache.cassandra:java-driver-mapper-runtime`. See [Integration](config/README.md) for detailed instructions
 for different build tools.
 
 ### Quick start
@@ -75,7 +75,7 @@ takes all the fields, we have to define the no-arg constructor explicitly.
 We use mapper annotations to mark the class as an entity, and indicate which field(s) correspond to
 the primary key.
 
-More annotations are available; for more details, see [Entities](entities/).
+More annotations are available; for more details, see [Entities](entities/README.md).
 
 #### DAO interface
 
@@ -103,7 +103,7 @@ public interface ProductDao {
 Again, mapper annotations are used to mark the interface, and indicate what kind of request each
 method should execute. You can probably guess what they are in this example.
 
-For the full list of available query types, see [DAOs](daos/).
+For the full list of available query types, see [DAOs](daos/README.md).
 
 #### Mapper interface
 
@@ -121,14 +121,14 @@ public interface InventoryMapper {
 }
 ```
 
-For more details, see [Mapper](mapper/).
+For more details, see [Mapper](mapper/README.md).
 
 #### Generating the code
 
 The mapper uses *annotation processing*: it hooks into the Java compiler to analyze annotations, and
 generate additional classes that implement the mapping logic. Annotation processing is a common
 technique in modern frameworks, and is generally well supported by build tools and IDEs; this is
-covered in detail in [Configuring the annotation processor](config/).
+covered in detail in [Configuring the annotation processor](config/README.md).
 
 Pay attention to the compiler output: the mapper processor will sometimes generate warnings if
 annotations are used incorrectly.
@@ -156,7 +156,7 @@ dao.save(new Product(UUID.randomUUID(), "Mechanical keyboard"));
 ### Logging
 
 The code generated by the mapper includes logs. They are issued with SLF4J, and can be configured
-the same way as the [core driver logs](../core/logging/).
+the same way as the [core driver logs](../core/logging/README.md).
 
 They can help you figure out which queries the mapper is generating under the hood, for example:
 
diff --git a/manual/mapper/config/README.md b/manual/mapper/config/README.md
index 1e4f9981306..698aa3e150d 100644
--- a/manual/mapper/config/README.md
+++ b/manual/mapper/config/README.md
@@ -74,7 +74,7 @@ configuration (make sure you use version 3.5 or higher):
 </build>
 ```
 
-Alternatively (e.g. if you are using the [BOM](../../core/bom/)), you may also declare the processor
+Alternatively (e.g. if you are using the [BOM](../../core/bom/README.md)), you may also declare the processor
 as a regular dependency in the "provided" scope:
 
 ```xml
@@ -128,7 +128,7 @@ You will find the generated files in `build/generated/sources/annotationProcesso
 
 ### Integration with other languages and libraries
 
-* <a name="kotlin"></a>[Kotlin](kotlin/)
-* <a name="lombok"></a>[Lombok](lombok/)
-* [Java 14 records](record/)
-* [Scala](scala/)
+* <a name="kotlin"></a>[Kotlin](kotlin/README.md)
+* <a name="lombok"></a>[Lombok](lombok/README.md)
+* [Java 14 records](record/README.md)
+* [Scala](scala/README.md)
diff --git a/manual/mapper/config/kotlin/README.md b/manual/mapper/config/kotlin/README.md
index a78bf04fb79..3f5e5205bdc 100644
--- a/manual/mapper/config/kotlin/README.md
+++ b/manual/mapper/config/kotlin/README.md
@@ -27,7 +27,7 @@ We have a full example at [DataStax-Examples/object-mapper-jvm/kotlin].
 ### Writing the model
 
 You can use Kotlin [data classes] for your entities. Data classes are usually
-[immutable](../../entities/#mutability), but you don't need to declare that explicitly with
+[immutable](../../entities/README.md#mutability), but you don't need to declare that explicitly with
 [@PropertyStrategy]: the mapper detects that it's processing Kotlin code, and will assume `mutable =
 false` by default:
 
@@ -46,10 +46,10 @@ declare a default value for every component in order to generate a no-arg constr
 data class Product(@PartitionKey var id: Int? = null, var description: String? = null)
 ```
 
-All of the [property annotations](../../entities/#property-annotations) can be declared directly on
+All of the [property annotations](../../entities/README.md#property-annotations) can be declared directly on
 the components.
 
-If you want to take advantage of [null saving strategies](../../daos/null_saving/), your components
+If you want to take advantage of [null saving strategies](../../daos/null_saving/README.md), your components
 should be nullable.
 
 The other mapper interfaces are direct translations of the Java versions:
diff --git a/manual/mapper/config/record/README.md b/manual/mapper/config/record/README.md
index 95530d52742..76bc27283bb 100644
--- a/manual/mapper/config/record/README.md
+++ b/manual/mapper/config/record/README.md
@@ -36,7 +36,7 @@ Annotate your records like regular classes:
 record Product(@PartitionKey int id, String description) {}
 ```
 
-Records are immutable and use the [fluent getter style](../../entities#getter-style), but you don't
+Records are immutable and use the [fluent getter style](../../entities/README.md#accessor-styles), but you don't
 need to declare that explicitly with [@PropertyStrategy]: the mapper detects when it's processing a
 record, and will assume `mutable = false, getterStyle = FLUENT` by default.
 
diff --git a/manual/mapper/config/scala/README.md b/manual/mapper/config/scala/README.md
index 2cb75273d0b..d17fedbc445 100644
--- a/manual/mapper/config/scala/README.md
+++ b/manual/mapper/config/scala/README.md
@@ -38,7 +38,7 @@ case class UserVideo(@(PartitionKey@field) userid: UUID,
                      previewImageLocation: String)
 ```
 
-Case classes are immutable and use the [fluent getter style](../../entities#getter-style), but you
+Case classes are immutable and use the [fluent getter style](../../entities/README.md#accessor-styles), but you
 don't need to declare that explicitly with [@PropertyStrategy]: the mapper detects when it's
 processing a case class, and will assume `mutable = false, getterStyle = FLUENT` by default.
 
diff --git a/manual/mapper/daos/README.md b/manual/mapper/daos/README.md
index d12172bf056..d069f2c9985 100644
--- a/manual/mapper/daos/README.md
+++ b/manual/mapper/daos/README.md
@@ -32,7 +32,7 @@ Interface annotated with [@Dao].
 -----
 
 A DAO is an interface that defines a set of query methods. In general, those queries will relate to
-the same [entity](../entities/) (although that is not a requirement).
+the same [entity](../entities/README.md) (although that is not a requirement).
 
 It must be annotated with [@Dao]:
 
@@ -55,22 +55,22 @@ public interface ProductDao {
 To add queries, define methods on your interface and mark them with one of the following
 annotations:
 
-* [@Delete](delete/)
-* [@GetEntity](getentity/)
-* [@Insert](insert/)
-* [@Query](query/)
-* [@QueryProvider](queryprovider/)
-* [@Select](select/)
-* [@SetEntity](setentity/)
-* [@Update](update/)
-* [@Increment](increment/)
+* [@Delete](delete/README.md)
+* [@GetEntity](getentity/README.md)
+* [@Insert](insert/README.md)
+* [@Query](query/README.md)
+* [@QueryProvider](queryprovider/README.md)
+* [@Select](select/README.md)
+* [@SetEntity](setentity/README.md)
+* [@Update](update/README.md)
+* [@Increment](increment/README.md)
 
 The methods can have any name. The allowed parameters and return type are specific to each
 annotation.
 
 ### Runtime usage
 
-To obtain a DAO instance, use a [factory method](../mapper/#dao-factory-methods) on the mapper
+To obtain a DAO instance, use a [factory method](../mapper/README.md#dao-factory-methods) on the mapper
 interface.
 
 ```java
@@ -171,4 +171,4 @@ To control how the hierarchy is scanned, annotate interfaces with [@HierarchySca
 [@DaoFactory]:   https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/mapper/annotations/DaoFactory.html
 [@DefaultNullSavingStrategy]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/mapper/annotations/DefaultNullSavingStrategy.html
 [@HierarchyScanStrategy]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/mapper/annotations/HierarchyScanStrategy.html
-[Entity Inheritance]: ../entities/#inheritance
+[Entity Inheritance]: ../entities/README.md#inheritance
diff --git a/manual/mapper/daos/custom_types/README.md b/manual/mapper/daos/custom_types/README.md
index 19f689655a7..d1235a02d4a 100644
--- a/manual/mapper/daos/custom_types/README.md
+++ b/manual/mapper/daos/custom_types/README.md
@@ -20,7 +20,7 @@ under the License.
 ## Custom result types
 
 The mapper supports a pre-defined set of built-in types for DAO method results. For example, a
-[Select](../select/#return-type) method can return a single entity, an asynchronous
+[Select](../select/README.md#return-type) method can return a single entity, an asynchronous
 `CompletionStage`, a `ReactiveResultSet`, etc.
 
 Sometimes it's convenient to use your own types. For example if you use a specific Reactive Streams
diff --git a/manual/mapper/daos/delete/README.md b/manual/mapper/daos/delete/README.md
index e67ecdc8a6e..c7b3453bd6b 100644
--- a/manual/mapper/daos/delete/README.md
+++ b/manual/mapper/daos/delete/README.md
@@ -19,7 +19,7 @@ under the License.
 
 ## Delete methods
 
-Annotate a DAO method with [@Delete] to generate a query that deletes an [Entity](../../entities):
+Annotate a DAO method with [@Delete] to generate a query that deletes an [Entity](../../entities/README.md):
 
 ```java
 @Dao
@@ -48,7 +48,7 @@ The method can operate on:
     ```
     
     In this case, the parameters must match the types of the [primary key
-    columns](../../entities/#primary-key-columns), in the exact order (as defined by the
+    columns](../../entities/README.md#primary-key-columns), in the exact order (as defined by the
     [@PartitionKey] and [@ClusteringColumn] annotations). The parameter names don't necessarily need
     to match the names of the columns.
     
@@ -99,7 +99,7 @@ void deleteIfDescriptionMatches(UUID productId, String expectedDescription);
 A `Function<BoundStatementBuilder, BoundStatementBuilder>` or `UnaryOperator<BoundStatementBuilder>`
 can be added as the **last** parameter. It will be applied to the statement before execution. This
 allows you to customize certain aspects of the request (page size, timeout, etc) at runtime. See
-[statement attributes](../statement_attributes/).
+[statement attributes](../statement_attributes/README.md).
 
 ### Return type
 
@@ -154,7 +154,7 @@ The method can return:
     ReactiveResultSet deleteReactive(Product product);
     ```
 
-* a [custom type](../custom_types).
+* a [custom type](../custom_types/README.md).
 
 Note that you can also return a boolean or result set for non-conditional queries, but there's no
 practical purpose for that since those queries always return `wasApplied = true` and an empty result
@@ -162,13 +162,13 @@ set.
 
 ### Target keyspace and table
 
-If a keyspace was specified [when creating the DAO](../../mapper/#dao-factory-methods), then the
+If a keyspace was specified [when creating the DAO](../../mapper/README.md#dao-factory-methods), then the
 generated query targets that keyspace. Otherwise, it doesn't specify a keyspace, and will only work
 if the mapper was built from a session that has a [default keyspace] set.
 
 If a table was specified when creating the DAO, then the generated query targets that table.
 Otherwise, it uses the default table name for the entity (which is determined by the name of the
-entity class and the [naming strategy](../../entities/#naming-strategy)).
+entity class and the [naming strategy](../../entities/README.md#naming-strategy)).
 
 [default keyspace]:       https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/session/SessionBuilder.html#withKeyspace-com.datastax.oss.driver.api.core.CqlIdentifier-
 [AsyncResultSet]:         https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/cql/AsyncResultSet.html
diff --git a/manual/mapper/daos/getentity/README.md b/manual/mapper/daos/getentity/README.md
index de9a530b558..bf8ff80a232 100644
--- a/manual/mapper/daos/getentity/README.md
+++ b/manual/mapper/daos/getentity/README.md
@@ -20,7 +20,7 @@ under the License.
 ## GetEntity methods
 
 Annotate a DAO method with [@GetEntity] to convert a core driver data structure into one or more
-[Entities](../../entities):
+[Entities](../../entities/README.md):
 
 ```java
 @Dao
diff --git a/manual/mapper/daos/increment/README.md b/manual/mapper/daos/increment/README.md
index 44b017be2e1..6559861de6e 100644
--- a/manual/mapper/daos/increment/README.md
+++ b/manual/mapper/daos/increment/README.md
@@ -50,10 +50,10 @@ public interface VotesDao {
 
 The entity class must be specified with `entityClass` in the annotation.
 
-The method's parameters must start with the [full primary key](../../entities/#primary-key-columns),
+The method's parameters must start with the [full primary key](../../entities/README.md#primary-key-columns),
 in the exact order (as defined by the [@PartitionKey] and [@ClusteringColumn] annotations in the
 entity class). The parameter names don't necessarily need to match the names of the columns, but the
-types must match. Unlike other methods like [@Select](../select/) or [@Delete](../delete/), counter
+types must match. Unlike other methods like [@Select](../select/README.md) or [@Delete](../delete/README.md), counter
 updates cannot operate on a whole partition, they need to target exactly one row; so all the
 partition key and clustering columns must be specified.
 
@@ -71,13 +71,13 @@ void incrementUpVotes(int articleId, @CqlName("up_votes") long foobar);
 When you invoke the method, each parameter value is interpreted as a **delta** that will be applied
 to the counter. In other words, if you pass 1, the counter will be incremented by 1. Negative values
 are allowed. If you are using Cassandra 2.2 or above, you can use `Long` and pass `null` for some of
-the parameters, they will be ignored (following [NullSavingStrategy#DO_NOT_SET](../null_saving/)
+the parameters, they will be ignored (following [NullSavingStrategy#DO_NOT_SET](../null_saving/README.md)
 semantics). If you are using Cassandra 2.1, `null` values will trigger a runtime error.
 
 A `Function<BoundStatementBuilder, BoundStatementBuilder>` or `UnaryOperator<BoundStatementBuilder>`
 can be added as the **last** parameter. It will be applied to the statement before execution. This
 allows you to customize certain aspects of the request (page size, timeout, etc) at runtime. See
-[statement attributes](../statement_attributes/).
+[statement attributes](../statement_attributes/README.md).
 
 ### Return type
 
@@ -86,7 +86,7 @@ The method can return `void`, a void [CompletionStage] or [CompletableFuture], o
 
 ### Target keyspace and table
 
-If a keyspace was specified [when creating the DAO](../../mapper/#dao-factory-methods), then the
+If a keyspace was specified [when creating the DAO](../../mapper/README.md#dao-factory-methods), then the
 generated query targets that keyspace. Otherwise, it doesn't specify a keyspace, and will only work
 if the mapper was built from a session that has a [default keyspace] set.
 
diff --git a/manual/mapper/daos/insert/README.md b/manual/mapper/daos/insert/README.md
index b90ffa33a32..02dbc59227c 100644
--- a/manual/mapper/daos/insert/README.md
+++ b/manual/mapper/daos/insert/README.md
@@ -19,7 +19,7 @@ under the License.
 
 ## Insert methods
 
-Annotate a DAO method with [@Insert] to generate a query that inserts an [Entity](../../entities):
+Annotate a DAO method with [@Insert] to generate a query that inserts an [Entity](../../entities/README.md):
 
 ```java
 @Dao
@@ -41,13 +41,13 @@ corresponding additional parameters (same name, and a compatible Java type):
 void insertWithTtl(Product product, int ttl);
 ```
 
-The annotation can define a [null saving strategy](../null_saving/) that applies to the properties
+The annotation can define a [null saving strategy](../null_saving/README.md) that applies to the properties
 of the entity to insert.
 
 A `Function<BoundStatementBuilder, BoundStatementBuilder>` or `UnaryOperator<BoundStatementBuilder>`
 can be added as the **last** parameter. It will be applied to the statement before execution. This
 allows you to customize certain aspects of the request (page size, timeout, etc) at runtime. See
-[statement attributes](../statement_attributes/).
+[statement attributes](../statement_attributes/README.md).
 
 ### Return type
 
@@ -115,17 +115,17 @@ The method can return:
     ReactiveResultSet insertReactive(Product product);
     ```
 
-* a [custom type](../custom_types).
+* a [custom type](../custom_types/README.md).
 
 ### Target keyspace and table
 
-If a keyspace was specified [when creating the DAO](../../mapper/#dao-factory-methods), then the
+If a keyspace was specified [when creating the DAO](../../mapper/README.md#dao-factory-methods), then the
 generated query targets that keyspace. Otherwise, it doesn't specify a keyspace, and will only work
 if the mapper was built from a session that has a [default keyspace] set.
 
 If a table was specified when creating the DAO, then the generated query targets that table.
 Otherwise, it uses the default table name for the entity (which is determined by the name of the
-entity class and the [naming strategy](../../entities/#naming-strategy)).
+entity class and the [naming strategy](../../entities/README.md#naming-strategy)).
 
 [default keyspace]:             https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/session/SessionBuilder.html#withKeyspace-com.datastax.oss.driver.api.core.CqlIdentifier-
 [@Insert]:                      https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/mapper/annotations/Insert.html
diff --git a/manual/mapper/daos/null_saving/README.md b/manual/mapper/daos/null_saving/README.md
index eed98934356..25d9985243b 100644
--- a/manual/mapper/daos/null_saving/README.md
+++ b/manual/mapper/daos/null_saving/README.md
@@ -37,7 +37,7 @@ Two strategies are available:
     update and the column previously had another value, it won't be overwritten.
 
     Note that unset values ([CASSANDRA-7304]) are only supported with [native
-    protocol](../../../core/native_protocol/) v4 (Cassandra 2.2) or above . If you try to use this
+    protocol](../../../core/native_protocol/README.md) v4 (Cassandra 2.2) or above . If you try to use this
     strategy with a lower Cassandra version, the mapper will throw an [MapperException] when you try
     to access the corresponding DAO.
 
@@ -60,12 +60,12 @@ import static com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrateg
 void update(Product product);
 ```
 
-This applies to [@Insert](../insert/), [@Query](../query/), [@SetEntity](../setentity/) and
-[@Update](../update/) (other method types don't need it since they don't write data).
+This applies to [@Insert](../insert/README.md), [@Query](../query/README.md), [@SetEntity](../setentity/README.md) and
+[@Update](../update/README.md) (other method types don't need it since they don't write data).
 
 ### DAO level
 
-Annotate your [DAO](../../daos/) interface with [@DefaultNullSavingStrategy]. Any method that does
+Annotate your [DAO](../README.md) interface with [@DefaultNullSavingStrategy]. Any method that does
 not explicitly define its strategy inherits the DAO-level one:
 
 ```java
diff --git a/manual/mapper/daos/query/README.md b/manual/mapper/daos/query/README.md
index a11753da880..bc56f17a91b 100644
--- a/manual/mapper/daos/query/README.md
+++ b/manual/mapper/daos/query/README.md
@@ -41,13 +41,13 @@ placeholders: same name and a compatible Java type.
 long countByIdAndYear(int id, int year);
 ```
 
-The annotation can define a [null saving strategy](../null_saving/) that applies to the method
+The annotation can define a [null saving strategy](../null_saving/README.md) that applies to the method
 parameters.
 
 A `Function<BoundStatementBuilder, BoundStatementBuilder>` or `UnaryOperator<BoundStatementBuilder>`
 can be added as the **last** parameter. It will be applied to the statement before execution. This
 allows you to customize certain aspects of the request (page size, timeout, etc) at runtime. See
-[statement attributes](../statement_attributes/).
+[statement attributes](../statement_attributes/README.md).
 
 ### Return type
 
@@ -65,7 +65,7 @@ The method can return:
 * a [Row]. This means the result is not converted, the mapper only extracts the first row of the
   result set and returns it. The method will return `null` if the result set is empty.
 
-* a single instance of an [Entity](../../entities/) class. The method will extract the first row and
+* a single instance of an [Entity](../../entities/README.md) class. The method will extract the first row and
   convert it, or return `null` if the result set is empty.
   
 * an [Optional] of an entity class. The method will extract the first row and convert
@@ -87,14 +87,14 @@ The method can return:
   
 * a [ReactiveResultSet], or a [MappedReactiveResultSet] of the entity class.
 
-* a [custom type](../custom_types).
+* a [custom type](../custom_types/README.md).
 
 ### Target keyspace and table
 
 To avoid hard-coding the keyspace and table name, the query string supports 3 additional
 placeholders: `${keyspaceId}`, `${tableId}` and `${qualifiedTableId}`. They get substituted at DAO
 initialization time, with the [keyspace and table that the DAO was built
-with](../../mapper/#dao-factory-methods).
+with](../../mapper/README.md#dao-factory-methods).
 
 For example, given the following:
 
diff --git a/manual/mapper/daos/queryprovider/README.md b/manual/mapper/daos/queryprovider/README.md
index 593a3a6b1a4..0a6b1d2649e 100644
--- a/manual/mapper/daos/queryprovider/README.md
+++ b/manual/mapper/daos/queryprovider/README.md
@@ -43,7 +43,7 @@ Use this for requests that can't be expressed as static query strings. For examp
 * if `day` is null, we query for the whole month: `WHERE id = ? AND month = ?`
 * if `month` is also null, we query the whole partition: `WHERE id = ?`
 
-We assume that you've already written a corresponding [entity](../../entities/) class:
+We assume that you've already written a corresponding [entity](../../entities/README.md) class:
 
 ```java
 @Entity
@@ -72,7 +72,7 @@ additional [EntityHelper] argument for each provided entity class. We specified
 `SensorReading.class` so our argument types are `(MapperContext, EntityHelper<SensorReading>)`.
 
 An entity helper is a utility type generated by the mapper. One thing it can do is construct query
-templates (with the [query builder](../../../query_builder/)). We want to retrieve entities so we
+templates (with the [query builder](../../../query_builder/README.md)). We want to retrieve entities so we
 use `selectStart()`, chain a first WHERE clause for the id (which is always present), and store the
 result in a field for later use:
 
diff --git a/manual/mapper/daos/select/README.md b/manual/mapper/daos/select/README.md
index fb6c4ca2077..7e8913e28dd 100644
--- a/manual/mapper/daos/select/README.md
+++ b/manual/mapper/daos/select/README.md
@@ -20,7 +20,7 @@ under the License.
 ## Select methods
 
 Annotate a DAO method with [@Select] to generate a query that selects one or more rows, and maps
-them to [Entities](../../entities):
+them to [Entities](../../entities/README.md):
 
 ```java
 @Dao
@@ -34,7 +34,7 @@ public interface ProductDao {
 
 If the annotation doesn't have a [customWhereClause()], the mapper defaults to a selection by
 primary key (partition key + clustering columns). The method's parameters must match the types of
-the [primary key columns](../../entities/#primary-key-columns), in the exact order (as defined by
+the [primary key columns](../../entities/README.md#primary-key-columns), in the exact order (as defined by
 the [@PartitionKey] and [@ClusteringColumn] annotations). The parameter names don't necessarily need
 to match the names of the columns.
 
@@ -85,7 +85,7 @@ whose values will be provided through additional method parameters. Note that it
 possible to determine if a parameter is a primary key component or a placeholder value; therefore
 the rule is that **if your method takes a partial primary key, the first parameter that is not a
 primary key component must be explicitly annotated with
-[@CqlName](../../entities/#user-provided-names)**. For example if the primary key is `((day int,
+[@CqlName](../../entities/README.md#user-provided-names)**. For example if the primary key is `((day int,
 hour int, minute int), ts timestamp)`:
 
 ```java
@@ -97,7 +97,7 @@ PagingIterable<Sale> findDailySales(int day, @CqlName("l") int l);
 A `Function<BoundStatementBuilder, BoundStatementBuilder>` or `UnaryOperator<BoundStatementBuilder>`
 can be added as the **last** parameter. It will be applied to the statement before execution. This
 allows you to customize certain aspects of the request (page size, timeout, etc) at runtime. See
-[statement attributes](../statement_attributes/).
+[statement attributes](../statement_attributes/README.md).
 
 ### Return type
 
@@ -167,17 +167,17 @@ In all cases, the method can return:
     MappedReactiveResultSet<Product> findByDescriptionReactive(String searchString);
     ```
 
-* a [custom type](../custom_types).
+* a [custom type](../custom_types/README.md).
 
 ### Target keyspace and table
 
-If a keyspace was specified [when creating the DAO](../../mapper/#dao-factory-methods), then the
+If a keyspace was specified [when creating the DAO](../../mapper/README.md#dao-factory-methods), then the
 generated query targets that keyspace. Otherwise, it doesn't specify a keyspace, and will only work
 if the mapper was built from a session that has a [default keyspace] set.
 
 If a table was specified when creating the DAO, then the generated query targets that table.
 Otherwise, it uses the default table name for the entity (which is determined by the name of the
-entity class and the [naming strategy](../../entities/#naming-strategy)).
+entity class and the [naming strategy](../../entities/README.md#naming-strategy)).
 
 [default keyspace]:          https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/session/SessionBuilder.html#withKeyspace-com.datastax.oss.driver.api.core.CqlIdentifier-
 [@ClusteringColumn]:         https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/mapper/annotations/ClusteringColumn.html
diff --git a/manual/mapper/daos/setentity/README.md b/manual/mapper/daos/setentity/README.md
index eeb7957f62e..0fc7a8c014b 100644
--- a/manual/mapper/daos/setentity/README.md
+++ b/manual/mapper/daos/setentity/README.md
@@ -20,7 +20,7 @@ under the License.
 ## SetEntity methods
 
 Annotate a DAO method with [@SetEntity] to fill a core driver data structure from an
-[Entity](../../entities):
+[Entity](../../entities/README.md):
 
 ```java
 public interface ProductDao {
@@ -97,7 +97,7 @@ The method must have two parameters: one is the entity instance, the other must
 
 The order of the parameters does not matter.
 
-The annotation can define a [null saving strategy](../null_saving/) that applies to the properties
+The annotation can define a [null saving strategy](../null_saving/README.md) that applies to the properties
 of the object to set. This is only really useful with bound statements (or bound statement
 builders): if the target is a [UdtValue], the driver sends null fields in the serialized form
 anyway, so both strategies are equivalent.
diff --git a/manual/mapper/daos/statement_attributes/README.md b/manual/mapper/daos/statement_attributes/README.md
index f772df36775..ded66bcbbd7 100644
--- a/manual/mapper/daos/statement_attributes/README.md
+++ b/manual/mapper/daos/statement_attributes/README.md
@@ -19,8 +19,8 @@ under the License.
 
 ## Statement attributes
 
-The [@Delete](../delete/), [@Insert](../insert/), [@Query](../query/), [@Select](../select/) and
-[@Update](../update/) annotations allow you to control some aspects of the execution of the
+The [@Delete](../delete/README.md), [@Insert](../insert/README.md), [@Query](../query/README.md), [@Select](../select/README.md) and
+[@Update](../update/README.md) annotations allow you to control some aspects of the execution of the
 underlying statement, such as the consistency level, timeout, etc.
 
 ### As a parameter
diff --git a/manual/mapper/daos/update/README.md b/manual/mapper/daos/update/README.md
index 87e9286c800..89f47f7a31c 100644
--- a/manual/mapper/daos/update/README.md
+++ b/manual/mapper/daos/update/README.md
@@ -20,7 +20,7 @@ under the License.
 ## Update methods
 
 Annotate a DAO method with [@Update] to generate a query that updates one or more
-[entities](../../entities):
+[entities](../../entities/README.md):
 
 ```java
 @Dao
@@ -77,7 +77,7 @@ with `customIfClause` (if both are set, the mapper processor will generate a com
 boolean updateIfExists(Product product);
 ```
 
-The annotation can define a [null saving strategy](../null_saving/) that applies to the properties
+The annotation can define a [null saving strategy](../null_saving/README.md) that applies to the properties
 of the entity to update. This allows you to implement partial updates, by passing a "template"
 entity that only contains the properties you want to modify:
 
@@ -95,7 +95,7 @@ dao.updateWhereIdIn(template, 42, 43);  // Will only update 'description' on the
 A `Function<BoundStatementBuilder, BoundStatementBuilder>` or `UnaryOperator<BoundStatementBuilder>`
 can be added as the **last** parameter. It will be applied to the statement before execution. This
 allows you to customize certain aspects of the request (page size, timeout, etc) at runtime. See
-[statement attributes](../statement_attributes/).
+[statement attributes](../statement_attributes/README.md).
 
 ### Return type
 
@@ -150,11 +150,11 @@ The method can return:
     ReactiveResultSet updateReactive(Product product);
     ```
 
-* a [custom type](../custom_types).
+* a [custom type](../custom_types/README.md).
 
 ### Target keyspace and table
 
-If a keyspace was specified [when creating the DAO](../../mapper/#dao-factory-methods), then the
+If a keyspace was specified [when creating the DAO](../../mapper/README.md#dao-factory-methods), then the
 generated query targets that keyspace. Otherwise, it doesn't specify a keyspace, and will only work
 if the mapper was built from a session that has a [default keyspace] set.
 
diff --git a/manual/mapper/entities/README.md b/manual/mapper/entities/README.md
index 978c781245f..de46fa4963b 100644
--- a/manual/mapper/entities/README.md
+++ b/manual/mapper/entities/README.md
@@ -38,8 +38,8 @@ POJO annotated with [@Entity], must expose a no-arg constructor.
 
 -----
 
-An entity is a Java class that will be mapped to a Cassandra table or [UDT](../../core/udts).
-Entities are used as arguments or return types of [DAO](../daos/) methods; they can also be nested
+An entity is a Java class that will be mapped to a Cassandra table or [UDT](../../core/udts/README.md).
+Entities are used as arguments or return types of [DAO](../daos/README.md) methods; they can also be nested
 inside other entities (to map UDT columns).
 
 In order to be detected by the mapper, the class must be annotated with [@Entity]:
@@ -280,7 +280,7 @@ private int day;
 ```
 
 This information is used by some of the DAO method annotations; for example,
-[@Select](../daos/select/)'s default behavior is to generate a selection by primary key.
+[@Select](../daos/select/README.md)'s default behavior is to generate a selection by primary key.
 
 #### Computed properties
 
diff --git a/manual/mapper/mapper/README.md b/manual/mapper/mapper/README.md
index 752424c9a3b..fc7d6218309 100644
--- a/manual/mapper/mapper/README.md
+++ b/manual/mapper/mapper/README.md
@@ -30,7 +30,7 @@ Interface annotated with [@Mapper], entry point to mapper features.
 -----
 
 The mapper interface is the top-level entry point to mapping features. It wraps a core driver
-session, and acts as a factory of [DAO](../daos/) objects that will be used to execute requests.
+session, and acts as a factory of [DAO](../daos/README.md) objects that will be used to execute requests.
 
 It must be annotated with [@Mapper]:
 
@@ -58,7 +58,7 @@ public interface InventoryMapper {
 ```
 
 The builder allows you to create a mapper instance, by wrapping a core `CqlSession` (if you need
-more details on how to create a session, refer to the [core driver documentation](../../core/)).
+more details on how to create a session, refer to the [core driver documentation](../../core/README.md)).
 
 ```java
 CqlSession session = CqlSession.builder().build();
@@ -161,7 +161,7 @@ ProductDao dao3 = inventoryMapper.productDao("keyspace3", "table3");
 
 * `dao1.findById` executes the query `SELECT ... FROM product WHERE id = ?`. No table name was
   specified for the DAO, so it uses the default name for the `Product` entity (which in this case is
-  the entity name converted with the default [naming strategy](../entities/#naming-strategy)). No
+  the entity name converted with the default [naming strategy](../entities/README.md#naming-strategy)). No
   keyspace was specified either, so the table is unqualified, and this DAO will only work with a
   session that was built with a default keyspace:
 
@@ -178,12 +178,12 @@ ProductDao dao3 = inventoryMapper.productDao("keyspace3", "table3");
   = ?`.
 
 The DAO's keyspace and table can also be injected into custom query strings; see [Query
-methods](../daos/query/).
+methods](../daos/query/README.md).
 
 #### Execution profile
 
 Similarly, a DAO can be parameterized to use a particular [configuration
-profile](../../core/configuration/#execution-profiles):
+profile](../../core/configuration/README.md#execution-profiles):
 
 ```java
 @Mapper
@@ -212,7 +212,7 @@ ProductDao dao2 = inventoryMapper.productDao("keyspace2", "product");
 ```
 
 For each entity referenced in the DAO, the mapper tries to find a schema element with the
-corresponding name (according to the [naming strategy](../entities/#naming-strategy)). It tries
+corresponding name (according to the [naming strategy](../entities/README.md#naming-strategy)). It tries
 tables first, then falls back to UDTs if there is no match. You can speed up this process by
 providing a hint:
 
@@ -228,12 +228,12 @@ public class Address { ... }
 The following checks are then performed:
 
 * for each entity field, the database table or UDT must contain a column with the corresponding name
-  (according to the [naming strategy](../entities/#naming-strategy)).
+  (according to the [naming strategy](../entities/README.md#naming-strategy)).
 * the types must be compatible, either according to the [default type
-  mappings](../../core/#cql-to-java-type-mapping), or via a [custom
-  codec](../../core/custom_codecs/) registered with the session.
+  mappings](../../core/README.md#cql-to-java-type-mapping), or via a [custom
+  codec](../../core/custom_codecs/README.md) registered with the session.
 * additionally, if the target element is a table, the primary key must be [properly
-  annotated](../entities/#primary-key-columns) in the entity.
+  annotated](../entities/README.md#primary-key-columns) in the entity.
  
 If any of those steps fails, an `IllegalArgumentException` is thrown.
 
diff --git a/manual/osgi/README.md b/manual/osgi/README.md
index 92cd4625b68..d35c6c66088 100644
--- a/manual/osgi/README.md
+++ b/manual/osgi/README.md
@@ -29,7 +29,7 @@ valid OSGi bundles:
 
 Note: some of the driver dependencies are not valid OSGi bundles. Most of them are optional, and the
 driver can work properly without them (see the
-[Integration>Driver dependencies](../core/integration/#driver-dependencies) section for more
+[Integration>Driver dependencies](../core/integration/README.md#driver-dependencies) section for more
 details); in such cases, the corresponding packages are declared with optional resolution in
 `Import-Package` directives. However, if you need to access such packages in an OSGi container you
 MUST wrap the corresponding jar in a valid OSGi bundle and make it available for provisioning to the
@@ -40,7 +40,7 @@ OSGi runtime.
 `java-driver-core-shaded` shares the same bundle name as `java-driver-core`
 (`com.datastax.oss.driver.core`).  It can be used as a drop-in replacement in cases where you have
 an explicit version of dependency in your project different than that of the driver's.  Refer to
-[shaded jar](../core/shaded_jar/) for more information.
+[shaded jar](../core/shaded_jar/README.md) for more information.
 
 ## Using a custom `ClassLoader`
 
@@ -136,7 +136,7 @@ The above configuration will honor all programmatic settings, but will look for
 ## What does the "Error loading libc" DEBUG message mean?
 
 The driver is able to perform native system calls through [JNR] in some cases, for example to
-achieve microsecond resolution when [generating timestamps](../core/query_timestamps/).
+achieve microsecond resolution when [generating timestamps](../core/query_timestamps/README.md).
 
 Unfortunately, some of the JNR artifacts available from Maven are not valid OSGi bundles and cannot
 be used in OSGi applications.
@@ -154,7 +154,7 @@ starting the driver:
     system clock
 
 
-[driver configuration]: ../core/configuration
+[driver configuration]: ../core/configuration/README.md
 [OSGi]:https://www.osgi.org
 [JNR]: https://github.com/jnr/jnr-posix
 [withClassLoader()]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/core/session/SessionBuilder.html#withClassLoader-java.lang.ClassLoader-
diff --git a/manual/query_builder/README.md b/manual/query_builder/README.md
index d1932b329e7..a5121f9914a 100644
--- a/manual/query_builder/README.md
+++ b/manual/query_builder/README.md
@@ -81,7 +81,7 @@ Select select =
 ```
 
 When your query is complete, you can either extract a raw query string, or turn it into a
-[simple statement](../core/statements/simple) (or its builder):
+[simple statement](../core/statements/simple/README.md) (or its builder):
 
 ```java
 String cql = select.asCql();
@@ -137,7 +137,7 @@ On the downside, immutability means that the query builder creates lots of short
 Modern garbage collectors are good at handling that, but still we recommend that you **avoid using
 the query builder in your hot path**:
 
-* favor [bound statements](../core/statements/prepared) for queries that are used often. You can
+* favor [bound statements](../core/statements/prepared/README.md) for queries that are used often. You can
   still use the query builder and prepare the result:
   
   ```java
@@ -157,7 +157,7 @@ the query builder in your hot path**:
 
 All fluent API methods use [CqlIdentifier] for schema element names (keyspaces, tables, columns...).
 But, for convenience, there are also `String` overloads that take the CQL form (as see [Case
-sensitivity](../case_sensitivity) for more explanations).
+sensitivity](../case_sensitivity/README.md) for more explanations).
 
 For conciseness, we'll use the string-based versions for the examples in this manual.
 
@@ -219,17 +219,17 @@ a better alternative.
 For a complete tour of the API, browse the child pages in this manual:
 
 * statement types:
-  * [SELECT](select/)
-  * [INSERT](insert/)
-  * [UPDATE](update/)
-  * [DELETE](delete/)
-  * [TRUNCATE](truncate/)
-  * [Schema builder](schema/) (for DDL statements such as CREATE TABLE, etc.)
+  * [SELECT](select/README.md)
+  * [INSERT](insert/README.md)
+  * [UPDATE](update/README.md)
+  * [DELETE](delete/README.md)
+  * [TRUNCATE](truncate/README.md)
+  * [Schema builder](schema/README.md) (for DDL statements such as CREATE TABLE, etc.)
 * common topics:
-  * [Relations](relation/)
-  * [Conditions](condition/)
-  * [Terms](term/)
-  * [Idempotence](idempotence/)
+  * [Relations](relation/README.md)
+  * [Conditions](condition/README.md)
+  * [Terms](term/README.md)
+  * [Idempotence](idempotence/README.md)
   
 [QueryBuilder]:  https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/querybuilder/QueryBuilder.html
 [SchemaBuilder]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/querybuilder/SchemaBuilder.html
diff --git a/manual/query_builder/condition/README.md b/manual/query_builder/condition/README.md
index 1a6a37eb2ef..bb8b902bfe9 100644
--- a/manual/query_builder/condition/README.md
+++ b/manual/query_builder/condition/README.md
@@ -19,8 +19,8 @@ under the License.
 
 ## Conditions
 
-A condition is a clause that appears after the IF keyword in a conditional [UPDATE](../update/) or
-[DELETE](../delete/) statement.
+A condition is a clause that appears after the IF keyword in a conditional [UPDATE](../update/README.md) or
+[DELETE](../delete/README.md) statement.
 
 The easiest way to add a condition is with an `ifXxx` method in the fluent API:
 
@@ -59,7 +59,7 @@ deleteFrom("user")
 ```
 
 Conditions are composed of a left operand, an operator, and a right-hand-side
-[term](../term/).
+[term](../term/README.md).
 
 ### Simple columns
 
diff --git a/manual/query_builder/delete/README.md b/manual/query_builder/delete/README.md
index 8e97920ae9f..3f62c792bd1 100644
--- a/manual/query_builder/delete/README.md
+++ b/manual/query_builder/delete/README.md
@@ -21,7 +21,7 @@ under the License.
 
 To start a DELETE query, use one of the `deleteFrom` methods in [QueryBuilder]. There are several
 variants depending on whether your table name is qualified, and whether you use
-[identifiers](../../case_sensitivity/) or raw strings:
+[identifiers](../../case_sensitivity/README.md) or raw strings:
 
 ```java
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.*;
@@ -134,7 +134,7 @@ SimpleStatement statement = deleteFrom("user").whereColumn("k").isEqualTo(bindMa
 ```
 
 Relations are a common feature used by many types of statements, so they have a
-[dedicated page](../relation) in this manual.
+[dedicated page](../relation/README.md) in this manual.
 
 ### Conditions
 
@@ -158,7 +158,7 @@ deleteFrom("user")
 ```
 
 Conditions are a common feature used by UPDATE and DELETE, so they have a
-[dedicated page](../condition) in this manual.
+[dedicated page](../condition/README.md) in this manual.
 
 [QueryBuilder]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/querybuilder/QueryBuilder.html
 [Selector]:     https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/querybuilder/select/Selector.html
diff --git a/manual/query_builder/idempotence/README.md b/manual/query_builder/idempotence/README.md
index 2f97151d277..1c44be31792 100644
--- a/manual/query_builder/idempotence/README.md
+++ b/manual/query_builder/idempotence/README.md
@@ -20,7 +20,7 @@ under the License.
 ## Idempotence in the query builder
 
 When you generate a statement (or a statement builder) from the query builder, it automatically
-infers the [isIdempotent](../../core/idempotence/) flag:
+infers the [isIdempotent](../../core/idempotence/README.md) flag:
 
 ```java
 SimpleStatement statement =
diff --git a/manual/query_builder/insert/README.md b/manual/query_builder/insert/README.md
index 6bac896d9b8..806eace154d 100644
--- a/manual/query_builder/insert/README.md
+++ b/manual/query_builder/insert/README.md
@@ -21,7 +21,7 @@ under the License.
 
 To start an INSERT query, use one of the `insertInto` methods in [QueryBuilder]. There are
 several variants depending on whether your table name is qualified, and whether you use
-[identifiers](../../case_sensitivity/) or raw strings:
+[identifiers](../../case_sensitivity/README.md) or raw strings:
 
 ```java
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.*;
@@ -46,7 +46,7 @@ insertInto("user")
 // INSERT INTO user (id,first_name,last_name) VALUES (?,'John','Doe')
 ```
 
-The column names can only be simple identifiers. The values are [terms](../term).
+The column names can only be simple identifiers. The values are [terms](../term/README.md).
 
 #### JSON insert
 
diff --git a/manual/query_builder/relation/README.md b/manual/query_builder/relation/README.md
index eb1c728888e..5ce171afe02 100644
--- a/manual/query_builder/relation/README.md
+++ b/manual/query_builder/relation/README.md
@@ -24,10 +24,10 @@ statement operates on.
 
 Relations are used by the following statements:
 
-* [SELECT](../select/) 
-* [UPDATE](../update/)
-* [DELETE](../delete/)
-* [CREATE MATERIALIZED VIEW](../schema/materialized_view/)
+* [SELECT](../select/README.md) 
+* [UPDATE](../update/README.md)
+* [DELETE](../delete/README.md)
+* [CREATE MATERIALIZED VIEW](../schema/materialized_view/README.md)
 
 The easiest way to add a relation is with a `whereXxx` method in the fluent API:
 
@@ -60,7 +60,7 @@ selectFrom("sensor_data").all()
 ```
 
 Relations are generally composed of a left operand, an operator, and an optional right-hand-side
-[term](../term/). The type of relation determines which operators are available.
+[term](../term/README.md). The type of relation determines which operators are available.
  
 ### Simple columns
 
diff --git a/manual/query_builder/schema/README.md b/manual/query_builder/schema/README.md
index 0472c8e8c6f..ac8eb9bfe5b 100644
--- a/manual/query_builder/schema/README.md
+++ b/manual/query_builder/schema/README.md
@@ -19,7 +19,7 @@ under the License.
 
 # Schema builder
 
-The schema builder is an additional API provided by [java-driver-query-builder](../) that enables
+The schema builder is an additional API provided by [java-driver-query-builder](../README.md) that enables
 one to *generate CQL DDL queries programmatically**.  For example it could be used to:
 
 * based on application configuration, generate schema queries instead of building CQL strings by
@@ -46,7 +46,7 @@ try (CqlSession session = CqlSession.builder().build()) {
 }
 ```
 
-The [general concepts](../#general-concepts) and [non goals](../#non-goals) defined for the query
+The [general concepts](../README.md#general-concepts) and [non goals](../README.md#non-goals) defined for the query
 builder also apply for the schema builder.
 
 ### Building DDL Queries
@@ -55,12 +55,12 @@ The schema builder offers functionality for creating, altering and dropping elem
 schema.  For a complete tour of the API, browse the child pages in the manual for each schema
 element type:
 
-* [keyspace](keyspace/)
-* [table](table/)
-* [index](index/)
-* [materialized view](materialized_view/)
-* [type](type/)
-* [function](function/)
-* [aggregate](aggregate/)
+* [keyspace](keyspace/README.md)
+* [table](table/README.md)
+* [index](index/README.md)
+* [materialized view](materialized_view/README.md)
+* [type](type/README.md)
+* [function](function/README.md)
+* [aggregate](aggregate/README.md)
 
 [SchemaBuilder]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/querybuilder/SchemaBuilder.html
diff --git a/manual/query_builder/schema/materialized_view/README.md b/manual/query_builder/schema/materialized_view/README.md
index c4f495f95aa..659b5f345af 100644
--- a/manual/query_builder/schema/materialized_view/README.md
+++ b/manual/query_builder/schema/materialized_view/README.md
@@ -45,7 +45,7 @@ There are a number of steps that must be executed to complete a materialized vie
 
 * Specify the base table using `asSelectFrom`
 * Specify the columns to include in the view via `column` or `columns` 
-* Specify the where clause using [relations](../../relation)
+* Specify the where clause using [relations](../../relation/README.md)
 * Specify the partition key columns using `withPartitionKey` and `withClusteringColumn`
 
 For example, the following defines a complete `CREATE MATERIALIZED VIEW` statement:
@@ -66,7 +66,7 @@ createMaterializedView("cycling", "cyclist_by_age")
 
 Please note that not all WHERE clause relations may be compatible with materialized views.
 
-Like a [table](../table), one may additionally provide configuration such as clustering order,
+Like a [table](../table/README.md), one may additionally provide configuration such as clustering order,
 compaction options and so on.  Refer to [RelationStructure] for documentation on additional
 configuration that may be provided for a view.
 
diff --git a/manual/query_builder/select/README.md b/manual/query_builder/select/README.md
index 0425423a402..fe1a5be8102 100644
--- a/manual/query_builder/select/README.md
+++ b/manual/query_builder/select/README.md
@@ -21,7 +21,7 @@ under the License.
 
 Start your SELECT with the `selectFrom` method in [QueryBuilder]. There are several variants
 depending on whether your table name is qualified, and whether you use
-[identifiers](../../case_sensitivity/) or raw strings:
+[identifiers](../../case_sensitivity/README.md) or raw strings:
 
 ```java
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.*;
@@ -321,7 +321,7 @@ selectFrom("foo").quotient(literal(1), Selector.column("a"));
 // SELECT 1/a FROM foo
 ```
 
-See the [terms](../term/#literals) section for more details on literals.
+See the [terms](../term/README.md#literals) section for more details on literals.
 
 #### Raw snippets
 
@@ -358,7 +358,7 @@ Like selectors, they also have fluent shortcuts to build and add in a single cal
 
 
 Relations are a common feature used by many types of statements, so they have a
-[dedicated page](../relation) in this manual.
+[dedicated page](../relation/README.md) in this manual.
 
 ### Other clauses
 
diff --git a/manual/query_builder/term/README.md b/manual/query_builder/term/README.md
index 460ed8dcb10..2f030025894 100644
--- a/manual/query_builder/term/README.md
+++ b/manual/query_builder/term/README.md
@@ -21,9 +21,9 @@ under the License.
 
 A term is an expression that does not involve the value of a column. It is used:
 
-* as an argument to some selectors, for example the indices of [sub-element](../select/#sub-element)
+* as an argument to some selectors, for example the indices of [sub-element](../select/README.md#sub-elements)
   selectors;
-* as the right operand of [relations](../relation).
+* as the right operand of [relations](../relation/README.md).
 
 To create a term, call one of the factory methods in [QueryBuilder]:
 
@@ -37,10 +37,10 @@ selectFrom("user").all().whereColumn("id").isEqualTo(literal(1));
 ```
 
 The argument is converted according to the driver's
-[default type mappings](../../core/#cql-to-java-type-mapping). If there is no default mapping, you
+[default type mappings](../../core/README.md#cql-to-java-type-mapping). If there is no default mapping, you
 will get a `CodecNotFoundException`.
 
-If you use [custom codecs](../../core/custom_codecs), you might need to inline a custom Java type.
+If you use [custom codecs](../../core/custom_codecs/README.md), you might need to inline a custom Java type.
 You can pass a [CodecRegistry] as the second argument (most likely, this will be the registry of
 your session):
 
diff --git a/manual/query_builder/truncate/README.md b/manual/query_builder/truncate/README.md
index c8cd6945123..9de93606293 100644
--- a/manual/query_builder/truncate/README.md
+++ b/manual/query_builder/truncate/README.md
@@ -21,7 +21,7 @@ under the License.
 
 To create a TRUNCATE query, use one of the `truncate` methods in [QueryBuilder]. There are several
 variants depending on whether your table name is qualified, and whether you use
-[identifiers](../../case_sensitivity/) or raw strings:
+[identifiers](../../case_sensitivity/README.md) or raw strings:
 
 ```java
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.*;
diff --git a/manual/query_builder/update/README.md b/manual/query_builder/update/README.md
index 15502f52bb7..e5484780e1d 100644
--- a/manual/query_builder/update/README.md
+++ b/manual/query_builder/update/README.md
@@ -21,7 +21,7 @@ under the License.
 
 To start an UPDATE query, use one of the `update` methods in [QueryBuilder]. There are several
 variants depending on whether your table name is qualified, and whether you use
-[identifiers](../../case_sensitivity/) or raw strings:
+[identifiers](../../case_sensitivity/README.md) or raw strings:
 
 ```java
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.*;
@@ -242,7 +242,7 @@ SimpleStatement statement = update("foo")
 ```
 
 Relations are a common feature used by many types of statements, so they have a
-[dedicated page](../relation) in this manual.
+[dedicated page](../relation/README.md) in this manual.
 
 ### Conditions
 
@@ -268,7 +268,7 @@ update("foo")
 ```
 
 Conditions are a common feature used by UPDATE and DELETE, so they have a
-[dedicated page](../condition) in this manual.
+[dedicated page](../condition/README.md) in this manual.
 
 [QueryBuilder]: https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/querybuilder/QueryBuilder.html
 [Assignment]:   https://docs.datastax.com/en/drivers/java/4.17/com/datastax/oss/driver/api/querybuilder/update/Assignment.html
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 00000000000..eafd4909813
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,177 @@
+site_name: Java Driver for Apache Cassandra
+site_description: Java Driver for Apache Cassandra® Documentation
+site_url: https://apache.github.io/cassandra-java-driver
+repo_url: https://github.com/apache/cassandra-java-driver
+repo_name: apache/cassandra-java-driver
+
+docs_dir: mkdocs
+site_dir: docs
+
+theme:
+  name: material
+  logo: faq/logo.png
+  favicon: faq/favicon.ico
+  features:
+    - navigation.tabs
+    - navigation.top
+    - navigation.path
+    - search.highlight
+    - search.share
+
+markdown_extensions:
+  - admonition
+  - codehilite
+  - pymdownx.superfences
+  - pymdownx.tabbed
+  - toc:
+      toc_depth: 2-3
+      permalink: true
+
+nav:
+  - Home: README.md
+  - Manual:
+    - Overview: manual/README.md
+    - API Conventions: manual/api_conventions/README.md
+    - Case Sensitivity: manual/case_sensitivity/README.md
+    - Cloud: manual/cloud/README.md
+    - Core:
+      - Overview: manual/core/README.md
+      - Integration: manual/core/integration/README.md
+      - Configuration:
+        - Overview: manual/core/configuration/README.md
+        - Reference: manual/core/configuration/reference/README.md
+      - Connection Management:
+        - Authentication: manual/core/authentication/README.md
+        - SSL: manual/core/ssl/README.md
+        - Pooling: manual/core/pooling/README.md
+        - Load Balancing: manual/core/load_balancing/README.md
+        - Reconnection: manual/core/reconnection/README.md
+        - Address Resolution: manual/core/address_resolution/README.md
+      - Statements:
+        - Overview: manual/core/statements/README.md
+        - Batch: manual/core/statements/batch/README.md
+        - Per Query Keyspace: manual/core/statements/per_query_keyspace/README.md
+        - Prepared: manual/core/statements/prepared/README.md
+        - Simple: manual/core/statements/simple/README.md
+      - Query Execution:
+        - Retries: manual/core/retries/README.md
+        - Idempotence: manual/core/idempotence/README.md
+        - Speculative Execution: manual/core/speculative_execution/README.md
+        - Paging: manual/core/paging/README.md
+        - Query Timestamps: manual/core/query_timestamps/README.md
+      - Advanced Types:
+        - Custom Codecs: manual/core/custom_codecs/README.md
+        - Temporal Types: manual/core/temporal_types/README.md
+        - Tuples: manual/core/tuples/README.md
+        - UDTs: manual/core/udts/README.md
+        - Detachable Types: manual/core/detachable_types/README.md
+      - Non-blocking:
+        - Overview: manual/core/non_blocking/README.md
+        - Async Programming: manual/core/async/README.md
+        - Reactive Streams: manual/core/reactive/README.md
+      - Observability:
+        - Request Tracker: manual/core/request_tracker/README.md
+        - Request ID: manual/core/request_id/README.md
+        - Metrics: manual/core/metrics/README.md
+        - Logging: manual/core/logging/README.md
+        - Tracing: manual/core/tracing/README.md
+      - Performance:
+        - Overview: manual/core/performance/README.md
+        - Throttling: manual/core/throttling/README.md
+        - Compression: manual/core/compression/README.md
+      - Metadata:
+        - Overview: manual/core/metadata/README.md
+        - Node: manual/core/metadata/node/README.md
+        - Schema: manual/core/metadata/schema/README.md
+        - Token: manual/core/metadata/token/README.md
+      - Driver Internals:
+        - Control Connection: manual/core/control_connection/README.md
+        - Native Protocol: manual/core/native_protocol/README.md
+      - DataStax DSE:
+        - Overview: manual/core/dse/README.md
+        - Geotypes: manual/core/dse/geotypes/README.md
+        - Graph:
+          - Overview: manual/core/dse/graph/README.md
+          - Fluent:
+            - Overview: manual/core/dse/graph/fluent/README.md
+            - Explicit: manual/core/dse/graph/fluent/explicit/README.md
+            - Implicit: manual/core/dse/graph/fluent/implicit/README.md
+          - Options: manual/core/dse/graph/options/README.md
+          - Results: manual/core/dse/graph/results/README.md
+          - Script: manual/core/dse/graph/script/README.md
+      - GraalVM: manual/core/graalvm/README.md
+      - Shaded JAR: manual/core/shaded_jar/README.md
+      - BOM: manual/core/bom/README.md
+    - Query Builder:
+      - Overview: manual/query_builder/README.md
+      - Select: manual/query_builder/select/README.md
+      - Insert: manual/query_builder/insert/README.md
+      - Update: manual/query_builder/update/README.md
+      - Delete: manual/query_builder/delete/README.md
+      - Schema:
+        - Overview: manual/query_builder/schema/README.md
+        - Aggregate: manual/query_builder/schema/aggregate/README.md
+        - Function: manual/query_builder/schema/function/README.md
+        - Index: manual/query_builder/schema/index/README.md
+        - Keyspace: manual/query_builder/schema/keyspace/README.md
+        - Materialized View: manual/query_builder/schema/materialized_view/README.md
+        - Table: manual/query_builder/schema/table/README.md
+        - Type: manual/query_builder/schema/type/README.md
+      - Truncate: manual/query_builder/truncate/README.md
+      - Condition: manual/query_builder/condition/README.md
+      - Relation: manual/query_builder/relation/README.md
+      - Term: manual/query_builder/term/README.md
+      - Idempotence: manual/query_builder/idempotence/README.md
+    - Mapper:
+      - Overview: manual/mapper/README.md
+      - Entities: manual/mapper/entities/README.md
+      - DAOs:
+        - Overview: manual/mapper/daos/README.md
+        - Custom Types: manual/mapper/daos/custom_types/README.md
+        - Delete: manual/mapper/daos/delete/README.md
+        - Get Entity: manual/mapper/daos/getentity/README.md
+        - Increment: manual/mapper/daos/increment/README.md
+        - Insert: manual/mapper/daos/insert/README.md
+        - Null Saving: manual/mapper/daos/null_saving/README.md
+        - Query: manual/mapper/daos/query/README.md
+        - Query Provider: manual/mapper/daos/queryprovider/README.md
+        - Select: manual/mapper/daos/select/README.md
+        - Set Entity: manual/mapper/daos/setentity/README.md
+        - Statement Attributes: manual/mapper/daos/statement_attributes/README.md
+        - Update: manual/mapper/daos/update/README.md
+      - Mapper: manual/mapper/mapper/README.md
+      - Configuration:
+        - Overview: manual/mapper/config/README.md
+        - Kotlin: manual/mapper/config/kotlin/README.md
+        - Lombok: manual/mapper/config/lombok/README.md
+        - Record: manual/mapper/config/record/README.md
+        - Scala: manual/mapper/config/scala/README.md
+    - Developer:
+      - Overview: manual/developer/README.md
+      - Common:
+        - Overview: manual/developer/common/README.md
+        - Concurrency: manual/developer/common/concurrency/README.md
+        - Context: manual/developer/common/context/README.md
+        - Event Bus: manual/developer/common/event_bus/README.md
+      - Native Protocol: manual/developer/native_protocol/README.md
+      - Netty Pipeline: manual/developer/netty_pipeline/README.md
+      - Request Execution: manual/developer/request_execution/README.md
+      - Admin: manual/developer/admin/README.md
+    - OSGi: manual/osgi/README.md
+  - API References: api/index.html
+  - FAQ: faq/README.md
+  - Changelog: changelog/README.md
+  - Upgrade Guide: upgrade_guide/README.md
+  - Contribute: CONTRIBUTING.md
+
+plugins:
+  - search
+  - awesome-pages
+  - macros
+  - mike:
+      alias_type: copy
+
+extra:
+  generator: false
+  version:
+    provider: mike
\ No newline at end of file
diff --git a/mkdocs/CONTRIBUTING.md b/mkdocs/CONTRIBUTING.md
new file mode 120000
index 00000000000..44fcc634393
--- /dev/null
+++ b/mkdocs/CONTRIBUTING.md
@@ -0,0 +1 @@
+../CONTRIBUTING.md
\ No newline at end of file
diff --git a/mkdocs/README.md b/mkdocs/README.md
new file mode 120000
index 00000000000..32d46ee883b
--- /dev/null
+++ b/mkdocs/README.md
@@ -0,0 +1 @@
+../README.md
\ No newline at end of file
diff --git a/mkdocs/api b/mkdocs/api
new file mode 120000
index 00000000000..fca923bc74c
--- /dev/null
+++ b/mkdocs/api
@@ -0,0 +1 @@
+../target/site/apidocs
\ No newline at end of file
diff --git a/mkdocs/changelog b/mkdocs/changelog
new file mode 120000
index 00000000000..0891c85c57a
--- /dev/null
+++ b/mkdocs/changelog
@@ -0,0 +1 @@
+../changelog
\ No newline at end of file
diff --git a/mkdocs/faq b/mkdocs/faq
new file mode 120000
index 00000000000..456533382a0
--- /dev/null
+++ b/mkdocs/faq
@@ -0,0 +1 @@
+../faq
\ No newline at end of file
diff --git a/mkdocs/manual b/mkdocs/manual
new file mode 120000
index 00000000000..0fd27f4be61
--- /dev/null
+++ b/mkdocs/manual
@@ -0,0 +1 @@
+../manual
\ No newline at end of file
diff --git a/mkdocs/upgrade_guide b/mkdocs/upgrade_guide
new file mode 120000
index 00000000000..3bfa50a874a
--- /dev/null
+++ b/mkdocs/upgrade_guide
@@ -0,0 +1 @@
+../upgrade_guide
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 126279912da..7e7a2bbc5de 100644
--- a/pom.xml
+++ b/pom.xml
@@ -798,6 +798,13 @@ limitations under the License.]]></inlineHeader>
           <quiet>true</quiet>
           <doclint>all,-missing</doclint>
           <excludePackageNames>com.datastax.*.driver.internal*</excludePackageNames>
+          <additionalDependencies>
+            <additionalDependency>
+              <groupId>com.google.errorprone</groupId>
+              <artifactId>error_prone_annotations</artifactId>
+              <version>2.3.4</version>
+            </additionalDependency>
+          </additionalDependencies>
           <tags>
             <tag>
               <name>apiNote</name>
@@ -876,6 +883,31 @@ limitations under the License.]]></inlineHeader>
               <useStandardDocletOptions>false</useStandardDocletOptions>
             </configuration>
           </execution>
+          <execution>
+            <!-- Generate aggregated Javadoc for specified modules -->
+            <id>aggregate-javadoc</id>
+            <goals>
+              <goal>aggregate</goal>
+            </goals>
+            <phase>site</phase>
+            <configuration>
+              <includeDependencySources>false</includeDependencySources>
+              <dependencySourceIncludes>
+                <dependencySourceInclude>org.apache.cassandra:java-driver-core</dependencySourceInclude>
+                <dependencySourceInclude>org.apache.cassandra:java-driver-query-builder</dependencySourceInclude>
+                <dependencySourceInclude>org.apache.cassandra:java-driver-mapper-runtime</dependencySourceInclude>
+              </dependencySourceIncludes>
+              <reactorProjects>
+                <reactorProject>core</reactorProject>
+                <reactorProject>query-builder</reactorProject>
+                <reactorProject>mapper-runtime</reactorProject>
+              </reactorProjects>
+              <doctitle>Apache Cassandra Java Driver ${project.version} API</doctitle>
+              <bottom><![CDATA[
+                Copyright &#169; {inceptionYear}&#x2013;{currentYear} <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.
+                ]]></bottom>
+            </configuration>
+          </execution>
         </executions>
       </plugin>
       <plugin>
diff --git a/upgrade_guide/README.md b/upgrade_guide/README.md
index 47f5be30746..5b58eeb8f94 100644
--- a/upgrade_guide/README.md
+++ b/upgrade_guide/README.md
@@ -89,7 +89,7 @@ session.execute(preparedInsert.bind(3, vector));
 
 In some cases, it makes sense to access the vector directly as an array of some numerical type. This version
 supports such use cases by providing a codec which translates a CQL vector to and from a primitive array. Only float arrays are supported. 
-You can find more information about this codec in the manual documentation on [custom codecs](../manual/core/custom_codecs/)
+You can find more information about this codec in the manual documentation on [custom codecs](../manual/core/custom_codecs/README.md)
 
 ### 4.15.0
 
@@ -158,7 +158,7 @@ explicitly declare a dependency on the Esri library:
 </dependency>
 ```
 
-See the [integration](../manual/core/integration/#esri) section in the manual for more details.
+See the [integration](../manual/core/integration/README.md#esri) section in the manual for more details.
 
 ### 4.13.0
 
@@ -171,7 +171,7 @@ If you were building a native image for your application, please verify your nat
 configuration. Most of the extra configuration required until now is likely to not be necessary
 anymore.
 
-Refer to this [manual page](../manual/core/graalvm) for details.
+Refer to this [manual page](../manual/core/graalvm/README.md) for details.
 
 #### Registration of multiple listeners and trackers
 
@@ -266,8 +266,8 @@ row or in the target statement, *leaving unmatched properties untouched*.
 This new, lenient behavior allows to achieve the equivalent of driver 3.x 
 [lenient mapping](https://docs.datastax.com/en/developer/java-driver/3.10/manual/object_mapper/using/#manual-mapping).
 
-Read the manual pages on [@GetEntity](../manual/mapper/daos/getentity) methods and
-[@SetEntity](../manual/mapper/daos/setentity) methods for more details and examples of lenient mode.
+Read the manual pages on [@GetEntity](../manual/mapper/daos/getentity/README.md) methods and
+[@SetEntity](../manual/mapper/daos/setentity/README.md) methods for more details and examples of lenient mode.
 
 ### 4.11.0
 
@@ -284,9 +284,9 @@ transparently selected as the protocol version to use.
 
 [JAVA-2872](https://datastax-oss.atlassian.net/browse/JAVA-2872) introduced the ability to configure
 how metric identifiers are generated. Metric names can now be configured, but most importantly,
-metric tags are now supported. See the [metrics](../manual/core/metrics/) section of the online
+metric tags are now supported. See the [metrics](../manual/core/metrics/README.md) section of the online
 manual, or the `advanced.metrics.id-generator` section in the
-[reference.conf](../manual/core/configuration/reference/) file for details.
+[reference.conf](../manual/core/configuration/reference/README.md) file for details.
 
 Users should not experience any disruption. However, those using metrics libraries that support tags
 are encouraged to try out the new `TaggingMetricIdGenerator`, as it generates metric names and tags
@@ -343,7 +343,7 @@ has been deprecated; it should be replaced with a node distance evaluator class
 
 [JAVA-2899](https://datastax-oss.atlassian.net/browse/JAVA-2899) re-introduced the ability to
 perform cross-datacenter failover using the driver's built-in load balancing policies. See [Load
-balancing](../manual/core/loadbalancing/) in the manual for details.
+balancing](../manual/core/load_balancing/README.md) in the manual for details.
 
 Cross-datacenter failover is disabled by default, therefore existing applications should not
 experience any disruption.
@@ -452,7 +452,7 @@ your POM file:
 </dependency>
 ```
 
-See the [integration](../manual/core/integration/#tinker-pop) section in the manual for more details
+See the [integration](../manual/core/integration/README.md#tinkerpop) section in the manual for more details
 as well as a driver vs. TinkerPop version compatibility matrix.
 
 ### 4.5.x - 4.6.0
@@ -468,7 +468,7 @@ separate DSE driver.
 
 #### For Apache Cassandra® users
 
-The great news is that [reactive execution](../manual/core/reactive/) is now available for everyone.
+The great news is that [reactive execution](../manual/core/reactive/README.md) is now available for everyone.
 See the `CqlSession.executeReactive` methods.
 
 Apart from that, the only visible change is that DSE-specific features are now exposed in the API: 
@@ -477,7 +477,7 @@ Apart from that, the only visible change is that DSE-specific features are now e
   have default implementations so this doesn't break binary compatibility. You can just ignore them.
 * new driver dependencies: TinkerPop, ESRI, Reactive Streams. If you want to keep your classpath
   lean, you can exclude some dependencies when you don't use the corresponding DSE features; see the 
-  [Integration>Driver dependencies](../manual/core/integration/#driver-dependencies) section.
+  [Integration>Driver dependencies](../manual/core/integration/README.md#driver-dependencies) section.
 
 #### For DataStax Enterprise users
 
@@ -518,7 +518,7 @@ changes right away; but you will get deprecation warnings:
 * `DseDriverConfigLoader`: the driver no longer needs DSE-specific config loaders. All the factory
   methods in this class now redirect to `DriverConfigLoader`. On that note, `dse-reference.conf`
   does not exist anymore, all the driver defaults are now in
-  [reference.conf](../manual/core/configuration/reference/).
+  [reference.conf](../manual/core/configuration/reference/README.md).
 * plain-text authentication: there is now a single implementation that works with both Cassandra and
   DSE. If you used `DseProgrammaticPlainTextAuthProvider`, replace it by
   `PlainTextProgrammaticAuthProvider`. Similarly, if you wrote a custom implementation by
@@ -568,7 +568,7 @@ a few notable differences:
 * the "mapper" and "accessor" concepts have been unified into a single "DAO" component, that handles
   both pre-defined CRUD patterns, and user-provided queries.
 
-Refer to the [mapper manual](../manual/mapper/) for all the details.
+Refer to the [mapper manual](../manual/mapper/README.md) for all the details.
 
 #### Internal API
 
@@ -646,7 +646,7 @@ Notable changes:
 * simple statement instances are now created with the `newInstance` static factory method. This is
   because `SimpleStatement` is now an interface (as most public API types).
 
-[API conventions]: ../manual/api_conventions
+[API conventions]: ../manual/api_conventions/README.md
 
 #### Configuration
 
@@ -714,9 +714,9 @@ This is fully customizable: the configuration is exposed to the rest of the driv
 `DriverConfig` interface; if the default implementation doesn't work for you, you can write your
 own.
 
-For more details, refer to the [manual](../manual/core/configuration).
+For more details, refer to the [manual](../manual/core/configuration/README.md).
 
-[Typesafe Config]: https://github.com/typesafehub/config
+[Typesafe Config]: https://github.com/typesafehub/config/README.md
 
 #### Session
 
@@ -734,7 +734,7 @@ to the best common denominator (see
 [JAVA-1295](https://datastax-oss.atlassian.net/browse/JAVA-1295)).
 
 Reconnection is now possible at startup: if no contact point is reachable, the driver will retry at
-periodic intervals (controlled by the [reconnection policy](../manual/core/reconnection/)) instead
+periodic intervals (controlled by the [reconnection policy](../manual/core/reconnection/README.md)) instead
 of throwing an error. To turn this on, set the following configuration option:
 
 ```
@@ -743,7 +743,7 @@ datastax-java-driver {
 }
 ```
 
-The session now has a built-in [throttler](../manual/core/throttling/) to limit how many requests
+The session now has a built-in [throttler](../manual/core/throttling/README.md) to limit how many requests
 can execute concurrently. Here's an example based on the number of requests (a rate-based variant is
 also available):
 
@@ -763,7 +763,7 @@ Previous driver versions came with multiple load balancing policies that could b
 other. In our experience, this was one of the most complicated aspects of the configuration.
 
 In driver 4, we are taking a more opinionated approach: we provide a single [default
-policy](../manual/core/load_balancing/#default-policy), with what we consider as the best practices:
+policy](../manual/core/load_balancing/README.md), with what we consider as the best practices:
 
 * local only: we believe that failover should be handled at infrastructure level, not by application
   code.
@@ -774,7 +774,7 @@ You can still provide your own policy by implementing the `LoadBalancingPolicy`
 
 #### Statements
 
-Simple, bound and batch [statements](../manual/core/statements/) are now exposed in the public API
+Simple, bound and batch [statements](../manual/core/statements/README.md) are now exposed in the public API
 as interfaces. The internal implementations are **immutable**. This makes them automatically
 thread-safe: you don't need to worry anymore about sharing them or reusing them between asynchronous
 executions.
@@ -802,7 +802,7 @@ maximum amount of time that `session.execute` will take, including any retry, sp
 etc. You can set it with `Statement.setTimeout`, or globally in the configuration with the
 `basic.request.timeout` option.
 
-[Prepared statements](../manual/core/statements/prepared/) are now cached client-side: if you call
+[Prepared statements](../manual/core/statements/prepared/README.md) are now cached client-side: if you call
 `session.prepare()` twice with the same query string, it will no longer log a warning. The second
 call will return the same statement instance, without sending anything to the server:
 
@@ -836,7 +836,7 @@ assert bs2.getConsistencyLevel() == DefaultConsistencyLevel.TWO;
 ```
 
 DDL statements are now debounced; see [Why do DDL queries have a higher latency than driver
-3?](../faq/#why-do-ddl-queries-have-a-higher-latency-than-driver-3) in the FAQ.
+3?](../faq/README.md#why-do-ddl-queries-have-a-higher-latency-than-driver-3) in the FAQ.
 
 #### Dual result set APIs
 
@@ -859,8 +859,8 @@ will find more information about asynchronous iterations in the manual pages abo
 programming][4.x async programming] and [paging][4.x paging].
 
 [3.x async paging]: http://docs.datastax.com/en/developer/java-driver/3.2/manual/async/#async-paging
-[4.x async programming]: ../manual/core/async/
-[4.x paging]: ../manual/core/paging/
+[4.x async programming]: ../manual/core/async/README.md
+[4.x paging]: ../manual/core/paging/README.md
 
 #### CQL to Java type mappings
 
@@ -875,8 +875,8 @@ changed when it comes to [temporal types] such as `date` and `timestamp`:
 
 The corresponding setter methods were also changed to expect these new types as inputs.
 
-[CQL to Java type mappings]: ../manual/core#cql-to-java-type-mapping
-[temporal types]: ../manual/core/temporal_types
+[CQL to Java type mappings]: ../manual/core/README.md#cql-to-java-type-mapping
+[temporal types]: ../manual/core/temporal_types/README.md
 [java.time.LocalDate]: https://docs.oracle.com/javase/8/docs/api/java/time/LocalDate.html
 [java.time.LocalTime]: https://docs.oracle.com/javase/8/docs/api/java/time/LocalTime.html
 [java.time.Instant]: https://docs.oracle.com/javase/8/docs/api/java/time/Instant.html
@@ -884,7 +884,7 @@ The corresponding setter methods were also changed to expect these new types as
 
 #### Metrics
 
-[Metrics](../manual/core/metrics/) are now divided into two categories: session-wide and per-node. 
+[Metrics](../manual/core/metrics/README.md) are now divided into two categories: session-wide and per-node. 
 Each metric can be enabled or disabled individually in the configuration:
 
 ```
@@ -949,7 +949,7 @@ datastax-java-driver {
 }
 ```
 
-See the [manual](../manual/core/metadata/) for all the details.
+See the [manual](../manual/core/metadata/README.md) for all the details.
 
 #### Query builder
 
@@ -989,14 +989,14 @@ SimpleStatement statement = query
 
 All query builder types are immutable, making them inherently thread-safe and share-safe.
 
-The query builder has its own [manual chapter](../manual/query_builder/), where the syntax is
+The query builder has its own [manual chapter](../manual/query_builder/README.md), where the syntax is
 covered in detail.
 
 #### Dedicated type for CQL identifiers
 
 Instead of raw strings, the names of schema objects (keyspaces, tables, columns, etc.) are now 
 wrapped in a dedicated `CqlIdentifier` type. This avoids ambiguities with regard to [case
-sensitivity](../manual/case_sensitivity).
+sensitivity](../manual/case_sensitivity/README.md).
 
 #### Pluggable request execution logic
 

From 375e4b5268484ee88aa847863261b3926aba8ff0 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aratnofsky@netflix.com>
Date: Thu, 7 May 2026 10:11:34 -0400
Subject: [PATCH 117/126] [maven-release-plugin] prepare release 4.19.3

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index dd76153a9b1..50e5bfdf157 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 84cb4b15398..37bde69d4f7 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 8758d20d78a..06abcc3d656 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index 4c1f11e53a8..a62bbe40a26 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 9cef313f8a5..6dccc491b84 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 20b9afc1bcd..b93a70f0adb 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 12e42dfdf53..2824869e5de 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index da2e82e0ab0..7496f917435 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index e302e12077f..081fc98b0c7 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 04d8c98c4f0..421163e4016 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 57fbd5d3432..557bba8bb3b 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 37ba8556a53..900f247634a 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 9893711d340..a632c6ec791 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index c2cc4d830f1..59892eac3d3 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 7e7a2bbc5de..ee3c2ed038b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.3-SNAPSHOT</version>
+  <version>4.19.3</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1081,7 +1081,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>HEAD</tag>
+    <tag>4.19.3</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 2bfe1bee8f5..66ec630765f 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 5bf2d07f652..927c48a99e8 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 342088c33bdba1db40326ecb67a63f9b6284bca3 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aratnofsky@netflix.com>
Date: Thu, 7 May 2026 10:28:36 -0400
Subject: [PATCH 118/126] [maven-release-plugin] prepare for next development
 iteration

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 50e5bfdf157..67e26c95bde 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 37bde69d4f7..7d173e2783b 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 06abcc3d656..59306b175cd 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index a62bbe40a26..40ca39bf612 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 6dccc491b84..c6352b3dfd9 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index b93a70f0adb..db95669cd6b 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 2824869e5de..e3ec891843e 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 7496f917435..7fbadd0cea1 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 081fc98b0c7..42432eda417 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 421163e4016..5513498f946 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 557bba8bb3b..33a1625ecbf 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 900f247634a..8efa9ed755b 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index a632c6ec791..931d17f1a88 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 59892eac3d3..037fc3f6055 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index ee3c2ed038b..575fd8749ed 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.3</version>
+  <version>4.19.4-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1081,7 +1081,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>4.19.3</tag>
+    <tag>HEAD</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 66ec630765f..511b8f9a005 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 927c48a99e8..5105e9bc08d 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 805cfa808d6ac6da730806b24ddc196b0fa86ddd Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aratnofsky@netflix.com>
Date: Thu, 7 May 2026 10:33:11 -0400
Subject: [PATCH 119/126] Revert "[maven-release-plugin] prepare for next
 development iteration"

This reverts commit 342088c33bdba1db40326ecb67a63f9b6284bca3.
---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 67e26c95bde..50e5bfdf157 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.4-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 7d173e2783b..37bde69d4f7 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 59306b175cd..06abcc3d656 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index 40ca39bf612..a62bbe40a26 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index c6352b3dfd9..6dccc491b84 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index db95669cd6b..b93a70f0adb 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index e3ec891843e..2824869e5de 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 7fbadd0cea1..7496f917435 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 42432eda417..081fc98b0c7 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 5513498f946..421163e4016 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 33a1625ecbf..557bba8bb3b 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 8efa9ed755b..900f247634a 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 931d17f1a88..a632c6ec791 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 037fc3f6055..59892eac3d3 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 575fd8749ed..ee3c2ed038b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.4-SNAPSHOT</version>
+  <version>4.19.3</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1081,7 +1081,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>HEAD</tag>
+    <tag>4.19.3</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 511b8f9a005..66ec630765f 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 5105e9bc08d..927c48a99e8 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.4-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From c7fe73fe23149c10fe365402b55a6dc88b90b0d4 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aratnofsky@netflix.com>
Date: Thu, 7 May 2026 10:33:13 -0400
Subject: [PATCH 120/126] Revert "[maven-release-plugin] prepare release
 4.19.3"

This reverts commit 375e4b5268484ee88aa847863261b3926aba8ff0.
---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 50e5bfdf157..dd76153a9b1 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 37bde69d4f7..84cb4b15398 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 06abcc3d656..8758d20d78a 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index a62bbe40a26..4c1f11e53a8 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 6dccc491b84..9cef313f8a5 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index b93a70f0adb..20b9afc1bcd 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 2824869e5de..12e42dfdf53 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 7496f917435..da2e82e0ab0 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 081fc98b0c7..e302e12077f 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 421163e4016..04d8c98c4f0 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 557bba8bb3b..57fbd5d3432 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 900f247634a..37ba8556a53 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index a632c6ec791..9893711d340 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 59892eac3d3..c2cc4d830f1 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index ee3c2ed038b..7e7a2bbc5de 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.3</version>
+  <version>4.19.3-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1081,7 +1081,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>4.19.3</tag>
+    <tag>HEAD</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 66ec630765f..2bfe1bee8f5 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 927c48a99e8..5bf2d07f652 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From be4e00b3a283184883571e094c9feba601eb60d9 Mon Sep 17 00:00:00 2001
From: absurdfarce <bret.mcguire@ibm.com>
Date: Mon, 11 May 2026 18:34:28 -0500
Subject: [PATCH 121/126] Revert #2051 and replace it with something closer to
 the intent of the original PR (#1901).

The change that was actually merged attempted to bump us up to the most recent Java8-compatible
logback impl.  This moved us from 1.2.x to 1.3.x which in turn brought some dependency changes
that were excessive, especially for a patch release.

patch by Bret McGuire; reviewed by Andy Tolbert and Abe Ratnofsky
reference: https://github.com/apache/cassandra-java-driver/pull/2088
---
 .../driver/internal/osgi/support/BundleOptions.java    | 10 ----------
 pom.xml                                                |  4 ++--
 2 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
index f15207219f9..71139bc01d8 100644
--- a/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
+++ b/osgi-tests/src/test/java/com/datastax/oss/driver/internal/osgi/support/BundleOptions.java
@@ -104,16 +104,6 @@ public static CompositeOption logbackBundles() {
         options(
             mavenBundle("ch.qos.logback", "logback-classic").versionAsInProject(),
             mavenBundle("ch.qos.logback", "logback-core").versionAsInProject(),
-
-            // slf4j 2.x requires spifly in order to operate in an OSGi context
-            mavenBundle("org.apache.aries.spifly", "org.apache.aries.spifly.dynamic.bundle")
-                .version("1.3.7"),
-            mavenBundle("org.apache.aries", "org.apache.aries.util").version("1.1.1"),
-            mavenBundle("org.ow2.asm", "asm").version("9.6"),
-            mavenBundle("org.ow2.asm", "asm-commons").version("9.6"),
-            mavenBundle("org.ow2.asm", "asm-util").version("9.6"),
-            mavenBundle("org.ow2.asm", "asm-tree").version("9.6"),
-            mavenBundle("org.ow2.asm", "asm-analysis").version("9.6"),
             systemProperty("logback.configurationFile")
                 .value("file:src/test/resources/logback-test.xml"));
   }
diff --git a/pom.xml b/pom.xml
index 7e7a2bbc5de..8c414ba0d9c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -65,7 +65,7 @@
     -->
     <tinkerpop.version>3.5.6</tinkerpop.version>
     <!-- when changing version also update version in LICENSE_binary  -->
-    <slf4j.version>2.0.16</slf4j.version>
+    <slf4j.version>1.7.26</slf4j.version>
     <!-- when changing version also update version in LICENSE_binary  -->
     <reactive-streams.version>1.0.3</reactive-streams.version>
     <jackson.version>2.20.1</jackson.version>
@@ -77,7 +77,7 @@
     <assertj.version>3.19.0</assertj.version>
     <commons-exec.version>1.3</commons-exec.version>
     <junit.version>4.13.2</junit.version>
-    <logback.version>1.3.15</logback.version>
+    <logback.version>1.2.13</logback.version>
     <osgi.version>6.0.0</osgi.version>
     <felix.version>7.0.1</felix.version>
     <pax-exam.version>4.13.4</pax-exam.version>

From 2ed181b2d57d559b348040fe2de525d73d19edb7 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aber@apache.org>
Date: Fri, 8 May 2026 17:26:33 -0400
Subject: [PATCH 122/126] Add changelog for 4.19.3

---
 changelog/README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/changelog/README.md b/changelog/README.md
index b01c3db3bf9..7ca167d00cc 100644
--- a/changelog/README.md
+++ b/changelog/README.md
@@ -21,6 +21,16 @@ under the License.
 
 <!-- Note: contrary to 3.x, insert new entries *first* in their section -->
 
+### 4.19.3
+
+- [bug] CASSJAVA-3: Fix ordering of LIMIT and PER PARTITION LIMIT clauses
+- [bug] PR 2050: Fix race condition in ClockSeqAndNodeContainer
+- [improvement] CASSJAVA-108: Update ESRI (and remove org.json) dependencies
+- [improvement] PR 2076: Bump Jackson to 2.20.1
+- [improvement] PR 2047: Re-work ordering clause support in query builder
+- [improvement] PR 2051: Bump logback to 1.3.15, slf4j to 2.0.16
+- [improvement] CASSJAVA-113: Bump LZ4 to 1.10.1, Netty to 4.1.130.Final
+
 ### 4.19.2
 
 - [bug] CASSJAVA-116: Retry or Speculative Execution with RequestIdGenerator throws "Duplicate Key"

From 8e2e70c63ae568e4c03cc44e4c68dfad54976075 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aber@apache.org>
Date: Tue, 26 May 2026 16:36:17 -0400
Subject: [PATCH 123/126] [maven-release-plugin] prepare release 4.19.3

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index dd76153a9b1..50e5bfdf157 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 84cb4b15398..37bde69d4f7 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 8758d20d78a..06abcc3d656 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index 4c1f11e53a8..a62bbe40a26 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 9cef313f8a5..6dccc491b84 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 20b9afc1bcd..b93a70f0adb 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 12e42dfdf53..2824869e5de 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index da2e82e0ab0..7496f917435 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index e302e12077f..081fc98b0c7 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 04d8c98c4f0..421163e4016 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 57fbd5d3432..557bba8bb3b 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 37ba8556a53..900f247634a 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 9893711d340..a632c6ec791 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index c2cc4d830f1..59892eac3d3 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 8c414ba0d9c..7c0df37b0cf 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.3-SNAPSHOT</version>
+  <version>4.19.3</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1081,7 +1081,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>HEAD</tag>
+    <tag>4.19.3</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 2bfe1bee8f5..66ec630765f 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 5bf2d07f652..927c48a99e8 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 20ee3368cb8b20e8764de4e6c3513bcdb8eede52 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aber@apache.org>
Date: Tue, 26 May 2026 16:52:38 -0400
Subject: [PATCH 124/126] Revert "[maven-release-plugin] prepare release
 4.19.3"

This reverts commit 8e2e70c63ae568e4c03cc44e4c68dfad54976075.
---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 50e5bfdf157..dd76153a9b1 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.3-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 37bde69d4f7..84cb4b15398 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 06abcc3d656..8758d20d78a 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index a62bbe40a26..4c1f11e53a8 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 6dccc491b84..9cef313f8a5 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index b93a70f0adb..20b9afc1bcd 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 2824869e5de..12e42dfdf53 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 7496f917435..da2e82e0ab0 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 081fc98b0c7..e302e12077f 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 421163e4016..04d8c98c4f0 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 557bba8bb3b..57fbd5d3432 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 900f247634a..37ba8556a53 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index a632c6ec791..9893711d340 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 59892eac3d3..c2cc4d830f1 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 7c0df37b0cf..8c414ba0d9c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.3</version>
+  <version>4.19.3-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1081,7 +1081,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>4.19.3</tag>
+    <tag>HEAD</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 66ec630765f..2bfe1bee8f5 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 927c48a99e8..5bf2d07f652 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.3-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From d954b5da58ea682ec39d474e241bc4b426d34dc2 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aber@apache.org>
Date: Tue, 26 May 2026 16:59:57 -0400
Subject: [PATCH 125/126] [maven-release-plugin] prepare release 4.19.3

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index dd76153a9b1..50e5bfdf157 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.3-SNAPSHOT</version>
+        <version>4.19.3</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 84cb4b15398..37bde69d4f7 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 8758d20d78a..06abcc3d656 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index 4c1f11e53a8..a62bbe40a26 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 9cef313f8a5..6dccc491b84 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index 20b9afc1bcd..b93a70f0adb 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 12e42dfdf53..2824869e5de 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index da2e82e0ab0..7496f917435 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index e302e12077f..081fc98b0c7 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 04d8c98c4f0..421163e4016 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 57fbd5d3432..557bba8bb3b 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 37ba8556a53..900f247634a 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index 9893711d340..a632c6ec791 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index c2cc4d830f1..59892eac3d3 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 8c414ba0d9c..7c0df37b0cf 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.3-SNAPSHOT</version>
+  <version>4.19.3</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1081,7 +1081,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>HEAD</tag>
+    <tag>4.19.3</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 2bfe1bee8f5..66ec630765f 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 5bf2d07f652..927c48a99e8 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3-SNAPSHOT</version>
+    <version>4.19.3</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>

From 90b09e0e34fd6fdda064f13f6acd0df7268a3dc6 Mon Sep 17 00:00:00 2001
From: Abe Ratnofsky <aber@apache.org>
Date: Tue, 26 May 2026 17:00:00 -0400
Subject: [PATCH 126/126] [maven-release-plugin] prepare for next development
 iteration

---
 bom/pom.xml                  | 20 ++++++++++----------
 core-shaded/pom.xml          |  2 +-
 core/pom.xml                 |  2 +-
 distribution-source/pom.xml  |  2 +-
 distribution-tests/pom.xml   |  2 +-
 distribution/pom.xml         |  2 +-
 examples/pom.xml             |  2 +-
 guava-shaded/pom.xml         |  2 +-
 integration-tests/pom.xml    |  2 +-
 mapper-processor/pom.xml     |  2 +-
 mapper-runtime/pom.xml       |  2 +-
 metrics/micrometer/pom.xml   |  2 +-
 metrics/microprofile/pom.xml |  2 +-
 osgi-tests/pom.xml           |  2 +-
 pom.xml                      |  4 ++--
 query-builder/pom.xml        |  2 +-
 test-infra/pom.xml           |  2 +-
 17 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/bom/pom.xml b/bom/pom.xml
index 50e5bfdf157..67e26c95bde 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-bom</artifactId>
   <packaging>pom</packaging>
@@ -33,47 +33,47 @@
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-core-shaded</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-processor</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-mapper-runtime</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-query-builder</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-guava-shaded</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-test-infra</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-micrometer</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>org.apache.cassandra</groupId>
         <artifactId>java-driver-metrics-microprofile</artifactId>
-        <version>4.19.3</version>
+        <version>4.19.4-SNAPSHOT</version>
       </dependency>
       <dependency>
         <groupId>com.datastax.oss</groupId>
diff --git a/core-shaded/pom.xml b/core-shaded/pom.xml
index 37bde69d4f7..7d173e2783b 100644
--- a/core-shaded/pom.xml
+++ b/core-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core-shaded</artifactId>
   <name>Apache Cassandra Java Driver - core with shaded deps</name>
diff --git a/core/pom.xml b/core/pom.xml
index 06abcc3d656..59306b175cd 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-core</artifactId>
   <packaging>bundle</packaging>
diff --git a/distribution-source/pom.xml b/distribution-source/pom.xml
index a62bbe40a26..40ca39bf612 100644
--- a/distribution-source/pom.xml
+++ b/distribution-source/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-source</artifactId>
   <packaging>pom</packaging>
diff --git a/distribution-tests/pom.xml b/distribution-tests/pom.xml
index 6dccc491b84..c6352b3dfd9 100644
--- a/distribution-tests/pom.xml
+++ b/distribution-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution-tests</artifactId>
   <name>Apache Cassandra Java Driver - distribution tests</name>
diff --git a/distribution/pom.xml b/distribution/pom.xml
index b93a70f0adb..db95669cd6b 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-distribution</artifactId>
   <!-- Should be pom but Javadoc generation requires a "classpath-capable" package -->
diff --git a/examples/pom.xml b/examples/pom.xml
index 2824869e5de..e3ec891843e 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <artifactId>java-driver-parent</artifactId>
     <groupId>org.apache.cassandra</groupId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-examples</artifactId>
   <name>Apache Cassandra Java Driver - examples.</name>
diff --git a/guava-shaded/pom.xml b/guava-shaded/pom.xml
index 7496f917435..7fbadd0cea1 100644
--- a/guava-shaded/pom.xml
+++ b/guava-shaded/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-guava-shaded</artifactId>
   <name>Apache Cassandra Java Driver - guava shaded dep</name>
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 081fc98b0c7..42432eda417 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-integration-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/mapper-processor/pom.xml b/mapper-processor/pom.xml
index 421163e4016..5513498f946 100644
--- a/mapper-processor/pom.xml
+++ b/mapper-processor/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-processor</artifactId>
   <name>Apache Cassandra Java Driver - object mapper processor</name>
diff --git a/mapper-runtime/pom.xml b/mapper-runtime/pom.xml
index 557bba8bb3b..33a1625ecbf 100644
--- a/mapper-runtime/pom.xml
+++ b/mapper-runtime/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-mapper-runtime</artifactId>
   <packaging>bundle</packaging>
diff --git a/metrics/micrometer/pom.xml b/metrics/micrometer/pom.xml
index 900f247634a..8efa9ed755b 100644
--- a/metrics/micrometer/pom.xml
+++ b/metrics/micrometer/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-micrometer</artifactId>
diff --git a/metrics/microprofile/pom.xml b/metrics/microprofile/pom.xml
index a632c6ec791..931d17f1a88 100644
--- a/metrics/microprofile/pom.xml
+++ b/metrics/microprofile/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
     <relativePath>../../</relativePath>
   </parent>
   <artifactId>java-driver-metrics-microprofile</artifactId>
diff --git a/osgi-tests/pom.xml b/osgi-tests/pom.xml
index 59892eac3d3..037fc3f6055 100644
--- a/osgi-tests/pom.xml
+++ b/osgi-tests/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-osgi-tests</artifactId>
   <packaging>jar</packaging>
diff --git a/pom.xml b/pom.xml
index 7c0df37b0cf..947132f9a43 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   </parent>
   <groupId>org.apache.cassandra</groupId>
   <artifactId>java-driver-parent</artifactId>
-  <version>4.19.3</version>
+  <version>4.19.4-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Apache Cassandra Java Driver</name>
   <url>https://github.com/datastax/java-driver</url>
@@ -1081,7 +1081,7 @@ limitations under the License.]]></inlineHeader>
     <connection>scm:git:git@github.com:datastax/java-driver.git</connection>
     <developerConnection>scm:git:git@github.com:datastax/java-driver.git</developerConnection>
     <url>https://github.com/datastax/java-driver</url>
-    <tag>4.19.3</tag>
+    <tag>HEAD</tag>
   </scm>
   <developers>
     <developer>
diff --git a/query-builder/pom.xml b/query-builder/pom.xml
index 66ec630765f..511b8f9a005 100644
--- a/query-builder/pom.xml
+++ b/query-builder/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-query-builder</artifactId>
   <packaging>bundle</packaging>
diff --git a/test-infra/pom.xml b/test-infra/pom.xml
index 927c48a99e8..5105e9bc08d 100644
--- a/test-infra/pom.xml
+++ b/test-infra/pom.xml
@@ -23,7 +23,7 @@
   <parent>
     <groupId>org.apache.cassandra</groupId>
     <artifactId>java-driver-parent</artifactId>
-    <version>4.19.3</version>
+    <version>4.19.4-SNAPSHOT</version>
   </parent>
   <artifactId>java-driver-test-infra</artifactId>
   <packaging>bundle</packaging>