diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9509fad5b4..8016bf9f0f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -83,7 +83,7 @@ jobs:
 #    strategy:
 #      matrix:
 #        os: [ ubuntu-latest, windows-latest, macos-latest ]
-#        java: [ '17', '21' ]
+#        java: [ '17', '21', '22' ]
 #        profiles: ['native', 'native,native-exported']
 #    runs-on: ${{ matrix.os }}
 #    steps:
diff --git a/README.adoc b/README.adoc
index ecfe43834a..40438f2941 100644
--- a/README.adoc
+++ b/README.adoc
@@ -1,5 +1,5 @@
 = SQLite JDBC Driver
-:project-version: 3.46.0.1
+:project-version: 3.47.0.0
 
 image:https://img.shields.io/github/actions/workflow/status/willena/sqlite-jdbc-crypt/ci.yml?branch=master[GitHub Workflow Status (branch),link=https://github.com/willena/sqlite-jdbc/actions/workflows/ci.yml?query=branch%3Amaster]
 image:https://maven-badges.herokuapp.com/maven-central/io.github.willena/sqlite-jdbc/badge.svg[Maven Central,link=https://maven-badges.herokuapp.com/maven-central/io.github.willena/sqlite-jdbc/]
@@ -29,19 +29,18 @@ SQLite JDBC is a library for accessing SQLite databases through the JDBC API. Fo
 
 . <<Download,Download>> `sqlite-jdbc-{project-version}.jar`
 then append this jar file into your classpath.
-. https://search.maven.org/remotecontent?filepath=org/slf4j/slf4j-api/1.7.36/slf4j-api-1.7.36.jar[Download] `slf4j-api-1.7.36.jar` then append this jar file into your classpath.
 . Open a SQLite database connection from your code. (see the example below)
 
 === Example usage
 
-Assuming `sqlite-jdbc-{project-version}.jar` and `slf4j-api-1.7.36.jar` are placed in the current directory.
+Assuming `sqlite-jdbc-{project-version}.jar` is placed in the current directory.
 
 [source,shell,subs="attributes+"]
 ----
 > javac Sample.java
-> java -classpath ".;sqlite-jdbc-{project-version}.jar;slf4j-api-1.7.36.jar" Sample   # in Windows
+> java -classpath ".;sqlite-jdbc-{project-version}.jar" Sample   # in Windows
 or
-> java -classpath ".:sqlite-jdbc-{project-version}.jar:slf4j-api-1.7.36.jar" Sample   # in macOS or Linux
+> java -classpath ".:sqlite-jdbc-{project-version}.jar" Sample   # in macOS or Linux
 name = leo
 id = 1
 name = yui
@@ -116,7 +115,7 @@ the following operating systems:
 |macOS | |✔ | | | |✔ | |
 |Linux (libc) |✔ |✔ |✔ |✔ |✔ |✔ |✔ |✔ 
 |Linux (musl) |✔ |✔ | | | |✔ | |
-|Android |✔ |✔ |✔ | | |✔ | |
+|Android (API Level 24+) |✔ |✔ |✔ | | |✔ | |
 |FreeBSD |✔ |✔ | | | |✔ | |
 |===
 
diff --git a/USAGE.md b/USAGE.md
index e095a57b0e..a738462fa7 100644
--- a/USAGE.md
+++ b/USAGE.md
@@ -233,6 +233,22 @@ Here is what you need to know.
 4. Change the key to `null` using`PRAGMA rekey=''`
 5. Use normally
 
