diff --git a/MODULE.bazel b/MODULE.bazel
index 6ca1f04..766e484 100644
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -21,6 +21,7 @@
 bazel_dep(name = "stardoc", version = "0.5.6", repo_name = "io_bazel_skydoc")
 bazel_dep(name = "zstd-jni", version = "1.5.2-3.bcr.1")
 bazel_dep(name = "blake3", version = "1.3.3.bcr.1")
+bazel_dep(name = "sqlite3", version = "3.42.0.bcr.1")
 bazel_dep(name = "zlib", version = "1.3")
 bazel_dep(name = "rules_cc", version = "0.0.9")
 bazel_dep(name = "rules_java", version = "7.5.0")
diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock
index 05bef5d..83889a8 100644
--- a/MODULE.bazel.lock
+++ b/MODULE.bazel.lock
@@ -1,6 +1,6 @@
 {
   "lockFileVersion": 6,
-  "moduleFileHash": "6d66ec3a2143e9d841b99698beb6de3ef66d0f3dc0b724afa19e534df8c72833",
+  "moduleFileHash": "41e97ab73eab5fafef6cd8f9b4696823e31384219a6356a052cab52245e1193c",
   "flags": {
     "cmdRegistries": [
       "https://bcr.bazel.build/"
@@ -39,7 +39,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 74,
+            "line": 75,
             "column": 22
           },
           "imports": {
@@ -168,7 +168,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 75,
+                "line": 76,
                 "column": 14
               }
             },
@@ -183,7 +183,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -198,7 +198,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -213,7 +213,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -228,7 +228,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -243,7 +243,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -258,7 +258,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -273,7 +273,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -288,7 +288,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -303,7 +303,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 198,
+                "line": 199,
                 "column": 19
               }
             },
@@ -331,7 +331,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 338,
+                "line": 339,
                 "column": 22
               }
             }
@@ -345,7 +345,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 219,
+            "line": 220,
             "column": 32
           },
           "imports": {
@@ -385,7 +385,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 253,
+            "line": 254,
             "column": 23
           },
           "imports": {},
@@ -399,7 +399,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 254,
+                "line": 255,
                 "column": 17
               }
             }
@@ -413,7 +413,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 256,
+            "line": 257,
             "column": 20
           },
           "imports": {
@@ -431,7 +431,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 257,
+                "line": 258,
                 "column": 10
               }
             }
@@ -445,7 +445,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 268,
+            "line": 269,
             "column": 33
           },
           "imports": {
@@ -476,7 +476,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 289,
+            "line": 290,
             "column": 29
           },
           "imports": {
@@ -493,7 +493,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 292,
+            "line": 293,
             "column": 20
           },
           "imports": {
@@ -512,7 +512,7 @@
               "devDependency": false,
               "location": {
                 "file": "@@//:MODULE.bazel",
-                "line": 293,
+                "line": 294,
                 "column": 12
               }
             }
@@ -526,7 +526,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 305,
+            "line": 306,
             "column": 32
           },
           "imports": {
@@ -545,7 +545,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 313,
+            "line": 314,
             "column": 31
           },
           "imports": {
@@ -562,7 +562,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 316,
+            "line": 317,
             "column": 48
           },
           "imports": {
@@ -579,7 +579,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 360,
+            "line": 361,
             "column": 35
           },
           "imports": {
@@ -596,7 +596,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 363,
+            "line": 364,
             "column": 42
           },
           "imports": {
@@ -614,7 +614,7 @@
           "usingModule": "<root>",
           "location": {
             "file": "@@//:MODULE.bazel",
-            "line": 366,
+            "line": 367,
             "column": 45
           },
           "imports": {
@@ -636,6 +636,7 @@
         "io_bazel_skydoc": "stardoc@0.5.6",
         "zstd-jni": "zstd-jni@1.5.2-3.bcr.1",
         "blake3": "blake3@1.3.3.bcr.1",
+        "sqlite3": "sqlite3@3.42.0.bcr.1",
         "zlib": "zlib@1.3",
         "rules_cc": "rules_cc@0.0.9",
         "rules_java": "rules_java@7.5.0",
@@ -1037,6 +1038,36 @@
         }
       }
     },