+## Generated keys
+
+SQLite has limited support to retrieve generated keys, using [last_insert_rowid](https://www.sqlite.org/c3ref/last_insert_rowid.html), with the following limitations:
+- a single ID can be retrieved, even if multiple rows were added or updated
+- it needs to be called right after the statement
+
+By default the driver will eagerly retrieve the generated keys after each statement, which may impact performances.
+
+You can disable the retrieval of generated keys in 3 ways:
+- via `SQLiteDataSource#setGetGeneratedKeys(false)`
+- via `SQLiteConnectionConfig#setGetGeneratedKeys(false)`:
+- using the pragma `jdbc.get_generated_keys`:
+```java
+try (Connection connection = DriverManager.getConnection("jdbc:sqlite::memory:?jdbc.get_generated_keys=false")) { /*...*/ }
+```
+
 ## Explicit read only transactions (use with Hibernate)
 
 In order for the driver to be compliant with Hibernate, it needs to allow setting the read only flag after a connection has been created.
diff --git a/VERSION b/VERSION
index d953991651..400f47059e 100644
--- a/VERSION
+++ b/VERSION
@@ -1,3 +1,3 @@
-version=3.46.1
-artifactVersion=3.46.1.1-SNAPSHOT
-sqliteMCVersion=1.8.7
+version=3.47.0
+artifactVersion=3.47.0.0-SNAPSHOT
+sqliteMCVersion=1.9.0
diff --git a/pom.xml b/pom.xml
index 13e17fdd50..2a28f50217 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,17 +4,17 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>io.github.willena</groupId>
     <artifactId>sqlite-jdbc</artifactId>
-    <version>3.46.1.1-SNAPSHOT</version>
+    <version>3.47.0.0-SNAPSHOT</version>
     <name>SQLite JDBC</name>
     <description>SQLite JDBC library with encryption and authentication support</description>
     <url>https://github.com/Willena/sqlite-jdbc-crypt</url>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <junit.version>5.10.3</junit.version>
-        <surefire.version>3.3.1</surefire.version>
+        <junit.version>5.11.3</junit.version>
+        <surefire.version>3.5.2</surefire.version>
         <archunit.version>1.3.0</archunit.version>
-        <graalvm.version>24.0.2</graalvm.version>
+        <graalvm.version>24.1.1</graalvm.version>
         <java9.sourceDirectory>${project.basedir}/src/main/java9</java9.sourceDirectory>
     </properties>
 
@@ -93,7 +93,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-help-plugin</artifactId>
-                <version>3.4.1</version>
+                <version>3.5.1</version>
             </plugin>
 
             <plugin>
@@ -280,7 +280,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-gpg-plugin</artifactId>
-                        <version>3.2.5</version>
+                        <version>3.2.7</version>
                         <configuration>
                             <!-- Prevent gpg from using pinentry programs -->
                             <gpgArguments>
@@ -301,7 +301,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-javadoc-plugin</artifactId>
-                        <version>3.8.0</version>
+                        <version>3.11.1</version>
                         <configuration>
                             <sourcepath>src/main/java</sourcepath>
                             <additionalOptions>-Xdoclint:none</additionalOptions>
@@ -340,7 +340,7 @@
                     <plugin>
                         <groupId>org.graalvm.buildtools</groupId>
                         <artifactId>native-maven-plugin</artifactId>
-                        <version>0.10.2</version>
+                        <version>0.10.3</version>
                         <extensions>true</extensions>
                         <executions>
                             <execution>
@@ -354,6 +354,10 @@
                         <configuration>
                             <fallback>false</fallback>
                             <verbose>true</verbose>
+                            <buildArgs>
+                                <!-- required to allow junit-pioneer to compile with strict image heap enabled -->
+                                <arg>--initialize-at-build-time=org.junitpioneer.jupiter.issue.IssueExtensionExecutionListener</arg>
+                            </buildArgs>
                         </configuration>
                     </plugin>
 
@@ -413,6 +417,7 @@
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
             <version>1.7.36</version>
+            <optional>true</optional>
         </dependency>
         <!--
         This dependency makes compilation on non-GraalVM versions possible.
@@ -450,13 +455,13 @@
         <dependency>
             <groupId>org.junit-pioneer</groupId>
             <artifactId>junit-pioneer</artifactId>
-            <version>2.2.0</version>
+            <version>2.3.0</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>5.12.0</version>
+            <version>5.14.2</version>
             <scope>test</scope>
         </dependency>
         <dependency>
diff --git a/src/main/java/org/sqlite/JDBC.java b/src/main/java/org/sqlite/JDBC.java
index 42f4499f49..9c4813af44 100644
--- a/src/main/java/org/sqlite/JDBC.java
+++ b/src/main/java/org/sqlite/JDBC.java
@@ -18,19 +18,19 @@
 
 import java.sql.*;
 import java.util.Properties;
-import java.util.logging.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.jdbc4.JDBC4Connection;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 
 public class JDBC implements Driver {
-    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(JDBC.class);
+    private static final Logger logger = LoggerFactory.getLogger(JDBC.class);
     public static final String PREFIX = "jdbc:sqlite:";
 
     static {
         try {
             DriverManager.registerDriver(new JDBC());
         } catch (SQLException e) {
-            logger.error("Could not register driver", e);
+            logger.error(() -> "Could not register driver", e);
         }
     }
 
@@ -49,7 +49,7 @@ public boolean jdbcCompliant() {
         return false;
     }
 
-    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
+    public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException {
         // TODO
         return null;
     }
diff --git a/src/main/java/org/sqlite/SQLiteConfig.java b/src/main/java/org/sqlite/SQLiteConfig.java
index 9d720533d0..01c0cd4a8f 100755
--- a/src/main/java/org/sqlite/SQLiteConfig.java
+++ b/src/main/java/org/sqlite/SQLiteConfig.java
@@ -189,6 +189,7 @@ public void apply(Connection conn) throws SQLException {
 
         // exclude this "fake" pragma from execution
         pragmaParams.remove(Pragma.JDBC_EXPLICIT_READONLY.pragmaName);
+        pragmaParams.remove(Pragma.JDBC_GET_GENERATED_KEYS.pragmaName);
 
         setupConnection(conn, pragmaParams, pragmaTable);
         try (Statement stat = conn.createStatement()) {
@@ -369,6 +370,9 @@ public Properties toProperties() {
                 defaultConnectionConfig.getDateStringFormat());
         pragmaTable.setProperty(
                 Pragma.JDBC_EXPLICIT_READONLY.pragmaName, this.explicitReadOnly ? "true" : "false");
+        pragmaTable.setProperty(
+                Pragma.JDBC_GET_GENERATED_KEYS.pragmaName,
+                defaultConnectionConfig.isGetGeneratedKeys() ? "true" : "false");
         return pragmaTable;
     }
 
@@ -581,6 +585,8 @@ public enum Pragma {
         // extensions: "fake" pragmas to allow conformance with JDBC
         JDBC_EXPLICIT_READONLY(
                 "jdbc.explicit_readonly", "Set explicit read only transactions", null),
+        JDBC_GET_GENERATED_KEYS(
+                "jdbc.get_generated_keys", "Enable retrieval of generated keys", OnOff.Values),
 
         // New pragmas for SQLiteMC improved support
         KEY("key", "Specify at least the encryption key", null),
@@ -1317,4 +1323,12 @@ public void setBusyTimeout(int milliseconds) {
     public int getBusyTimeout() {
         return parseLimitPragma(Pragma.BUSY_TIMEOUT, 3000);
     }
+
+    public boolean isGetGeneratedKeys() {
+        return this.defaultConnectionConfig.isGetGeneratedKeys();
+    }
+
+    public void setGetGeneratedKeys(boolean generatedKeys) {
+        this.defaultConnectionConfig.setGetGeneratedKeys(generatedKeys);
+    }
 }
diff --git a/src/main/java/org/sqlite/SQLiteConnectionConfig.java b/src/main/java/org/sqlite/SQLiteConnectionConfig.java
index 749efb203f..277b4db55a 100644
--- a/src/main/java/org/sqlite/SQLiteConnectionConfig.java
+++ b/src/main/java/org/sqlite/SQLiteConnectionConfig.java
@@ -19,6 +19,7 @@ public class SQLiteConnectionConfig implements Cloneable {
     private int transactionIsolation = Connection.TRANSACTION_SERIALIZABLE;
     private SQLiteConfig.TransactionMode transactionMode = SQLiteConfig.TransactionMode.DEFERRED;
     private boolean autoCommit = true;
+    private boolean getGeneratedKeys = true;
 
     public static SQLiteConnectionConfig fromPragmaTable(Properties pragmaTable) {
         return new SQLiteConnectionConfig(
@@ -38,7 +39,10 @@ public static SQLiteConnectionConfig fromPragmaTable(Properties pragmaTable) {
                         pragmaTable.getProperty(
                                 SQLiteConfig.Pragma.TRANSACTION_MODE.pragmaName,
                                 SQLiteConfig.TransactionMode.DEFERRED.name())),
-                true);
+                true,
+                Boolean.parseBoolean(
+                        pragmaTable.getProperty(
+                                SQLiteConfig.Pragma.JDBC_GET_GENERATED_KEYS.pragmaName, "true")));
     }
 
     public SQLiteConnectionConfig(
@@ -47,13 +51,15 @@ public SQLiteConnectionConfig(
             String dateStringFormat,
             int transactionIsolation,
             SQLiteConfig.TransactionMode transactionMode,
-            boolean autoCommit) {
+            boolean autoCommit,
+            boolean getGeneratedKeys) {
         setDateClass(dateClass);
         setDatePrecision(datePrecision);
         setDateStringFormat(dateStringFormat);
         setTransactionIsolation(transactionIsolation);
         setTransactionMode(transactionMode);
         setAutoCommit(autoCommit);
+        setGetGeneratedKeys(getGeneratedKeys);
     }
 
     public SQLiteConnectionConfig copyConfig() {
@@ -63,7 +69,8 @@ public SQLiteConnectionConfig copyConfig() {
                 dateStringFormat,
                 transactionIsolation,
                 transactionMode,
-                autoCommit);
+                autoCommit,
+                getGeneratedKeys);
     }
 
     public long getDateMultiplier() {
@@ -124,8 +131,16 @@ public void setTransactionMode(SQLiteConfig.TransactionMode transactionMode) {
         this.transactionMode = transactionMode;
     }
 
+    public boolean isGetGeneratedKeys() {
+        return getGeneratedKeys;
+    }
+
+    public void setGetGeneratedKeys(boolean getGeneratedKeys) {
+        this.getGeneratedKeys = getGeneratedKeys;
+    }
+
     private static final Map<SQLiteConfig.TransactionMode, String> beginCommandMap =
-            new EnumMap<SQLiteConfig.TransactionMode, String>(SQLiteConfig.TransactionMode.class);
+            new EnumMap<>(SQLiteConfig.TransactionMode.class);
 
     static {
         beginCommandMap.put(SQLiteConfig.TransactionMode.DEFERRED, "begin;");
diff --git a/src/main/java/org/sqlite/SQLiteDataSource.java b/src/main/java/org/sqlite/SQLiteDataSource.java
index 3004cb01b4..77dd6a1c19 100755
--- a/src/main/java/org/sqlite/SQLiteDataSource.java
+++ b/src/main/java/org/sqlite/SQLiteDataSource.java
@@ -449,6 +449,15 @@ public void setTransactionMode(String transactionMode) {
         config.setTransactionMode(transactionMode);
     }
 
+    /**
+     * Configure where generated keys will be retrieved for this database.
+     *
+     * @param generatedKeys true to retrieve generated keys
+     */
+    public void setGetGeneratedKeys(boolean generatedKeys) {
+        config.setGetGeneratedKeys(generatedKeys);
+    }
+
     /**
      * Sets the value of the user-version. It is a big-endian 32-bit signed integer stored in the
      * database header at offset 60.
diff --git a/src/main/java/org/sqlite/SQLiteJDBCLoader.java b/src/main/java/org/sqlite/SQLiteJDBCLoader.java
index 684bf8a783..f34f18b3c1 100644
--- a/src/main/java/org/sqlite/SQLiteJDBCLoader.java
+++ b/src/main/java/org/sqlite/SQLiteJDBCLoader.java
@@ -34,14 +34,15 @@
 import java.security.DigestInputStream;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.text.MessageFormat;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Properties;
 import java.util.UUID;
 import java.util.stream.Stream;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.util.LibraryLoaderUtil;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 import org.sqlite.util.OSInfo;
 import org.sqlite.util.StringUtils;
 
@@ -101,12 +102,12 @@ static void cleanup() {
                                     try {
                                         Files.delete(nativeLib);
                                     } catch (Exception e) {
-                                        logger.error("Failed to delete old native lib", e);
+                                        logger.error(() -> "Failed to delete old native lib", e);
                                     }
                                 }
                             });
         } catch (IOException e) {
-            logger.error("Failed to open directory", e);
+            logger.error(() -> "Failed to open directory", e);
         }
     }
 
@@ -222,7 +223,7 @@ private static boolean extractAndLoadLibraryFile(
             }
             return loadNativeLibrary(targetFolder, extractedLibFileName);
         } catch (IOException e) {
-            logger.error("Unexpected IOException", e);
+            logger.error(() -> "Unexpected IOException", e);
             return false;
         }
     }
@@ -246,7 +247,7 @@ private static InputStream getResourceAsStream(String name) {
             connection.setUseCaches(false);
             return connection.getInputStream();
         } catch (IOException e) {
-            logger.error("Could not connect", e);
+            logger.error(() -> "Could not connect", e);
             return null;
         }
     }
@@ -268,9 +269,10 @@ private static boolean loadNativeLibrary(String path, String name) {
             } catch (UnsatisfiedLinkError e) {
 
                 logger.error(
-                        "Failed to load native library: {}. osinfo: {}",
-                        name,
-                        OSInfo.getNativeLibFolderPathForCurrentOS(),
+                        () ->
+                                MessageFormat.format(
+                                        "Failed to load native library: {0}. osinfo: {1}",
+                                        name, OSInfo.getNativeLibFolderPathForCurrentOS()),
                         e);
                 return false;
             }
@@ -285,7 +287,7 @@ private static boolean loadNativeLibraryJdk() {
             System.loadLibrary(LibraryLoaderUtil.NATIVE_LIB_BASE_NAME);
             return true;
         } catch (UnsatisfiedLinkError e) {
-            logger.error("Failed to load native library through System.loadLibrary", e);
+            logger.error(() -> "Failed to load native library through System.loadLibrary", e);
             return false;
         }
     }
@@ -419,8 +421,14 @@ public static final class VersionHolder {
             } catch (IOException e) {
                 // inline creation of logger to avoid build-time initialization of the logging
                 // framework in native-image
+                URL finalVersionFile = versionFile;
                 LoggerFactory.getLogger(VersionHolder.class)
-                        .error("Could not read version from file: {}", versionFile, e);
+                        .error(
+                                () ->
+                                        MessageFormat.format(
+                                                "Could not read version from file: {0}",
+                                                finalVersionFile),
+                                e);
             }
             VERSION = version;
         }
diff --git a/src/main/java/org/sqlite/core/CoreStatement.java b/src/main/java/org/sqlite/core/CoreStatement.java
index e74d399792..62b1aa600a 100644
--- a/src/main/java/org/sqlite/core/CoreStatement.java
+++ b/src/main/java/org/sqlite/core/CoreStatement.java
@@ -181,10 +181,12 @@ protected void clearGeneratedKeys() throws SQLException {
      * block.
      */
     public void updateGeneratedKeys() throws SQLException {
-        clearGeneratedKeys();
-        if (sql != null && INSERT_PATTERN.matcher(sql).find()) {
-            generatedKeysStat = conn.createStatement();
-            generatedKeysRs = generatedKeysStat.executeQuery("SELECT last_insert_rowid();");
+        if (conn.getConnectionConfig().isGetGeneratedKeys()) {
+            clearGeneratedKeys();
+            if (sql != null && INSERT_PATTERN.matcher(sql).find()) {
+                generatedKeysStat = conn.createStatement();
+                generatedKeysRs = generatedKeysStat.executeQuery("SELECT last_insert_rowid();");
+            }
         }
     }
 
diff --git a/src/main/java/org/sqlite/core/NativeDB.java b/src/main/java/org/sqlite/core/NativeDB.java
index f23269db6c..a71e8ea9c8 100644
--- a/src/main/java/org/sqlite/core/NativeDB.java
+++ b/src/main/java/org/sqlite/core/NativeDB.java
@@ -19,14 +19,15 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.sql.SQLException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.text.MessageFormat;
 import org.sqlite.BusyHandler;
 import org.sqlite.Collation;
 import org.sqlite.Function;
 import org.sqlite.ProgressHandler;
 import org.sqlite.SQLiteConfig;
 import org.sqlite.SQLiteJDBCLoader;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 
 /** This class provides a thin JNI layer over the SQLite3 C API. */
 public final class NativeDB extends DB {
@@ -90,10 +91,11 @@ protected synchronized void _open(String file, int openFlags) throws SQLExceptio
     /** @see org.sqlite.core.DB#_exec(java.lang.String) */
     @Override
     public synchronized int _exec(String sql) throws SQLException {
-        if (logger.isTraceEnabled()) {
-            logger.trace(
-                    "DriverManager [{}] [SQLite EXEC] {}", Thread.currentThread().getName(), sql);
-        }
+        logger.trace(
+                () ->
+                        MessageFormat.format(
+                                "DriverManager [{0}] [SQLite EXEC] {1}",
+                                Thread.currentThread().getName(), sql));
         return _exec_utf8(stringToUtf8ByteArray(sql));
     }
 
@@ -125,10 +127,11 @@ public synchronized int _exec(String sql) throws SQLException {
     /** @see org.sqlite.core.DB#prepare(java.lang.String) */
     @Override
     protected synchronized SafeStmtPtr prepare(String sql) throws SQLException {
-        if (logger.isTraceEnabled()) {
-            logger.trace(
-                    "DriverManager [{}] [SQLite EXEC] {}", Thread.currentThread().getName(), sql);
-        }
+        logger.trace(
+                () ->
+                        MessageFormat.format(
+                                "DriverManager [{0}] [SQLite EXEC] {1}",
+                                Thread.currentThread().getName(), sql));
         return new SafeStmtPtr(this, prepare_utf8(stringToUtf8ByteArray(sql)));
     }
 
diff --git a/src/main/java/org/sqlite/jdbc3/JDBC3DatabaseMetaData.java b/src/main/java/org/sqlite/jdbc3/JDBC3DatabaseMetaData.java
index 1a2229c79f..086fcbc000 100644
--- a/src/main/java/org/sqlite/jdbc3/JDBC3DatabaseMetaData.java
+++ b/src/main/java/org/sqlite/jdbc3/JDBC3DatabaseMetaData.java
@@ -21,12 +21,12 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.SQLiteConnection;
 import org.sqlite.core.CoreDatabaseMetaData;
 import org.sqlite.core.CoreStatement;
 import org.sqlite.jdbc3.JDBC3DatabaseMetaData.ImportedKeyFinder.ForeignKey;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 import org.sqlite.util.QueryUtils;
 import org.sqlite.util.StringUtils;
 
@@ -964,14 +964,14 @@ public ResultSet getColumns(String c, String s, String tblNamePattern, String co
                         try {
                             rsColAutoinc.close();
                         } catch (Exception e) {
-                            LogHolder.logger.error("Could not close ResultSet", e);
+                            LogHolder.logger.error(() -> "Could not close ResultSet", e);
                         }
                     }
                     if (statColAutoinc != null) {
                         try {
                             statColAutoinc.close();
                         } catch (Exception e) {
-                            LogHolder.logger.error("Could not close statement", e);
+                            LogHolder.logger.error(() -> "Could not close statement", e);
                         }
                     }
                 }
@@ -1125,7 +1125,7 @@ public ResultSet getColumns(String c, String s, String tblNamePattern, String co
                 try {
                     rs.close();
                 } catch (Exception e) {
-                    LogHolder.logger.error("Could not close ResultSet", e);
+                    LogHolder.logger.error(() -> "Could not close ResultSet", e);
                 }
             }
         }
diff --git a/src/main/java/org/sqlite/jdbc3/JDBC3Statement.java b/src/main/java/org/sqlite/jdbc3/JDBC3Statement.java
index 69cadf72b5..1af5694bd9 100644
--- a/src/main/java/org/sqlite/jdbc3/JDBC3Statement.java
+++ b/src/main/java/org/sqlite/jdbc3/JDBC3Statement.java
@@ -7,15 +7,16 @@
 import java.sql.SQLFeatureNotSupportedException;
 import java.sql.SQLWarning;
 import java.sql.Statement;
+import java.text.MessageFormat;
 import java.util.Arrays;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.ExtendedCommand;
 import org.sqlite.ExtendedCommand.SQLExtension;
 import org.sqlite.SQLiteConnection;
 import org.sqlite.core.CoreStatement;
 import org.sqlite.core.DB;
 import org.sqlite.core.DB.ProgressObserver;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 
 public abstract class JDBC3Statement extends CoreStatement {
 
@@ -100,7 +101,10 @@ static class BackupObserver implements ProgressObserver {
         private static final Logger logger = LoggerFactory.getLogger(BackupObserver.class);
 
         public void progress(int remaining, int pageCount) {
-            logger.info("remaining:{}, page count:{}", remaining, pageCount);
+            logger.info(
+                    () ->
+                            MessageFormat.format(
+                                    "remaining:{0}, page count:{1}", remaining, pageCount));
         }
     }
 
diff --git a/src/main/java/org/sqlite/util/Logger.java b/src/main/java/org/sqlite/util/Logger.java
new file mode 100644
index 0000000000..556f801e7b
--- /dev/null
+++ b/src/main/java/org/sqlite/util/Logger.java
@@ -0,0 +1,14 @@
+package org.sqlite.util;
+
+import java.util.function.Supplier;
+
+/** A simple internal Logger interface. */
+public interface Logger {
+    void trace(Supplier<String> message);
+
+    void info(Supplier<String> message);
+
+    void warn(Supplier<String> message);
+
+    void error(Supplier<String> message, Throwable t);
+}
diff --git a/src/main/java/org/sqlite/util/LoggerFactory.java b/src/main/java/org/sqlite/util/LoggerFactory.java
new file mode 100644
index 0000000000..6b3e8c7618
--- /dev/null
+++ b/src/main/java/org/sqlite/util/LoggerFactory.java
@@ -0,0 +1,109 @@
+package org.sqlite.util;
+
+import java.util.function.Supplier;
+import java.util.logging.Level;
+
+/**
+ * A factory for {@link Logger} instances that uses SLF4J if present, falling back on a
+ * java.util.logging implementation otherwise.
+ */
+public class LoggerFactory {
+    static final boolean USE_SLF4J;
+
+    static {
+        boolean useSLF4J;
+        try {
+            Class.forName("org.slf4j.Logger");
+            useSLF4J = true;
+        } catch (Exception e) {
+            useSLF4J = false;
+        }
+        USE_SLF4J = useSLF4J;
+    }
+
+    /**
+     * Get a {@link Logger} instance for the given host class.
+     *
+     * @param hostClass the host class from which log messages will be issued
+     * @return a Logger
+     */
+    public static Logger getLogger(Class<?> hostClass) {
+        if (USE_SLF4J) {
+            return new SLF4JLogger(hostClass);
+        }
+
+        return new JDKLogger(hostClass);
+    }
+
+    private static class JDKLogger implements Logger {
+        final java.util.logging.Logger logger;
+
+        public JDKLogger(Class<?> hostClass) {
+            logger = java.util.logging.Logger.getLogger(hostClass.getCanonicalName());
+        }
+
+        @Override
+        public void trace(Supplier<String> message) {
+            if (logger.isLoggable(Level.FINEST)) {
+                logger.log(Level.FINEST, message.get());
+            }
+        }
+
+        @Override
+        public void info(Supplier<String> message) {
+            if (logger.isLoggable(Level.INFO)) {
+                logger.log(Level.INFO, message.get());
+            }
+        }
+
+        @Override
+        public void warn(Supplier<String> message) {
+            if (logger.isLoggable(Level.WARNING)) {
+                logger.log(Level.WARNING, message.get());
+            }
+        }
+
+        @Override
+        public void error(Supplier<String> message, Throwable t) {
+            if (logger.isLoggable(Level.SEVERE)) {
+                logger.log(Level.SEVERE, message.get(), t);
+            }
+        }
+    }
+
+    private static class SLF4JLogger implements Logger {
+        final org.slf4j.Logger logger;
+
+        SLF4JLogger(Class<?> hostClass) {
+            logger = org.slf4j.LoggerFactory.getLogger(hostClass);
+        }
+
+        @Override
+        public void trace(Supplier<String> message) {
+            if (logger.isTraceEnabled()) {
+                logger.trace(message.get());
+            }
+        }
+
+        @Override
+        public void info(Supplier<String> message) {
+            if (logger.isInfoEnabled()) {
+                logger.info(message.get());
+            }
+        }
+
+        @Override
+        public void warn(Supplier<String> message) {
+            if (logger.isWarnEnabled()) {
+                logger.warn(message.get());
+            }
+        }
+
+        @Override
+        public void error(Supplier<String> message, Throwable t) {
+            if (logger.isErrorEnabled()) {
+                logger.error(message.get(), t);
+            }
+        }
+    }
+}
diff --git a/src/main/java/org/sqlite/util/OSInfo.java b/src/main/java/org/sqlite/util/OSInfo.java
index abf9d1c727..731a155728 100644
--- a/src/main/java/org/sqlite/util/OSInfo.java
+++ b/src/main/java/org/sqlite/util/OSInfo.java
@@ -31,8 +31,6 @@
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.stream.Stream;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * Provides OS name and architecture name.
@@ -163,7 +161,7 @@ static String getHardwareName() {
         try {
             return processRunner.runAndWaitFor("uname -m");
         } catch (Throwable e) {
-            LogHolder.logger.error("Error while running uname -m", e);
+            LogHolder.logger.error(() -> "Error while running uname -m", e);
             return "unknown";
         }
     }
@@ -231,7 +229,8 @@ static String resolveArmArchType() {
                     }
                 } else {
                     LogHolder.logger.warn(
-                            "readelf not found. Cannot check if running on an armhf system, armel architecture will be presumed");
+                            () ->
+                                    "readelf not found. Cannot check if running on an armhf system, armel architecture will be presumed");
                 }
             } catch (IOException | InterruptedException e) {
                 // ignored: fall back to "arm" arch (soft-float ABI)
diff --git a/src/main/java9/module-info.java b/src/main/java9/module-info.java
index e1eafeb78b..ce88543002 100644
--- a/src/main/java9/module-info.java
+++ b/src/main/java9/module-info.java
@@ -1,6 +1,6 @@
 module io.github.willena.sqlitejdbc {
 
-    requires org.slf4j;
+    requires static org.slf4j;
     requires transitive java.sql;
     requires transitive java.sql.rowset;
     requires static org.graalvm.nativeimage;
diff --git a/src/main/java9/org/sqlite/nativeimage/SqliteJdbcFeature.java b/src/main/java9/org/sqlite/nativeimage/SqliteJdbcFeature.java
index 05159b9975..17082155c8 100644
--- a/src/main/java9/org/sqlite/nativeimage/SqliteJdbcFeature.java
+++ b/src/main/java9/org/sqlite/nativeimage/SqliteJdbcFeature.java
@@ -10,6 +10,7 @@
 import org.sqlite.jdbc3.JDBC3DatabaseMetaData;
 import org.sqlite.util.LibraryLoaderUtil;
 import org.sqlite.util.OSInfo;
+import org.sqlite.util.ProcessRunner;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -27,6 +28,7 @@ public void beforeAnalysis(BeforeAnalysisAccess a) {
         RuntimeClassInitialization.initializeAtBuildTime(SQLiteJDBCLoader.VersionHolder.class);
         RuntimeClassInitialization.initializeAtBuildTime(JDBC3DatabaseMetaData.class);
         RuntimeClassInitialization.initializeAtBuildTime(OSInfo.class);
+        RuntimeClassInitialization.initializeAtBuildTime(ProcessRunner.class);
         RuntimeClassInitialization.initializeAtBuildTime(LibraryLoaderUtil.class);
         a.registerReachabilityHandler(
                 this::nativeDbReachable, method(SQLiteJDBCLoader.class, "initialize"));
diff --git a/src/test/java/org/sqlite/PrepStmtTest.java b/src/test/java/org/sqlite/PrepStmtTest.java
index 0a296b686d..fee401d0b0 100644
--- a/src/test/java/org/sqlite/PrepStmtTest.java
+++ b/src/test/java/org/sqlite/PrepStmtTest.java
@@ -81,6 +81,36 @@ public void update() throws SQLException {
         rs.close();
     }
 
+    @Test
+    public void pragmaGetGeneratedKeys() throws SQLException {
+        SQLiteConnection connection =
+                (SQLiteConnection)
+                        DriverManager.getConnection(
+                                "jdbc:sqlite::memory:?jdbc.get_generated_keys=false");
+        assertThat(connection.getConnectionConfig().isGetGeneratedKeys()).isFalse();
+    }
+
+    @Test
+    public void updateWithoutGeneratedKeys() throws SQLException {
+        Connection conn =
+                DriverManager.getConnection("jdbc:sqlite::memory:?jdbc.get_generated_keys=false");
+
+        assertThat(conn.prepareStatement("create table s1 (c1);").executeUpdate()).isEqualTo(0);
+        PreparedStatement prep = conn.prepareStatement("insert into s1 values (?);");
+        prep.setInt(1, 3);
+        assertThat(prep.executeUpdate()).isEqualTo(1);
+        assertThat(prep.getResultSet()).isNull();
+        prep.setInt(1, 5);
+        assertThat(prep.executeUpdate()).isEqualTo(1);
+        prep.setInt(1, 7);
+        assertThat(prep.executeUpdate()).isEqualTo(1);
+
+        ResultSet rsgk = prep.getGeneratedKeys();
+        assertThat(rsgk.next()).isFalse();
+        rsgk.close();
+        prep.close();
+    }
+
     @Test
     public void multiUpdate() throws SQLException {
         stat.executeUpdate("create table test (c1);");
diff --git a/src/test/java/org/sqlite/SQLiteConfigTest.java b/src/test/java/org/sqlite/SQLiteConfigTest.java
index a9b22e1869..67b56525e3 100644
--- a/src/test/java/org/sqlite/SQLiteConfigTest.java
+++ b/src/test/java/org/sqlite/SQLiteConfigTest.java
@@ -18,6 +18,7 @@ public void toProperties() {
         config.setDateStringFormat("yyyy/mm/dd");
         config.setDatePrecision("seconds");
         config.setDateClass("real");
+        config.setGetGeneratedKeys(false);
 
         Properties properties = config.toProperties();
 
@@ -27,6 +28,8 @@ public void toProperties() {
                 .isEqualTo(SQLiteConfig.DatePrecision.SECONDS.name());
         assertThat(properties.getProperty(SQLiteConfig.Pragma.DATE_CLASS.getPragmaName()))
                 .isEqualTo(SQLiteConfig.DateClass.REAL.name());
+        assertThat(properties.getProperty(Pragma.JDBC_GET_GENERATED_KEYS.getPragmaName()))
+                .isEqualTo("false");
     }
 
     @Test
diff --git a/src/test/java/org/sqlite/SQLiteDataSourceTest.java b/src/test/java/org/sqlite/SQLiteDataSourceTest.java
index b7674644cc..d01d630aeb 100755
--- a/src/test/java/org/sqlite/SQLiteDataSourceTest.java
+++ b/src/test/java/org/sqlite/SQLiteDataSourceTest.java
@@ -14,6 +14,7 @@
 import java.nio.ByteOrder;
 import java.sql.Connection;
 import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.sql.Statement;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -92,4 +93,36 @@ public void setBusyTimeout() {
                 .isEqualTo("1234");
         assertThat(ds.getConfig().getBusyTimeout()).isEqualTo(1234);
     }
+
+    @Test
+    public void setGetGeneratedKeys() throws SQLException {
+        final SQLiteDataSource ds = new SQLiteDataSource();
+        ds.setGetGeneratedKeys(false);
+        assertThat(
+                        ds.getConfig()
+                                .toProperties()
+                                .getProperty(
+                                        SQLiteConfig.Pragma.JDBC_GET_GENERATED_KEYS.pragmaName))
+                .isEqualTo("false");
+        assertThat(ds.getConfig().isGetGeneratedKeys()).isEqualTo(false);
+        assertThat(
+                        ((SQLiteConnection) ds.getConnection())
+                                .getConnectionConfig()
+                                .isGetGeneratedKeys())
+                .isFalse();
+
+        ds.setGetGeneratedKeys(true);
+        assertThat(
+                        ds.getConfig()
+                                .toProperties()
+                                .getProperty(
+                                        SQLiteConfig.Pragma.JDBC_GET_GENERATED_KEYS.pragmaName))
+                .isEqualTo("true");
+        assertThat(ds.getConfig().isGetGeneratedKeys()).isEqualTo(true);
+        assertThat(
+                        ((SQLiteConnection) ds.getConnection())
+                                .getConnectionConfig()
+                                .isGetGeneratedKeys())
+                .isTrue();
+    }
 }
diff --git a/src/test/java/org/sqlite/StatementTest.java b/src/test/java/org/sqlite/StatementTest.java
index 40b8a2b339..7419bbd7a2 100644
--- a/src/test/java/org/sqlite/StatementTest.java
+++ b/src/test/java/org/sqlite/StatementTest.java
@@ -1,8 +1,6 @@
 package org.sqlite;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.assertj.core.api.Assertions.assertThatNoException;
+import static org.assertj.core.api.Assertions.*;
 import static org.assertj.core.data.Offset.offset;
 
 import java.lang.reflect.Method;
@@ -351,6 +349,23 @@ public void getGeneratedKeys() throws SQLException {
         assertThat(rs).isNotNull();
         assertThat(rs.next()).isFalse();
         stat2.close();
+
+        // disable then re-enable generated keys retrieval
+        try {
+            ((SQLiteConnection) conn).getConnectionConfig().setGetGeneratedKeys(false);
+            stat.executeUpdate("insert into t1 (v) values ('red');");
+            rs = stat.getGeneratedKeys();
+            assertThat(rs.next()).isFalse();
+
+            ((SQLiteConnection) conn).getConnectionConfig().setGetGeneratedKeys(true);
+
+            stat.executeUpdate("insert into t1 (v) values ('red');");
+            rs = stat.getGeneratedKeys();
+            assertThat(rs.next()).isTrue();
+            rs.close();
+        } finally {
+            ((SQLiteConnection) conn).getConnectionConfig().setGetGeneratedKeys(true);
+        }
     }
 
     @Test
diff --git a/src/test/java/org/sqlite/architecture/CodingRulesTest.java b/src/test/java/org/sqlite/architecture/CodingRulesTest.java
index 2bc3aa78f6..6e17b90266 100644
--- a/src/test/java/org/sqlite/architecture/CodingRulesTest.java
+++ b/src/test/java/org/sqlite/architecture/CodingRulesTest.java
@@ -1,6 +1,7 @@
 package org.sqlite.architecture;
 
 import static com.tngtech.archunit.base.DescribedPredicate.not;
+import static com.tngtech.archunit.core.domain.JavaClass.Predicates.belongToAnyOf;
 import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo;
 import static com.tngtech.archunit.lang.conditions.ArchPredicates.are;
 import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
@@ -14,15 +15,26 @@
 import com.tngtech.archunit.core.importer.ImportOption;
 import com.tngtech.archunit.junit.AnalyzeClasses;
 import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchCondition;
 import com.tngtech.archunit.lang.ArchRule;
 import com.tngtech.archunit.lang.conditions.ArchConditions;
 import java.sql.DriverManager;
+import org.sqlite.util.LoggerFactory;
 import org.sqlite.util.OSInfo;
 
 @AnalyzeClasses(
         packages = "org.sqlite",
         importOptions = {ImportOption.DoNotIncludeTests.class})
 class CodingRulesTest {
+    public static final ArchCondition<JavaClass> USE_SLF4J_LOGGING;
+
+    static {
+        USE_SLF4J_LOGGING =
+                ArchConditions.dependOnClassesThat(
+                                com.tngtech.archunit.core.domain.JavaClass.Predicates
+                                        .resideInAPackage("org.slf4j"))
+                        .as("use SLF4J");
+    }
 
     @ArchTest
     void no_access_to_standard_streams(JavaClasses importedClasses) {
@@ -35,7 +47,12 @@ void no_access_to_standard_streams(JavaClasses importedClasses) {
 
     @ArchTest private final ArchRule no_jodatime = NO_CLASSES_SHOULD_USE_JODATIME;
 
-    @ArchTest private final ArchRule no_java_util_logging = NO_CLASSES_SHOULD_USE_JAVA_UTIL_LOGGING;
+    @ArchTest
+    private final ArchRule no_loggers_except_ours =
+            noClasses()
+                    .that(not(belongToAnyOf(LoggerFactory.class)))
+                    .should(USE_JAVA_UTIL_LOGGING)
+                    .orShould(USE_SLF4J_LOGGING);
 
     @ArchTest
     private final ArchRule no_driver_manager_println =