+    "sqlite3@3.42.0.bcr.1": {
+      "name": "sqlite3",
+      "version": "3.42.0.bcr.1",
+      "key": "sqlite3@3.42.0.bcr.1",
+      "repoName": "sqlite3",
+      "executionPlatformsToRegister": [],
+      "toolchainsToRegister": [],
+      "extensionUsages": [],
+      "deps": {
+        "platforms": "platforms@0.0.9",
+        "bazel_tools": "bazel_tools@_",
+        "local_config_platform": "local_config_platform@_"
+      },
+      "repoSpec": {
+        "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl",
+        "ruleClassName": "http_archive",
+        "attributes": {
+          "urls": [
+            "https://sqlite.org/2023/sqlite-amalgamation-3420000.zip"
+          ],
+          "integrity": "sha256-HMgk0PXmdYKfo3AYMY/agz6lb36d4rQe3dn3ZDtewp4=",
+          "strip_prefix": "sqlite-amalgamation-3420000",
+          "remote_patches": {
+            "https://bcr.bazel.build/modules/sqlite3/3.42.0.bcr.1/patches/add_build_file.patch": "sha256-jv2puH58Mvf5zg3l26JdJHsAHBjb743lE3uV0FvSAd8=",
+            "https://bcr.bazel.build/modules/sqlite3/3.42.0.bcr.1/patches/module_dot_bazel.patch": "sha256-0nVrZCj8DjLNzeeLpBtVT9X0s4BQXqANYyu++q7Ikv8="
+          },
+          "remote_patch_strip": 0
+        }
+      }
+    },
     "zlib@1.3": {
       "name": "zlib",
       "version": "1.3",
@@ -2704,7 +2735,7 @@
   "moduleExtensions": {
     "//:extensions.bzl%bazel_android_deps": {
       "general": {
-        "bzlTransitiveDigest": "R3xBHm2eNuqBleAB9JHPLRUvv5Eq/3rnrpxiZN2EBKc=",
+        "bzlTransitiveDigest": "tunTSmgwd2uvTzkCLtdbuCp0AI+WR+ftiPNqZ0rmcZk=",
         "recordedFileInputs": {},
         "recordedDirentsInputs": {},
         "envVariables": {},
@@ -2822,6 +2853,11 @@
           ],
           [
             "",
+            "sqlite3",
+            "sqlite3~"
+          ],
+          [
+            "",
             "upb",
             "upb~"
           ],
@@ -2845,9 +2881,9 @@
     },
     "//:extensions.bzl%bazel_build_deps": {
       "general": {
-        "bzlTransitiveDigest": "R3xBHm2eNuqBleAB9JHPLRUvv5Eq/3rnrpxiZN2EBKc=",
+        "bzlTransitiveDigest": "tunTSmgwd2uvTzkCLtdbuCp0AI+WR+ftiPNqZ0rmcZk=",
         "recordedFileInputs": {
-          "@@//MODULE.bazel": "6d66ec3a2143e9d841b99698beb6de3ef66d0f3dc0b724afa19e534df8c72833",
+          "@@//MODULE.bazel": "41e97ab73eab5fafef6cd8f9b4696823e31384219a6356a052cab52245e1193c",
           "@@//src/test/tools/bzlmod/MODULE.bazel.lock": "e6b22f35c7bce99c0677f24a19c7aee829f97e7b1b5cc31e600c7cc9b408a292"
         },
         "recordedDirentsInputs": {},
@@ -2948,6 +2984,7 @@
                 "rules_pkg~",
                 "rules_proto~",
                 "rules_python~",
+                "sqlite3~",
                 "upb~",
                 "zlib~",
                 "zstd-jni~",
@@ -3191,6 +3228,11 @@
           ],
           [
             "",
+            "sqlite3",
+            "sqlite3~"
+          ],
+          [
+            "",
             "upb",
             "upb~"
           ],
@@ -3214,7 +3256,7 @@
     },
     "//:extensions.bzl%bazel_test_deps": {
       "general": {
-        "bzlTransitiveDigest": "R3xBHm2eNuqBleAB9JHPLRUvv5Eq/3rnrpxiZN2EBKc=",
+        "bzlTransitiveDigest": "tunTSmgwd2uvTzkCLtdbuCp0AI+WR+ftiPNqZ0rmcZk=",
         "recordedFileInputs": {},
         "recordedDirentsInputs": {},
         "envVariables": {},
@@ -3342,6 +3384,11 @@
           ],
           [
             "",
+            "sqlite3",
+            "sqlite3~"
+          ],
+          [
+            "",
             "upb",
             "upb~"
           ],
diff --git a/repositories.bzl b/repositories.bzl
index d8fec8a..b3c2c66 100644
--- a/repositories.bzl
+++ b/repositories.bzl
@@ -43,6 +43,7 @@
     "rules_pkg",
     "rules_proto",
     "rules_python",
+    "sqlite3",
     "upb",
     "zlib",
     "zstd-jni",
diff --git a/src/main/java/com/google/devtools/build/lib/remote/disk/BUILD b/src/main/java/com/google/devtools/build/lib/remote/disk/BUILD
index 57271f3..c7ed7da 100644
--- a/src/main/java/com/google/devtools/build/lib/remote/disk/BUILD
+++ b/src/main/java/com/google/devtools/build/lib/remote/disk/BUILD
@@ -16,6 +16,7 @@
     srcs = glob(["*.java"]),
     deps = [
         "//src/main/java/com/google/devtools/build/lib/exec:spawn_runner",
+        "//src/main/java/com/google/devtools/build/lib/jni",
         "//src/main/java/com/google/devtools/build/lib/remote:store",
         "//src/main/java/com/google/devtools/build/lib/remote/common",
         "//src/main/java/com/google/devtools/build/lib/remote/common:cache_not_found_exception",
diff --git a/src/main/java/com/google/devtools/build/lib/remote/disk/Sqlite.java b/src/main/java/com/google/devtools/build/lib/remote/disk/Sqlite.java
new file mode 100644
index 0000000..8f5b1ef
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/remote/disk/Sqlite.java
@@ -0,0 +1,421 @@
+// Copyright 2024 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.remote.disk;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.jni.JniLoader;
+import com.google.devtools.build.lib.vfs.Path;
+import java.io.IOException;
+import java.util.HashSet;
+import javax.annotation.Nullable;
+
+/**
+ * A wrapper around the SQLite C API.
+ *
+ * <p>Exposes only the subset of the SQLite C API required by Bazel.
+ */
+public final class Sqlite {
+
+  static {
+    JniLoader.loadJni();
+  }
+
+  private Sqlite() {}
+
+  /**
+   * Opens a connection to a database, creating it in an empty state if it doesn't yet exist.
+   *
+   * @param path the path to the database
+   * @throws IOException if an error occurred while opening the connection
+   */
+  public static Connection newConnection(Path path) throws IOException {
+    checkNotNull(path);
+    return new Connection(path);
+  }
+
+  /**
+   * A connection to a database.
+   *
+   * <p>This class is *not* thread-safe. A single connection should be used by a single thread. Use
+   * separate connections to the same database for multithreaded access.
+   */
+  public static final class Connection implements AutoCloseable {
+
+    // C pointer to the `sqlite3` handle. Zero means the connection has been closed.
+    private long connPtr;
+
+    // Tracks open statements so they can also be closed when the connection is closed.
+    private final HashSet<Statement> openStatements = new HashSet<>();
+
+    private Connection(Path path) throws IOException {
+      this.connPtr = openConn(path.getPathString());
+    }
+
+    /**
+     * Closes the connection, rendering it unusable.
+     *
+     * <p>As a convenience, every {@link Statement} associated with the connection is also closed,
+     * with any errors silently ignored.
+     *
+     * <p>Multiple calls have no further effect.
+     *
+     * @throws IOException if an error occurred while closing the connection
+     */
+    @Override
+    public void close() throws IOException {
+      if (connPtr != 0) {
+        // SQLite won't let us close the connection before first closing associated statements.
+        for (Statement stmt : ImmutableList.copyOf(openStatements)) {
+          stmt.close();
+        }
+        closeConn(connPtr);
+        connPtr = 0;
+      }
+    }
+
+    /**
+     * Creates a new {@link Statement}.
+     *
+     * @param sql a string containing a single SQL statement
+     * @throws IOException if the string contains multiple SQL statements, or the single SQL
+     *     statement could not be parsed and validated
+     */
+    public Statement newStatement(String sql) throws IOException {
+      checkState(connPtr != 0, "newStatement() called in invalid state");
+      Statement stmt = new Statement(this, sql);
+      openStatements.add(stmt);
+      return stmt;
+    }
+  }
+
+  /**
+   * A prepared statement.
+   *
+   * <p>Provides a facility to bind values to parameters and execute the statement by calling one of
+   * {@link #executeQuery} or {@link #executeUpdate}. The same statement may be executed multiple
+   * times, with its parameters possibly bound to different values, but there can be at most one
+   * ongoing execution at a time.
+   *
+   * <p>Parameters that haven't been bound or whose binding has been cleared behave as null.
+   */
+  public static final class Statement implements AutoCloseable {
+
+    // The connection owning this statement.
+    private Connection conn;
+
+    // C pointer to te `sqlite3_stmt` handle. Zero means the statement has been closed.
+    private long stmtPtr;
+
+    // The result of current execution, or null if no execution is ongoing.
+    @Nullable private Result currentResult;
+
+    private Statement(Connection conn, String sql) throws IOException {
+      this.conn = conn;
+      stmtPtr = prepareStmt(conn.connPtr, sql);
+      if (stmtPtr == -1) {
+        // Special value returned when a multi-statement string is detected.
+        throw new IOException("unsupported multi-statement string");
+      }
+    }
+
+    /**
+     * Closes the statement, rendering it unusable.
+     *
+     * <p>A {@link Result} previously returned by {@link #executeQuery} is also closed, with any
+     * error silently ignored.
+     *
+     * <p>Multiple calls have no additional effect.
+     */
+    @Override
+    public void close() {
+      if (stmtPtr != 0) {
+        if (currentResult != null) {
+          try {
+            currentResult.close();
+          } catch (IOException e) {
+            // Intentionally ignored: an error always pertains to a particular execution, and should
+            // only be reported when Result#close is called directly.
+          }
+        }
+        try {
+          finalizeStmt(stmtPtr);
+        } catch (IOException e) {
+          // Cannot occur since the statement has been reset by Result#close.
+          throw new IllegalStateException("unexpected exception thrown by finalize", e);
+        }
+        conn.openStatements.remove(this);
+        conn = null;
+        stmtPtr = 0;
+      }
+    }
+
+    /**
+     * Binds a long value to the statement's i-th parameter, counting from 1.
+     *
+     * <p>The binding remains in effect until it is cleared or another value is bound to the same
+     * parameter.
+     *
+     * <p>Must not be called after {@link #executeQuery} returns a {@link Result} and before the
+     * {@link Result} is closed.
+     */
+    public void bindLong(int i, long val) throws IOException {
+      checkState(stmtPtr != 0 && currentResult == null, "bindLong() called in invalid state");
+      bindStmtLong(stmtPtr, i, val);
+    }
+
+    /**
+     * Binds a double value to the statement's i-th parameter, counting from 1.
+     *
+     * <p>The binding remains in effect until it is cleared or another value is bound to the same
+     * parameter.
+     *
+     * <p>Must not be called after {@link #executeQuery} returns a {@link Result} and before the
+     * {@link Result} is closed.
+     */
+    public void bindDouble(int i, double val) throws IOException {
+      checkState(stmtPtr != 0 && currentResult == null, "bindDouble() called in invalid state");
+      bindStmtDouble(stmtPtr, i, val);
+    }
+
+    /**
+     * Binds a non-null string value to the statement's i-th parameter, counting from 1.
+     *
+     * <p>The binding remains in effect until it is cleared or another value is bound to the same
+     * parameter.
+     *
+     * <p>Must not be called after {@link #executeQuery} returns a {@link Result} and before the
+     * {@link Result} is closed.
+     */
+    public void bindString(int i, String val) throws IOException {
+      checkState(stmtPtr != 0 && currentResult == null, "bindString() called in invalid state");
+      checkNotNull(val);
+      bindStmtString(stmtPtr, i, val);
+    }
+
+    /**
+     * Clears the i-th binding.
+     *
+     * <p>Must not be called after {@link #executeQuery} returns a {@link Result} and before the
+     * {@link Result} is closed.
+     */
+    public void clearBinding(int i) throws IOException {
+      checkState(stmtPtr != 0 && currentResult == null, "clearBinding() called in invalid state");
+      clearStmtBinding(stmtPtr, i);
+    }
+
+    /**
+     * Clears all bindings.
+     *
+     * <p>Must not be called after {@link #executeQuery} returns a {@link Result} and before the
+     * {@link Result} is closed.
+     */
+    public void clearBindings() throws IOException {
+      checkState(stmtPtr != 0 && currentResult == null, "clearBindings() called in invalid state");
+      clearStmtBindings(stmtPtr);
+    }
+
+    /**
+     * Executes a statement expected to return a result.
+     *
+     * <p>Execution doesn't actually start until the first call to {@link Result#next}.
+     *
+     * <p>Must not be called again until the returned {@link Result} has been closed.
+     */
+    public Result executeQuery() {
+      checkState(stmtPtr != 0 && currentResult == null, "executeQuery() called in invalid state");
+      currentResult = new Result(this);
+      return currentResult;
+    }
+
+    /**
+     * Executes a statement not expected to return a result.
+     *
+     * <p>Must not be called after {@link #executeQuery} until the returned {@link Result} has been
+     * closed.
+     *
+     * @throws IOException if the statement returned a non-empty result or an execution error
+     *     occurred
+     */
+    public void executeUpdate() throws IOException {
+      checkState(stmtPtr != 0 && currentResult == null, "executeUpdate() called in invalid state");
+      currentResult = new Result(this);
+      try {
+        if (currentResult.next()) {
+          throw new IOException("unexpected non-empty result");
+        }
+      } finally {
+        currentResult.close();
+      }
+    }
+  }
+
+  /**
+   * The result of executing a statement.
+   *
+   * <p>Acts as a cursor to iterate over result rows and obtain the corresponding column values. The
+   * cursor is initially positioned before the first row. A call to {@link #next} moves the cursor
+   * to the next row, returning {@code false} once no more results are available. If a call to
+   * {@link #next} returns {@code true}, the getter methods may be called to retrieve the column
+   * values for the current row.
+   */
+  public static final class Result implements AutoCloseable {
+
+    // The statement owning this result.
+    private Statement stmt;
+
+    enum State {
+      START, // next() not yet called
+      CONTINUE, // last call to next() returned true
+      DONE, // last call to next() returned false, but close() not yet called
+      ERROR, // last call to next() threw, but close() not yet called
+      CLOSED // close() was called
+    }
+
+    private State state = State.START;
+
+    private Result(Statement stmt) {
+      this.stmt = stmt;
+    }
+
+    /**
+     * Closes the result, rendering it unusable.
+     *
+     * <p>Multiple calls have no additional effect.
+     *
+     * @throws IOException if an error occurred while finishing execution
+     */
+    @Override
+    public void close() throws IOException {
+      if (state != State.CLOSED) {
+        try {
+          resetStmt(stmt.stmtPtr);
+        } catch (IOException e) {
+          // Some statements may throw an error only after the result has been fully consumed.
+          // However, if the error has already been thrown by next(), don't throw it again.
+          if (state != State.ERROR) {
+            throw e;
+          }
+        } finally {
+          stmt.currentResult = null;
+          stmt = null;
+          state = State.CLOSED;
+        }
+      }
+    }
+
+    /**
+     * Advances the cursor the next row.
+     *
+     * <p>Must not be called further after {@code false} is returned or an exception is thrown.
+     *
+     * @return whether another row was available
+     * @throws IOException if an error occurred while executing the statement
+     */
+    public boolean next() throws IOException {
+      checkState(state == State.START || state == State.CONTINUE, "next() called in invalid state");
+
+      try {
+        boolean available = stepStmt(stmt.stmtPtr);
+        state = available ? State.CONTINUE : State.DONE;
+        return available;
+      } catch (IOException e) {
+        state = State.ERROR;
+        throw e;
+      }
+    }
+
+    /**
+     * Returns whether the i-th column for the current result row is null.
+     *
+     * <p>WARNING: this must be called before any of the getter methods. Calling a getter method may
+     * cause a conversion to occur, after which the return value of this method is unspecified.
+     */
+    public boolean isNull(int i) throws IOException {
+      checkState(state == State.CONTINUE, "isNull() called in invalid state");
+      return columnIsNull(stmt.stmtPtr, i);
+    }
+
+    /**
+     * Reads the i-th column for the current result row, starting from 0, as a long.
+     *
+     * <p>If the column is not of long type, a conversion occurs. In particular, null is converted
+     * to 0.
+     *
+     * <p>Must not be called unless the last call to {@link #next} returned {@code true}.
+     */
+    public long getLong(int i) throws IOException {
+      checkState(state == State.CONTINUE, "getLong() called in invalid state");
+      return columnLong(stmt.stmtPtr, i);
+    }
+
+    /**
+     * Reads the i-th column for the current result row, starting from 0, as a double.
+     *
+     * <p>If the column is not of double type, a conversion occurs. In particular, null is converted
+     * to 0.0.
+     *
+     * <p>Must not be called unless the last call to {@link #next} returned {@code true}.
+     */
+    public double getDouble(int i) throws IOException {
+      checkState(state == State.CONTINUE, "getDouble() called in invalid state");
+      return columnDouble(stmt.stmtPtr, i);
+    }
+
+    /**
+     * Reads the i-th column for the current result row, starting from 0, as a string.
+     *
+     * <p>If the column is not of string type, a conversion occurs. In particular, null is converted
+     * to the empty string.
+     *
+     * <p>Must not be called unless the last call to {@link #next} returned {@code true}.
+     */
+    public String getString(int i) throws IOException {
+      checkState(state == State.CONTINUE, "getString() called in invalid state");
+      return columnString(stmt.stmtPtr, i);
+    }
+  }
+
+  private static native long openConn(String path) throws IOException;
+
+  private static native void closeConn(long conn) throws IOException;
+
+  private static native long prepareStmt(long conn, String sql) throws IOException;
+
+  private static native void bindStmtLong(long stmt, int i, long value) throws IOException;
+
+  private static native void bindStmtDouble(long stmt, int i, double value) throws IOException;
+
+  private static native void bindStmtString(long stmt, int i, String value) throws IOException;
+
+  private static native void clearStmtBinding(long stmt, int i) throws IOException;
+
+  private static native void clearStmtBindings(long stmt) throws IOException;
+
+  private static native boolean stepStmt(long stmt) throws IOException;
+
+  private static native boolean columnIsNull(long stmt, int i) throws IOException;
+
+  private static native long columnLong(long stmt, int i) throws IOException;
+
+  private static native double columnDouble(long stmt, int i) throws IOException;
+
+  private static native String columnString(long stmt, int i) throws IOException;
+
+  private static native void resetStmt(long stmt) throws IOException;
+
+  private static native void finalizeStmt(long stmt) throws IOException;
+}
diff --git a/src/main/native/BUILD b/src/main/native/BUILD
index c011aef..31f6b1c 100644
--- a/src/main/native/BUILD
+++ b/src/main/native/BUILD
@@ -69,6 +69,23 @@
     alwayslink = 1,
 )
 
+cc_library(
+    name = "sqlite_jni",
+    srcs = [
+        "sqlite_jni.cc",
+        ":jni.h",
+        ":jni_md.h",
+    ],
+    includes = ["."],  # For jni headers.
+    visibility = ["//src/main/native:__subpackages__"],
+    deps = [
+        ":latin1_jni_path",
+        "//src/main/cpp/util:logging",
+        "@sqlite3",
+    ],
+    alwayslink = 1,
+)
+
 cc_binary(
     name = "libunix_jni.so",
     srcs = [
@@ -97,6 +114,7 @@
     deps = [
         ":blake3_jni",
         ":latin1_jni_path",
+        ":sqlite_jni",
         "//src/main/cpp/util:logging",
         "//src/main/cpp/util:md5",
         "//src/main/cpp/util:port",
diff --git a/src/main/native/sqlite_jni.cc b/src/main/native/sqlite_jni.cc
new file mode 100644
index 0000000..f1f83ac
--- /dev/null
+++ b/src/main/native/sqlite_jni.cc
@@ -0,0 +1,230 @@
+// Copyright 2024 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <jni.h>
+
+#include <string>
+
+#include "src/main/cpp/util/logging.h"
+#include "src/main/native/latin1_jni_path.h"
+#include "sqlite3.h"
+
+namespace blaze_jni {
+
+namespace {
+
+// A RAII wrapper around a null-terminated UTF string obtained from a jstring.
+class ScopedUTFString {
+ public:
+  ScopedUTFString(JNIEnv *env, jstring jstr)
+      : env_(env),
+        jstr_(jstr),
+        str_(env->GetStringUTFChars(jstr, nullptr)),
+        len_(env->GetStringUTFLength(jstr)) {}
+
+  ~ScopedUTFString() { env_->ReleaseStringUTFChars(jstr_, str_); }
+
+  const char *c_str() const { return str_; }
+
+  int length() const { return len_; }
+
+ private:
+  JNIEnv *env_;
+  jstring jstr_;
+  const char *str_;
+  int len_;
+};
+
+// Throws an exception for the given JNI function name and SQLite error code.
+void PostException(JNIEnv *env, const std::string &fn, int err) {
+  std::string message =
+      fn + ": [" + std::to_string(err) + "] " + sqlite3_errstr(err);
+  bool success = false;
+  jclass exc_class = env->FindClass("java/io/IOException");
+  if (exc_class != nullptr) {
+    success = env->ThrowNew(exc_class, message.c_str()) == 0;
+  }
+  if (!success) {
+    BAZEL_LOG(FATAL) << "Failed to throw Java exception from JNI: "
+                     << message.c_str();
+  }
+}
+
+}  // namespace
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_openConn(
+    JNIEnv *env, jclass cls, jstring path_str) {
+  const char *path = GetStringLatin1Chars(env, path_str);
+  sqlite3 *conn = nullptr;
+  int err = sqlite3_open(path, &conn);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_open", err);
+  }
+  ReleaseStringLatin1Chars(path);
+  return reinterpret_cast<jlong>(conn);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_closeConn(
+    JNIEnv *env, jclass cls, jlong conn_ptr) {
+  sqlite3 *conn = reinterpret_cast<sqlite3 *>(conn_ptr);
+  int err = sqlite3_close(conn);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_close", err);
+  }
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_prepareStmt(
+    JNIEnv *env, jclass cls, jlong conn_ptr, jstring sql_jstr) {
+  sqlite3 *conn = reinterpret_cast<sqlite3 *>(conn_ptr);
+  ScopedUTFString sql(env, sql_jstr);
+  sqlite3_stmt *stmt;
+  const char *sql_tail;
+  int err = sqlite3_prepare_v3(conn, sql.c_str(), sql.length(),
+                               SQLITE_PREPARE_PERSISTENT, &stmt, &sql_tail);
+  if (err == SQLITE_OK && *sql_tail != '\0') {
+    // Return special value to signal an unsupported multi-statement string.
+    sqlite3_finalize(stmt);
+    return -1L;
+  }
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_prepare_v3", err);
+  }
+  return reinterpret_cast<jlong>(stmt);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_bindStmtLong(
+    JNIEnv *env, jclass cls, jlong stmt_ptr, jint i, jlong val) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  int err = sqlite3_bind_int64(stmt, i, val);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_bind_int64", err);
+  }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_bindStmtDouble(
+    JNIEnv *env, jclass cls, jlong stmt_ptr, jint i, jdouble val) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  int err = sqlite3_bind_double(stmt, i, val);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_bind_double", err);
+  }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_bindStmtString(
+    JNIEnv *env, jclass cls, jlong stmt_ptr, jint i, jstring val_jstr) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  ScopedUTFString val(env, val_jstr);
+  int err =
+      sqlite3_bind_text(stmt, i, val.c_str(), val.length(), SQLITE_TRANSIENT);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_bind_text", err);
+  }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_clearStmtBinding(
+    JNIEnv *env, jclass cls, jlong stmt_ptr, jint i) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  int err = sqlite3_bind_null(stmt, i);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_bind_null", err);
+  }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_clearStmtBindings(
+    JNIEnv *env, jclass cls, jlong stmt_ptr) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  int err = sqlite3_clear_bindings(stmt);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_clear_bindings", err);
+  }
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_stepStmt(JNIEnv *env,
+                                                               jclass cls,
+                                                               jlong stmt_ptr) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  int err = sqlite3_step(stmt);
+  // Deviation from the C API: SQLITE_ROW and SQLITE_DONE are returned as true
+  // or false, respectively. Everything else causes an exception to be thrown.
+  if (err == SQLITE_ROW) {
+    return true;
+  } else if (err == SQLITE_DONE) {
+    return false;
+  }
+  PostException(env, "sqlite3_step", err);
+  return false;
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_columnIsNull(
+    JNIEnv *env, jclass cls, jlong stmt_ptr, jint i) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  return sqlite3_column_type(stmt, i) == SQLITE_NULL;
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_columnLong(JNIEnv *env,
+                                                                 jclass cls,
+                                                                 jlong stmt_ptr,
+                                                                 jint i) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  return sqlite3_column_int64(stmt, i);
+}
+
+extern "C" JNIEXPORT jdouble JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_columnDouble(
+    JNIEnv *env, jclass cls, jlong stmt_ptr, jint i) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  return sqlite3_column_double(stmt, i);
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_columnString(
+    JNIEnv *env, jclass cls, jlong stmt_ptr, jint i) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  const char *val =
+      reinterpret_cast<const char *>(sqlite3_column_text(stmt, i));
+  return val != nullptr ? env->NewStringUTF(val) : env->NewStringUTF("");
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_resetStmt(
+    JNIEnv *env, jclass cls, jlong stmt_ptr) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  int err = sqlite3_reset(stmt);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_reset", err);
+  }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_devtools_build_lib_remote_disk_Sqlite_finalizeStmt(
+    JNIEnv *env, jclass cls, jlong stmt_ptr) {
+  sqlite3_stmt *stmt = reinterpret_cast<sqlite3_stmt *>(stmt_ptr);
+  int err = sqlite3_finalize(stmt);
+  if (err != SQLITE_OK) {
+    PostException(env, "sqlite3_finalize", err);
+  }
+}
+
+}  // namespace blaze_jni
diff --git a/src/main/native/unix_jni.cc b/src/main/native/unix_jni.cc
index 893507d..c05d54d 100644
--- a/src/main/native/unix_jni.cc
+++ b/src/main/native/unix_jni.cc
@@ -65,7 +65,8 @@
     success = env->ThrowNew(exception_class, message.c_str()) == 0;
   }
   if (!success) {
-    BAZEL_LOG(FATAL) << "Failure to throw java error: " << message.c_str();
+    BAZEL_LOG(FATAL) << "Failed to throw Java exception from JNI: "
+                     << message.c_str();
   }
 }
 
diff --git a/src/main/native/windows/BUILD b/src/main/native/windows/BUILD
index b595e75..c7e3de4 100644
--- a/src/main/native/windows/BUILD
+++ b/src/main/native/windows/BUILD
@@ -77,6 +77,7 @@
         ":lib-file",
         ":lib-process",
         "//src/main/native:blake3_jni",
+        "//src/main/native:sqlite_jni",
     ],
 )
 
diff --git a/src/test/java/com/google/devtools/build/lib/remote/disk/BUILD b/src/test/java/com/google/devtools/build/lib/remote/disk/BUILD
index e088c67..e437a4e 100644
--- a/src/test/java/com/google/devtools/build/lib/remote/disk/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/remote/disk/BUILD
@@ -29,6 +29,7 @@
         "//src/main/java/com/google/devtools/build/lib/vfs/bazel",
         "//src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs",
         "//src/test/java/com/google/devtools/build/lib:test_runner",
+        "//src/test/java/com/google/devtools/build/lib/testutil:TestUtils",
         "//third_party:error_prone_annotations",
         "//third_party:guava",
         "//third_party:junit4",
diff --git a/src/test/java/com/google/devtools/build/lib/remote/disk/SqliteTest.java b/src/test/java/com/google/devtools/build/lib/remote/disk/SqliteTest.java
new file mode 100644
index 0000000..8b6358c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/remote/disk/SqliteTest.java
@@ -0,0 +1,276 @@
+// Copyright 2024 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.remote.disk;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import com.google.devtools.build.lib.remote.disk.Sqlite.Connection;
+import com.google.devtools.build.lib.remote.disk.Sqlite.Result;
+import com.google.devtools.build.lib.remote.disk.Sqlite.Statement;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import java.io.IOException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class SqliteTest {
+
+  private Path dbPath;
+
+  @Before
+  public void setUp() throws Exception {
+    dbPath = TestUtils.createUniqueTmpDir(null).getChild("tmp.db");
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    try {
+      dbPath.delete();
+    } catch (IOException e) {
+      // Intentionally ignored.
+    }
+  }
+
+  @Test
+  public void executeQuery_withEmptyResult_nextReturnsFalse() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT 1 LIMIT 0");
+        Result result = stmt.executeQuery()) {
+      assertThat(result.next()).isFalse();
+    }
+  }
+
+  @Test
+  public void executeQuery_withNonEmptyResult_nextReturnsTrue() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3");
+        Result result = stmt.executeQuery()) {
+      assertThat(result.next()).isTrue();
+      assertThat(result.next()).isTrue();
+      assertThat(result.next()).isTrue();
+      assertThat(result.next()).isFalse();
+    }
+  }
+
+  @Test
+  public void executeQuery_getterCalledBeforeNextReturnsTrue_throws() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT 1");
+        Result result = stmt.executeQuery()) {
+      assertThrows(IllegalStateException.class, () -> result.isNull(0));
+      assertThrows(IllegalStateException.class, () -> result.getLong(0));
+      assertThrows(IllegalStateException.class, () -> result.getDouble(0));
+      assertThrows(IllegalStateException.class, () -> result.getString(0));
+    }
+  }
+
+  @Test
+  public void executeQuery_getterCalledAfterNextReturnsFalse_throws() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT 1 LIMIT 0");
+        Result result = stmt.executeQuery()) {
+      assertThat(result.next()).isFalse();
+      assertThrows(IllegalStateException.class, () -> result.isNull(0));
+      assertThrows(IllegalStateException.class, () -> result.getLong(0));
+      assertThrows(IllegalStateException.class, () -> result.getDouble(0));
+      assertThrows(IllegalStateException.class, () -> result.getString(0));
+    }
+  }
+
+  @Test
+  public void executeQuery_prematureClose_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT 1");
+        Result result = stmt.executeQuery()) {}
+  }
+
+  @Test
+  public void executeQuery_gettersConvertNull() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT NULL, NULL, NULL");
+        Result result = stmt.executeQuery()) {
+      assertThat(result.next()).isTrue();
+      assertThat(result.isNull(0)).isTrue();
+      assertThat(result.getLong(0)).isEqualTo(0);
+      assertThat(result.isNull(1)).isTrue();
+      assertThat(result.getDouble(1)).isEqualTo(0.0);
+      assertThat(result.isNull(2)).isTrue();
+      assertThat(result.getString(2)).isEmpty();
+    }
+  }
+
+  @Test
+  public void executeQuery_onError_throws() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("CREATE TABLE tbl (id INTEGER)")) {
+      try (Result result = stmt.executeQuery()) {
+        assertThat(result.next()).isFalse();
+      }
+      try (Result result = stmt.executeQuery()) {
+        IOException e = assertThrows(IOException.class, result::next);
+        assertThat(e).hasMessageThat().contains("SQL logic error");
+      }
+    }
+  }
+
+  @Test
+  public void executeUpdate_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath)) {
+      try (Statement stmt = conn.newStatement("CREATE TABLE tbl (id INTEGER)")) {
+        stmt.executeUpdate();
+      }
+
+      try (Statement stmt = conn.newStatement("SELECT COUNT(*) FROM tbl");
+          Result result = stmt.executeQuery()) {
+        assertThat(result.next()).isTrue();
+      }
+    }
+  }
+
+  @Test
+  public void executeUpdate_withParameters_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath)) {
+      try (Statement stmt = conn.newStatement("CREATE TABLE tbl AS SELECT ?, ?, ?")) {
+        stmt.bindLong(1, 42);
+        stmt.bindDouble(2, 3.14);
+        stmt.bindString(3, "hello");
+        stmt.executeUpdate();
+      }
+
+      try (Statement stmt = conn.newStatement("SELECT * FROM tbl");
+          Result result = stmt.executeQuery()) {
+        assertThat(result.next()).isTrue();
+        assertThat(result.isNull(0)).isFalse();
+        assertThat(result.getLong(0)).isEqualTo(42);
+        assertThat(result.isNull(1)).isFalse();
+        assertThat(result.getDouble(1)).isEqualTo(3.14);
+        assertThat(result.isNull(2)).isFalse();
+        assertThat(result.getString(2)).isEqualTo("hello");
+        assertThat(result.next()).isFalse();
+      }
+    }
+  }
+
+  @Test
+  public void executeUpdate_withNonEmptyResult_throws() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT NULL")) {
+      IOException e = assertThrows(IOException.class, stmt::executeUpdate);
+      assertThat(e).hasMessageThat().contains("unexpected non-empty result");
+    }
+  }
+
+  @Test
+  public void executeUpdate_onError_throws() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("CREATE TABLE tbl (id INTEGER)")) {
+      stmt.executeUpdate();
+      IOException e = assertThrows(IOException.class, stmt::executeUpdate);
+      assertThat(e).hasMessageThat().contains("SQL logic error");
+    }
+  }
+
+  @Test
+  public void clearBinding_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT ?, ?")) {
+      stmt.bindString(1, "abc");
+      stmt.bindString(2, "def");
+
+      stmt.clearBinding(1);
+      try (Result result = stmt.executeQuery()) {
+        assertThat(result.next()).isTrue();
+        assertThat(result.isNull(0)).isTrue();
+        assertThat(result.isNull(1)).isFalse();
+        assertThat(result.next()).isFalse();
+      }
+
+      stmt.clearBinding(2);
+      try (Result result = stmt.executeQuery()) {
+        assertThat(result.next()).isTrue();
+        assertThat(result.isNull(0)).isTrue();
+        assertThat(result.isNull(1)).isTrue();
+        assertThat(result.next()).isFalse();
+      }
+    }
+  }
+
+  @Test
+  public void clearBindings_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT ?, ?")) {
+      stmt.bindString(1, "abc");
+      stmt.bindString(2, "def");
+      stmt.clearBindings();
+
+      try (Result result = stmt.executeQuery()) {
+        assertThat(result.next()).isTrue();
+        assertThat(result.isNull(0)).isTrue();
+        assertThat(result.isNull(1)).isTrue();
+        assertThat(result.next()).isFalse();
+      }
+    }
+  }
+
+  @Test
+  public void newStatement_withInvalidStatement_throws() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath)) {
+      IOException e = assertThrows(IOException.class, () -> conn.newStatement("i am not sql"));
+      assertThat(e).hasMessageThat().contains("[1] SQL logic error");
+    }
+  }
+
+  @Test
+  public void newStatement_withTrailingSemicolon_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT 1;")) {}
+  }
+
+  @Test
+  public void newStatement_withMultipleStatements_throws() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath)) {
+      IOException e =
+          assertThrows(IOException.class, () -> conn.newStatement("SELECT 1; SELECT 2"));
+      assertThat(e).hasMessageThat().contains("unsupported multi-statement string");
+    }
+  }
+
+  @Test
+  public void closeStatement_withOpenResult_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath);
+        Statement stmt = conn.newStatement("SELECT 1")) {
+      Result unusedResult = stmt.executeQuery();
+    }
+  }
+
+  @Test
+  public void closeConnection_withOpenStatement_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath)) {
+      Statement unusedStmt = conn.newStatement("SELECT 1");
+    }
+  }
+
+  @Test
+  public void closeConnection_withOpenStatementAndResult_works() throws Exception {
+    try (Connection conn = Sqlite.newConnection(dbPath)) {
+      Statement stmt = conn.newStatement("SELECT 1");
+      Result unusedResult = stmt.executeQuery();
+    }
+  }
+}