Release 1.76

Fix for Windows quadmath builds.

.github/workflows/build.yml

@@ -15,10 +15,10 @@ jobs:
     strategy:
       matrix:
         perl-version:
-          - '5.8'
-          - '5.10'
-          - '5.18'
-          - '5.20'
+          - '5.8-buster'
+          - '5.10-buster'
+          - '5.18-buster'
+          - '5.20-buster'
           - '5.26'
           - 'latest'
 
@@ -26,7 +26,7 @@ jobs:
       image: perl:${{ matrix.perl-version }}
 
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v4
       - name: perl -V
         run: perl -V
       - name: Install dependencies

Changes

@@ -1,5 +1,63 @@
 Changes for Perl extension DBD-SQLite
 
+1.76 2024-10-19
+    - Switched to a production version
+
+1.75_01 2024-09-17
+    - Upgraded SQLite to 3.46.1
+    - Fix for Windows quadmath builds (GH#115, sisyphus++)
+    - Omit load_extension if static build
+
+1.74 2023-09-20
+    - Switched to a production version
+
+1.73_01 2023-07-09
+    - Upgraded SQLite to 3.42.0
+    - Add missing possible table_type values to POD (GH#105, dboehmer++)
+
+1.72 2022-11-04
+    - Switched to a production version
+
+1.71_07 2022-10-26
+    - Upgraded SQLite to 3.39.4
+
+1.71_06 2022-03-12
+    - Set UTF8CACHE to avoid slowdown with -DDEBUGGING (andk, Leont, FGasper)
+
+1.71_05 2022-02-26
+    - Fix another test failure on perl built with -DDEBUGGING
+    - Lowercase datatype in table column metadata for backcompat
+
+1.71_04 2022-02-26
+    - Fix test failure on perl built with -DDEBUGGING (andk++)
+
+1.71_03 2022-02-23
+    - Upgraded SQLite to 3.38.0
+    - Expose sqlite_error_offset introduced in 3.38.0
+
+1.71_02 2022-01-07
+    - Upgraded SQLite to 3.37.2
+    - Improve sqlite_load_extension doc (GH#94, Derek Lamb++)
+
+1.71_01 2021-12-02
+    - Upgraded SQLite to 3.37.0
+    - Add a feature to unregister a created function
+    - Fix accented characters in POD (GH#90, HaraldJoerg++)
+
+1.70 2021-08-01
+    - Switched to a production version
+
+1.69_02 2021-07-30
+    - Fix doc to use the correct attribute with sqlite_ (GH#86, eekboek++)
+    - Modify the fix to silence the sqlite_unicode warning not to check
+      the attribute twice
+    - Fix an encoding issue of naive (GH#83, HaraldJoerg++)
+
+1.69_01 2021-07-30
+    - Typo (GH#85, grr++)
+    - Silenced deprecation warning of sqlite_unicode not to break
+      tests of existing applications
+
 1.68 2021-07-22
     - Switched to a production version
 

Makefile.PL

@@ -288,6 +288,10 @@ if ($^O =~ /bsd/i && $^O !~ /(?:open|net)bsd/) {
 	push @CC_DEFINE, '-D_XOPEN_SOURCE';
 }
 
+if (!$Config{usedl}) {
+    push @CC_DEFINE, '-DSQLITE_OMIT_LOAD_EXTENSION';
+}
+
 my (@CCFLAGS, @LDFLAGS, @LDDLFLAGS);
 
 if ($ENV{TEST_DBD_SQLITE_WITH_ASAN}) {

SQLite.xs

@@ -391,6 +391,24 @@ txn_state(SV* dbh, SV *schema = &PL_sv_undef)
     OUTPUT:
         RETVAL
 
+static int
+error_offset(dbh)
+    SV *dbh
+    ALIAS:
+        DBD::SQLite::db::sqlite_error_offset = 1
+    CODE:
+    {
+#if SQLITE_VERSION_NUMBER >= 3038000
+        D_imp_dbh(dbh);
+        RETVAL = sqlite3_error_offset(imp_dbh->db);
+#else
+        RETVAL = -1;
+#endif
+    }
+    OUTPUT:
+        RETVAL
+
+
 MODULE = DBD::SQLite          PACKAGE = DBD::SQLite::st
 
 PROTOTYPES: DISABLE

constants.inc

@@ -493,6 +493,32 @@ _const_database_connection_configuration_options_3031000_zero()
 
 #endif
 
+#if SQLITE_VERSION_NUMBER >= 3042000
+
+IV
+_const_database_connection_configuration_options_3042000()
+    ALIAS:
+        SQLITE_DBCONFIG_STMT_SCANSTATUS = SQLITE_DBCONFIG_STMT_SCANSTATUS
+        SQLITE_DBCONFIG_REVERSE_SCANORDER = SQLITE_DBCONFIG_REVERSE_SCANORDER
+    CODE:
+        RETVAL = ix;
+    OUTPUT:
+        RETVAL
+
+#else
+
+IV
+_const_database_connection_configuration_options_3042000_zero()
+    ALIAS:
+        SQLITE_DBCONFIG_STMT_SCANSTATUS = 1
+        SQLITE_DBCONFIG_REVERSE_SCANORDER = 2
+    CODE:
+        RETVAL = 0;
+    OUTPUT:
+        RETVAL
+
+#endif
+
 #if SQLITE_VERSION_NUMBER >= 3006002
 
 IV
@@ -1189,6 +1215,78 @@ _const_extended_result_codes_3034000_zero()
 
 #endif
 
+#if SQLITE_VERSION_NUMBER >= 3037000
+
+IV
+_const_extended_result_codes_3037000()
+    ALIAS:
+        SQLITE_CONSTRAINT_DATATYPE = SQLITE_CONSTRAINT_DATATYPE
+    CODE:
+        RETVAL = ix;
+    OUTPUT:
+        RETVAL
+
+#else
+
+IV
+_const_extended_result_codes_3037000_zero()
+    ALIAS:
+        SQLITE_CONSTRAINT_DATATYPE = 1
+    CODE:
+        RETVAL = 0;
+    OUTPUT:
+        RETVAL
+
+#endif
+
+#if SQLITE_VERSION_NUMBER >= 3041000
+
+IV
+_const_extended_result_codes_3041000()
+    ALIAS:
+        SQLITE_NOTICE_RBU = SQLITE_NOTICE_RBU
+    CODE:
+        RETVAL = ix;
+    OUTPUT:
+        RETVAL
+
+#else
+
+IV
+_const_extended_result_codes_3041000_zero()
+    ALIAS:
+        SQLITE_NOTICE_RBU = 1
+    CODE:
+        RETVAL = 0;
+    OUTPUT:
+        RETVAL
+
+#endif
+
+#if SQLITE_VERSION_NUMBER >= 3043000
+
+IV
+_const_extended_result_codes_3043000()
+    ALIAS:
+        SQLITE_IOERR_IN_PAGE = SQLITE_IOERR_IN_PAGE
+    CODE:
+        RETVAL = ix;
+    OUTPUT:
+        RETVAL
+
+#else
+
+IV
+_const_extended_result_codes_3043000_zero()
+    ALIAS:
+        SQLITE_IOERR_IN_PAGE = 1
+    CODE:
+        RETVAL = 0;
+    OUTPUT:
+        RETVAL
+
+#endif
+
 IV
 _const_flags_for_file_open_operations()
     ALIAS:
@@ -1347,6 +1445,30 @@ _const_flags_for_file_open_operations_3033000_zero()
 
 #endif
 
+#if SQLITE_VERSION_NUMBER >= 3037000
+
+IV
+_const_flags_for_file_open_operations_3037000()
+    ALIAS:
+        SQLITE_OPEN_EXRESCODE = SQLITE_OPEN_EXRESCODE
+    CODE:
+        RETVAL = ix;
+    OUTPUT:
+        RETVAL
+
+#else
+
+IV
+_const_flags_for_file_open_operations_3037000_zero()
+    ALIAS:
+        SQLITE_OPEN_EXRESCODE = 1
+    CODE:
+        RETVAL = 0;
+    OUTPUT:
+        RETVAL
+
+#endif
+
 #if SQLITE_VERSION_NUMBER >= 3008003
 
 IV
@@ -1421,6 +1543,30 @@ _const_function_flags_3031000_zero()
 
 #endif
 
+#if SQLITE_VERSION_NUMBER >= 3044001
+
+IV
+_const_function_flags_3044001()
+    ALIAS:
+        SQLITE_RESULT_SUBTYPE = SQLITE_RESULT_SUBTYPE
+    CODE:
+        RETVAL = ix;
+    OUTPUT:
+        RETVAL
+
+#else
+
+IV
+_const_function_flags_3044001_zero()
+    ALIAS:
+        SQLITE_RESULT_SUBTYPE = 1
+    CODE:
+        RETVAL = 0;
+    OUTPUT:
+        RETVAL
+
+#endif
+
 IV
 _const_fundamental_datatypes()
     ALIAS:
@@ -1428,6 +1574,7 @@ _const_fundamental_datatypes()
         SQLITE_FLOAT = SQLITE_FLOAT
         SQLITE_BLOB = SQLITE_BLOB
         SQLITE_NULL = SQLITE_NULL
+        SQLITE_TEXT = SQLITE_TEXT
     CODE:
         RETVAL = ix;
     OUTPUT:
@@ -1825,3 +1972,27 @@ _const__flags_for_file_open_operations_3033000_zero()
 
 #endif
 
+#if SQLITE_VERSION_NUMBER >= 3037000
+
+IV
+_const__flags_for_file_open_operations_3037000()
+    ALIAS:
+        OPEN_EXRESCODE = SQLITE_OPEN_EXRESCODE
+    CODE:
+        RETVAL = ix;
+    OUTPUT:
+        RETVAL
+
+#else
+
+IV
+_const__flags_for_file_open_operations_3037000_zero()
+    ALIAS:
+        OPEN_EXRESCODE = 1
+    CODE:
+        RETVAL = 0;
+    OUTPUT:
+        RETVAL
+
+#endif
+

dbdimp.c

@@ -407,10 +407,16 @@ sqlite_is_number(pTHX_ const char *v, int sql_type)
     if (sql_type != SQLITE_INTEGER) {
 #ifdef USE_QUADMATH
         sprintf(format, (has_plus ? "+%%.%dQf" : "%%.%dQf"), precision);
+#  if defined(WIN32)
+        /* On Windows quadmath, we need to use strtoflt128(), not atov() */
+        if (strEQ(form(format, strtoflt128(v, NULL)), v)) return 2;
+#  else
+        if (strEQ(form(format, atof(v)), v)) return 2;
+#  endif
 #else
         sprintf(format, (has_plus ? "+%%.%df"  : "%%.%df" ), precision);
-#endif
         if (strEQ(form(format, atof(v)), v)) return 2;
+#endif
     }
     return 0;
 }
@@ -856,7 +862,18 @@ sqlite_db_STORE_attrib(SV *dbh, imp_dbh_t *imp_dbh, SV *keysv, SV *valuesv)
         return TRUE;
     }
 
-    if (strEQ(key, "sqlite_unicode") || strEQ(key, "unicode")) {
+    if (strEQ(key, "sqlite_unicode")) {
+        /* it's too early to warn the deprecation of sqlite_unicode as it's widely used */
+#if PERL_UNICODE_DOES_NOT_WORK_WELL
+        sqlite_trace(dbh, imp_dbh, 3, form("Unicode support is disabled for this version of perl."));
+        imp_dbh->string_mode = DBD_SQLITE_STRING_MODE_PV;
+#else
+        imp_dbh->string_mode = SvTRUE(valuesv) ? DBD_SQLITE_STRING_MODE_UNICODE_NAIVE : DBD_SQLITE_STRING_MODE_PV;
+#endif
+        return TRUE;
+    }
+
+    if (strEQ(key, "unicode")) {
         _warn_deprecated_if_possible(key, "sqlite_string_mode");
 #if PERL_UNICODE_DOES_NOT_WORK_WELL
         sqlite_trace(dbh, imp_dbh, 3, form("Unicode support is disabled for this version of perl."));
@@ -1848,16 +1865,20 @@ sqlite_db_create_function(pTHX_ SV *dbh, const char *name, int argc, SV *func, i
     }
 
     /* Copy the function reference */
+    if (SvOK(func)) {
         func_sv = newSVsv(func);
         av_push( imp_dbh->functions, func_sv );
+    }
 
     croak_if_db_is_null();
 
     /* warn("create_function %s with %d args\n", name, argc); */
+    if (SvOK(func)) {
         rc = sqlite3_create_function( imp_dbh->db, name, argc, SQLITE_UTF8|flags,
-                                  func_sv,
-                                  _FUNC_DISPATCHER[imp_dbh->string_mode],
-                                  NULL, NULL );
+                                      func_sv, _FUNC_DISPATCHER[imp_dbh->string_mode], NULL, NULL );
+    } else {
+        rc = sqlite3_create_function( imp_dbh->db, name, argc, SQLITE_UTF8|flags, NULL, NULL, NULL, NULL );
+    }
     if ( rc != SQLITE_OK ) {
         sqlite_error(dbh, rc, form("sqlite_create_function failed with error %s", sqlite3_errmsg(imp_dbh->db)));
         return FALSE;
@@ -1913,6 +1934,21 @@ sqlite_db_load_extension(pTHX_ SV *dbh, const char *file, const char *proc)
 
 #endif
 
+SV* _lc(pTHX_ SV* sv) {
+    int i, l;
+    char* pv;
+    if (SvPOK(sv)) {
+        pv = SvPV_nolen(sv);
+        l = strlen(pv);
+        for(i = 0; i < l; i++) {
+            if (pv[i] >= 'A' && pv[i] <= 'Z') {
+                pv[i] = pv[i] - 'A' + 'a';
+            }
+        }
+    }
+    return sv;
+}
+
 HV*
 sqlite_db_table_column_metadata(pTHX_ SV *dbh, SV *dbname, SV *tablename, SV *columnname)
 {
@@ -1949,7 +1985,7 @@ sqlite_db_table_column_metadata(pTHX_ SV *dbh, SV *dbname, SV *tablename, SV *co
 #endif
 
     if (rc == SQLITE_OK) {
-        hv_stores(metadata, "data_type", datatype ? newSVpv(datatype, 0) : newSV(0));
+        hv_stores(metadata, "data_type", datatype ? _lc(aTHX_ newSVpv(datatype, 0)) : newSV(0));
         hv_stores(metadata, "collation_name", collseq ? newSVpv(collseq, 0) : newSV(0));
         hv_stores(metadata, "not_null", newSViv(notnull));
         hv_stores(metadata, "primary", newSViv(primary));

lib/DBD/SQLite.pm

@@ -5,7 +5,7 @@ use strict;
 use DBI   1.57 ();
 use XSLoader ();
 
-our $VERSION = '1.68';
+our $VERSION = '1.76';
 
 # sqlite_version cache (set in the XS bootstrap)
 our ($sqlite_version, $sqlite_version_number);
@@ -62,6 +62,7 @@ sub driver {
         DBD::SQLite::db->install_method('sqlite_db_config');
         DBD::SQLite::db->install_method('sqlite_get_autocommit');
         DBD::SQLite::db->install_method('sqlite_txn_state');
+        DBD::SQLite::db->install_method('sqlite_error_offset');
 
         $methods_are_installed++;
     }
@@ -1073,7 +1074,7 @@ are limited by the typeless nature of the SQLite database.
 =head1 SQLITE VERSION
 
 DBD::SQLite is usually compiled with a bundled SQLite library
-(SQLite version S<3.36.0> as of this release) for consistency.
+(SQLite version S<3.46.1> as of this release) for consistency.
 However, a different version of SQLite may sometimes be used for
 some reasons like security, or some new experimental features.
 
@@ -1655,7 +1656,7 @@ updates:
 
   use DBI qw(:sql_types);
   use DBD::SQLite::Constants ':dbd_sqlite_string_mode';
-  $dbh->{string_mode} = DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK;
+  $dbh->{sqlite_string_mode} = DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK;
   my $sth = $dbh->prepare("INSERT INTO mytable (blobcolumn) VALUES (?)");
 
   # Binary_data will be stored as is.
@@ -1668,8 +1669,8 @@ DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK but usually throws an exception
 rather than a warning if SQLite sends invalid UTF-8. (In Perl callbacks
 from SQLite we still warn instead.)
 
-=item * DBD_SQLITE_STRING_MODULE_UNICODE_NAIVE: Like
-DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK but uses a "naïve" UTF-8 decoding
+=item * DBD_SQLITE_STRING_MODE_UNICODE_NAIVE: Like
+DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK but uses a "naïve" UTF-8 decoding
 method that forgoes validation. This is marginally faster than a validated
 decode, but it can also B<corrupt> B<Perl> B<itself!>
 
@@ -1748,7 +1749,8 @@ Returns all tables and schemas (databases) as specified in L<DBI/table_info>.
 The schema and table arguments will do a C<LIKE> search. You can specify an
 ESCAPE character by including an 'Escape' attribute in \%attr. The C<$type>
 argument accepts a comma separated list of the following types 'TABLE',
-'VIEW', 'LOCAL TEMPORARY' and 'SYSTEM TABLE' (by default all are returned).
+'INDEX', 'VIEW', 'TRIGGER', 'LOCAL TEMPORARY' and 'SYSTEM TABLE'
+(by default all are returned).
 Note that a statement handle is returned, and not a direct list of tables.
 
 The following fields are returned:
@@ -1761,8 +1763,8 @@ databases will be in the name given when the database was attached.
 
 B<TABLE_NAME>: The name of the table or view.
 
-B<TABLE_TYPE>: The type of object returned. Will be one of 'TABLE', 'VIEW',
-'LOCAL TEMPORARY' or 'SYSTEM TABLE'.
+B<TABLE_TYPE>: The type of object returned. Will be one of 'TABLE', 'INDEX',
+'VIEW', 'TRIGGER', 'LOCAL TEMPORARY' or 'SYSTEM TABLE'.
 
 =head2 primary_key, primary_key_info
 
@@ -2297,12 +2299,16 @@ Calling this method with a true value enables loading (external)
 SQLite3 extensions. After the call, you can load extensions like this:
 
   $dbh->sqlite_enable_load_extension(1);
-  $sth = $dbh->prepare("select load_extension('libsqlitefunctions.so')")
+  $sth = $dbh->prepare("select load_extension('libmemvfs.so')")
   or die "Cannot prepare: " . $dbh->errstr();
 
 =head2 $dbh->sqlite_load_extension( $file, $proc )
 
-Loading an extension by a select statement (with the "load_extension" SQLite3 function like above) has some limitations. If you need to, say, create other functions from an extension, use this method. $file (a path to the extension) is mandatory, and $proc (an entry point name) is optional. You need to call C<sqlite_enable_load_extension> before calling C<sqlite_load_extension>.
+Loading an extension by a select statement (with the "load_extension" SQLite3 function like above) has some limitations. If the extension you want to use creates other functions that are not native to SQLite, use this method instead. $file (a path to the extension) is mandatory, and $proc (an entry point name) is optional. You need to call C<sqlite_enable_load_extension> before calling C<sqlite_load_extension>:
+
+  $dbh->sqlite_enable_load_extension(1);
+  $dbh->sqlite_load_extension('libsqlitefunctions.so')
+  or die "Cannot load extension: " . $dbh->errstr();
 
 If the extension uses SQLite mutex functions like C<sqlite3_mutex_enter>, then
 the extension should be compiled with the same C<SQLITE_THREADSAFE> compile-time
@@ -2427,6 +2433,12 @@ can be imported from DBD::SQLite::Constants. You may pass an optional
 schema name (usually "main"). If SQLite does not support this function,
 or if you pass a wrong schema name, -1 is returned.
 
+=head2 $dbh->sqlite_error_offset()
+
+Returns the byte offset of the start of a problematic input SQL token
+or -1 if the most recent error does not reference a specific token in
+the input SQL (or DBD::SQLite is built with an older version of SQLite).
+
 =head1 DRIVER FUNCTIONS
 
 =head2 DBD::SQLite::compile_options()
@@ -2589,18 +2601,17 @@ or
 
 =head2 Unicode handling
 
-If the attribute C<< $dbh->{sqlite_unicode} >> is set, strings coming from
-the database and passed to the collation function will be properly
-tagged with the utf8 flag; but this only works if the
-C<sqlite_unicode> attribute is set B<before> the first call to
-a perl collation sequence . The recommended way to activate unicode
-is to set the parameter at connection time :
+Depending on the C<< $dbh->{sqlite_string_mode} >> value, strings coming
+from the database and passed to the collation function may be decoded as
+UTF-8. This only works, though, if the C<sqlite_string_mode> attribute is
+set B<before> the first call to a perl collation sequence. The recommended
+way to activate unicode is to set C<sqlite_string_mode> at connection time:
 
   my $dbh = DBI->connect(
       "dbi:SQLite:dbname=foo", "", "",
       {
           RaiseError         => 1,
-          sqlite_unicode => 1,
+          sqlite_string_mode => DBD_SQLITE_STRING_MODE_UNICODE_STRICT,
       }
   );
 
@@ -2622,7 +2633,7 @@ characters :
   use DBD::SQLite;
   $DBD::SQLite::COLLATION{no_accents} = sub {
     my ( $a, $b ) = map lc, @_;
-    tr[àâáäåãçðèêéëìîíïñòôóöõøùûúüý]
+    tr[àâáäåãçðèêéëìîíïñòôóöõøùûúüý]
       [aaaaaacdeeeeiiiinoooooouuuuy] for $a, $b;
     $a cmp $b;
   };

lib/DBD/SQLite/Constants.pm

@@ -87,6 +87,8 @@ our @EXPORT_OK = (
       SQLITE_DBCONFIG_MAX
       SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
       SQLITE_DBCONFIG_RESET_DATABASE
+      SQLITE_DBCONFIG_REVERSE_SCANORDER
+      SQLITE_DBCONFIG_STMT_SCANSTATUS
       SQLITE_DBCONFIG_TRIGGER_EQP
       SQLITE_DBCONFIG_TRUSTED_SCHEMA
       SQLITE_DBCONFIG_WRITABLE_SCHEMA
@@ -107,6 +109,7 @@ our @EXPORT_OK = (
       SQLITE_CANTOPEN_SYMLINK
       SQLITE_CONSTRAINT_CHECK
       SQLITE_CONSTRAINT_COMMITHOOK
+      SQLITE_CONSTRAINT_DATATYPE
       SQLITE_CONSTRAINT_FOREIGNKEY
       SQLITE_CONSTRAINT_FUNCTION
       SQLITE_CONSTRAINT_NOTNULL
@@ -139,6 +142,7 @@ our @EXPORT_OK = (
       SQLITE_IOERR_FSTAT
       SQLITE_IOERR_FSYNC
       SQLITE_IOERR_GETTEMPPATH
+      SQLITE_IOERR_IN_PAGE
       SQLITE_IOERR_LOCK
       SQLITE_IOERR_MMAP
       SQLITE_IOERR_NOMEM
@@ -157,6 +161,7 @@ our @EXPORT_OK = (
       SQLITE_IOERR_WRITE
       SQLITE_LOCKED_SHAREDCACHE
       SQLITE_LOCKED_VTAB
+      SQLITE_NOTICE_RBU
       SQLITE_NOTICE_RECOVER_ROLLBACK
       SQLITE_NOTICE_RECOVER_WAL
       SQLITE_OK_SYMLINK
@@ -172,6 +177,7 @@ our @EXPORT_OK = (
     # flags_for_file_open_operations
     qw/
       SQLITE_OPEN_CREATE
+      SQLITE_OPEN_EXRESCODE
       SQLITE_OPEN_FULLMUTEX
       SQLITE_OPEN_MEMORY
       SQLITE_OPEN_NOFOLLOW
@@ -189,6 +195,7 @@ our @EXPORT_OK = (
       SQLITE_DETERMINISTIC
       SQLITE_DIRECTONLY
       SQLITE_INNOCUOUS
+      SQLITE_RESULT_SUBTYPE
       SQLITE_SUBTYPE
     /,
 
@@ -198,6 +205,7 @@ our @EXPORT_OK = (
       SQLITE_FLOAT
       SQLITE_INTEGER
       SQLITE_NULL
+      SQLITE_TEXT
     /,
 
     # result_codes
@@ -277,6 +285,7 @@ our %EXPORT_TAGS = (
       SQLITE_CONSTRAINT
       SQLITE_CONSTRAINT_CHECK
       SQLITE_CONSTRAINT_COMMITHOOK
+      SQLITE_CONSTRAINT_DATATYPE
       SQLITE_CONSTRAINT_FOREIGNKEY
       SQLITE_CONSTRAINT_FUNCTION
       SQLITE_CONSTRAINT_NOTNULL
@@ -316,6 +325,8 @@ our %EXPORT_TAGS = (
       SQLITE_DBCONFIG_MAX
       SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
       SQLITE_DBCONFIG_RESET_DATABASE
+      SQLITE_DBCONFIG_REVERSE_SCANORDER
+      SQLITE_DBCONFIG_STMT_SCANSTATUS
       SQLITE_DBCONFIG_TRIGGER_EQP
       SQLITE_DBCONFIG_TRUSTED_SCHEMA
       SQLITE_DBCONFIG_WRITABLE_SCHEMA
@@ -372,6 +383,7 @@ our %EXPORT_TAGS = (
       SQLITE_IOERR_FSTAT
       SQLITE_IOERR_FSYNC
       SQLITE_IOERR_GETTEMPPATH
+      SQLITE_IOERR_IN_PAGE
       SQLITE_IOERR_LOCK
       SQLITE_IOERR_MMAP
       SQLITE_IOERR_NOMEM
@@ -410,12 +422,14 @@ our %EXPORT_TAGS = (
       SQLITE_NOTADB
       SQLITE_NOTFOUND
       SQLITE_NOTICE
+      SQLITE_NOTICE_RBU
       SQLITE_NOTICE_RECOVER_ROLLBACK
       SQLITE_NOTICE_RECOVER_WAL
       SQLITE_NULL
       SQLITE_OK
       SQLITE_OK_SYMLINK
       SQLITE_OPEN_CREATE
+      SQLITE_OPEN_EXRESCODE
       SQLITE_OPEN_FULLMUTEX
       SQLITE_OPEN_MEMORY
       SQLITE_OPEN_NOFOLLOW
@@ -440,11 +454,13 @@ our %EXPORT_TAGS = (
       SQLITE_READONLY_ROLLBACK
       SQLITE_RECURSIVE
       SQLITE_REINDEX
+      SQLITE_RESULT_SUBTYPE
       SQLITE_ROW
       SQLITE_SAVEPOINT
       SQLITE_SCHEMA
       SQLITE_SELECT
       SQLITE_SUBTYPE
+      SQLITE_TEXT
       SQLITE_TOOBIG
       SQLITE_TRANSACTION
       SQLITE_TXN_NONE
@@ -525,6 +541,8 @@ our %EXPORT_TAGS = (
       SQLITE_DBCONFIG_MAX
       SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
       SQLITE_DBCONFIG_RESET_DATABASE
+      SQLITE_DBCONFIG_REVERSE_SCANORDER
+      SQLITE_DBCONFIG_STMT_SCANSTATUS
       SQLITE_DBCONFIG_TRIGGER_EQP
       SQLITE_DBCONFIG_TRUSTED_SCHEMA
       SQLITE_DBCONFIG_WRITABLE_SCHEMA
@@ -552,6 +570,7 @@ our %EXPORT_TAGS = (
       SQLITE_CANTOPEN_SYMLINK
       SQLITE_CONSTRAINT_CHECK
       SQLITE_CONSTRAINT_COMMITHOOK
+      SQLITE_CONSTRAINT_DATATYPE
       SQLITE_CONSTRAINT_FOREIGNKEY
       SQLITE_CONSTRAINT_FUNCTION
       SQLITE_CONSTRAINT_NOTNULL
@@ -584,6 +603,7 @@ our %EXPORT_TAGS = (
       SQLITE_IOERR_FSTAT
       SQLITE_IOERR_FSYNC
       SQLITE_IOERR_GETTEMPPATH
+      SQLITE_IOERR_IN_PAGE
       SQLITE_IOERR_LOCK
       SQLITE_IOERR_MMAP
       SQLITE_IOERR_NOMEM
@@ -602,6 +622,7 @@ our %EXPORT_TAGS = (
       SQLITE_IOERR_WRITE
       SQLITE_LOCKED_SHAREDCACHE
       SQLITE_LOCKED_VTAB
+      SQLITE_NOTICE_RBU
       SQLITE_NOTICE_RECOVER_ROLLBACK
       SQLITE_NOTICE_RECOVER_WAL
       SQLITE_OK_SYMLINK
@@ -616,6 +637,7 @@ our %EXPORT_TAGS = (
 
     flags_for_file_open_operations => [qw/
       SQLITE_OPEN_CREATE
+      SQLITE_OPEN_EXRESCODE
       SQLITE_OPEN_FULLMUTEX
       SQLITE_OPEN_MEMORY
       SQLITE_OPEN_NOFOLLOW
@@ -632,6 +654,7 @@ our %EXPORT_TAGS = (
       SQLITE_DETERMINISTIC
       SQLITE_DIRECTONLY
       SQLITE_INNOCUOUS
+      SQLITE_RESULT_SUBTYPE
       SQLITE_SUBTYPE
     /],
 
@@ -640,6 +663,7 @@ our %EXPORT_TAGS = (
       SQLITE_FLOAT
       SQLITE_INTEGER
       SQLITE_NULL
+      SQLITE_TEXT
     /],
 
     result_codes => [qw/
@@ -864,6 +888,10 @@ This module does not export anything by default.
 
 =item SQLITE_DBCONFIG_TRUSTED_SCHEMA
 
+=item SQLITE_DBCONFIG_STMT_SCANSTATUS
+
+=item SQLITE_DBCONFIG_REVERSE_SCANORDER
+
 =back
 
 =head2 dbd_sqlite_string_mode
@@ -1032,6 +1060,12 @@ This module does not export anything by default.
 
 =item SQLITE_IOERR_CORRUPTFS
 
+=item SQLITE_CONSTRAINT_DATATYPE
+
+=item SQLITE_NOTICE_RBU
+
+=item SQLITE_IOERR_IN_PAGE
+
 =back
 
 =head2 file_open (flags_for_file_open_operations)
@@ -1060,6 +1094,8 @@ This module does not export anything by default.
 
 =item SQLITE_OPEN_SUPER_JOURNAL
 
+=item SQLITE_OPEN_EXRESCODE
+
 =back
 
 =head2 function_flags
@@ -1074,6 +1110,8 @@ This module does not export anything by default.
 
 =item SQLITE_INNOCUOUS
 
+=item SQLITE_RESULT_SUBTYPE
+
 =back
 
 =head2 datatypes (fundamental_datatypes)
@@ -1088,6 +1126,8 @@ This module does not export anything by default.
 
 =item SQLITE_NULL
 
+=item SQLITE_TEXT
+
 =back
 
 =head2 result_codes

lib/DBD/SQLite/VirtualTable.pm

@@ -5,7 +5,7 @@ use strict;
 use warnings;
 use Scalar::Util    qw/weaken/;
 
-our $VERSION = '1.68';
+our $VERSION = '1.76';
 our @ISA;
 
 

sqlite3ext.h

@@ -331,12 +331,41 @@ struct sqlite3_api_routines {
   const char *(*filename_journal)(const char*);
   const char *(*filename_wal)(const char*);
   /* Version 3.32.0 and later */
-  char *(*create_filename)(const char*,const char*,const char*,
+  const char *(*create_filename)(const char*,const char*,const char*,
                            int,const char**);
-  void (*free_filename)(char*);
+  void (*free_filename)(const char*);
   sqlite3_file *(*database_file_object)(const char*);
   /* Version 3.34.0 and later */
   int (*txn_state)(sqlite3*,const char*);
+  /* Version 3.36.1 and later */
+  sqlite3_int64 (*changes64)(sqlite3*);
+  sqlite3_int64 (*total_changes64)(sqlite3*);
+  /* Version 3.37.0 and later */
+  int (*autovacuum_pages)(sqlite3*,
+     unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
+     void*, void(*)(void*));
+  /* Version 3.38.0 and later */
+  int (*error_offset)(sqlite3*);
+  int (*vtab_rhs_value)(sqlite3_index_info*,int,sqlite3_value**);
+  int (*vtab_distinct)(sqlite3_index_info*);
+  int (*vtab_in)(sqlite3_index_info*,int,int);
+  int (*vtab_in_first)(sqlite3_value*,sqlite3_value**);
+  int (*vtab_in_next)(sqlite3_value*,sqlite3_value**);
+  /* Version 3.39.0 and later */
+  int (*deserialize)(sqlite3*,const char*,unsigned char*,
+                     sqlite3_int64,sqlite3_int64,unsigned);
+  unsigned char *(*serialize)(sqlite3*,const char *,sqlite3_int64*,
+                              unsigned int);
+  const char *(*db_name)(sqlite3*,int);
+  /* Version 3.40.0 and later */
+  int (*value_encoding)(sqlite3_value*);
+  /* Version 3.41.0 and later */
+  int (*is_interrupted)(sqlite3*);
+  /* Version 3.43.0 and later */
+  int (*stmt_explain)(sqlite3_stmt*,int);
+  /* Version 3.44.0 and later */
+  void *(*get_clientdata)(sqlite3*,const char*);
+  int (*set_clientdata)(sqlite3*, const char*, void*, void(*)(void*));
 };
 
 /*
@@ -643,6 +672,33 @@ typedef int (*sqlite3_loadext_entry)(
 #define sqlite3_database_file_object   sqlite3_api->database_file_object
 /* Version 3.34.0 and later */
 #define sqlite3_txn_state              sqlite3_api->txn_state
+/* Version 3.36.1 and later */
+#define sqlite3_changes64              sqlite3_api->changes64
+#define sqlite3_total_changes64        sqlite3_api->total_changes64
+/* Version 3.37.0 and later */
+#define sqlite3_autovacuum_pages       sqlite3_api->autovacuum_pages
+/* Version 3.38.0 and later */
+#define sqlite3_error_offset           sqlite3_api->error_offset
+#define sqlite3_vtab_rhs_value         sqlite3_api->vtab_rhs_value
+#define sqlite3_vtab_distinct          sqlite3_api->vtab_distinct
+#define sqlite3_vtab_in                sqlite3_api->vtab_in
+#define sqlite3_vtab_in_first          sqlite3_api->vtab_in_first
+#define sqlite3_vtab_in_next           sqlite3_api->vtab_in_next
+/* Version 3.39.0 and later */
+#ifndef SQLITE_OMIT_DESERIALIZE
+#define sqlite3_deserialize            sqlite3_api->deserialize
+#define sqlite3_serialize              sqlite3_api->serialize
+#endif
+#define sqlite3_db_name                sqlite3_api->db_name
+/* Version 3.40.0 and later */
+#define sqlite3_value_encoding         sqlite3_api->value_encoding
+/* Version 3.41.0 and later */
+#define sqlite3_is_interrupted         sqlite3_api->is_interrupted
+/* Version 3.43.0 and later */
+#define sqlite3_stmt_explain           sqlite3_api->stmt_explain
+/* Version 3.44.0 and later */
+#define sqlite3_get_clientdata         sqlite3_api->get_clientdata
+#define sqlite3_set_clientdata         sqlite3_api->set_clientdata
 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
 
 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)

t/07_error.t

@@ -25,4 +25,12 @@ ok($@, 'Statement 2 generated an error');
 is( $DBI::err, 19, '$DBI::err ok' );
 like( $DBI::errstr, qr/column a is not unique|UNIQUE constraint failed/, '$DBI::errstr ok' );
 
+if ($DBD::SQLite::sqlite_version_number && $DBD::SQLite::sqlite_version_number >= 3038000) {
+    my $sql = 'insert testerror values (1, 5)';
+    eval { $dbh->do($sql) };
+    my $offset = $dbh->sqlite_error_offset;
+    ok $offset != -1, "error offset: $offset";
+    note substr($sql, 0, $offset) . '<*error*>' . substr($sql, $offset);
+}
+
 done_testing;

t/09_create_function.t

@@ -150,6 +150,10 @@ foreach my $call_func (@CALL_FUNCS) { for my $flags (@function_flags) {
 	$result = $dbh->selectrow_arrayref( "SELECT typeof(md5_blob('my_blob'))" );
 	is_deeply( $result, [ 'blob' ], "SELECT typeof(md5_blob('my_blob'))" );
 
+	ok($dbh->$call_func( "md5_blob", 1, undef, defined $flags ? $flags : (), "create_function" ));
+	$result = $dbh->selectrow_arrayref( "SELECT md5_blob('my_blob')" );
+	is_deeply( $result, undef, "SELECT md5_blob('my_blob')" );
+
 	$dbh->disconnect;
 }}
 

t/43_fts3.t

@@ -8,6 +8,9 @@ use if -d ".git", "Test::FailWarnings";
 use DBD::SQLite;
 use DBD::SQLite::Constants ':dbd_sqlite_string_mode';
 
+# Avoid slowdown with -DDEBUGGING:
+${^UTF8CACHE} = 1;
+
 my @texts = ("il était une bergère",
              "qui gardait ses moutons",
              "elle fit un fromage",

util/SQLiteUtil.pm

@@ -184,6 +184,14 @@ my %since = (
   TXN_READ => '3034000',
   TXN_WRITE => '3034000',
   IOERR_CORRUPTFS => '3034000',
+  SESSION_OBJCONFIG_SIZE => '3036000',
+  CONSTRAINT_DATATYPE => '3037000',
+  OPEN_EXRESCODE => '3037000',
+  NOTICE_RBU => '3041000',
+  DBCONFIG_STMT_SCANSTATUS => '3042000',
+  DBCONFIG_REVERSE_SCANORDER => '3042000',
+  IOERR_IN_PAGE => '3043000',
+  RESULT_SUBTYPE => '3044001',
 
   status_parameters_for_prepared_statements => '3006004',
   extended_result_codes => '3006005',
@@ -214,6 +222,7 @@ my %ignore = map {$_ => 1} qw/
   OPEN_MAIN_JOURNAL OPEN_TEMP_JOURNAL
   OPEN_SUBJOURNAL OPEN_MASTER_JOURNAL OPEN_WAL
   OK_LOAD_PERMANENTLY PREPARE_PERSISTENT
+  SESSION_OBJCONFIG_SIZE
 /;
 
 my $ignore_tag_re = join '|', (
@@ -228,6 +237,9 @@ my $ignore_tag_re = join '|', (
   'virtual_table_configuration_options', # for sqlite3_vtab_config
   'prepare_flags', # for sqlite3_prepare_v3
 
+  'delete_a_session_object',
+  'prepared_statement_scan_status',
+
   # status flags (status methods are read-only at the moment)
   'status_parameters',
   'status_parameters_for_database_connections',
@@ -253,6 +265,7 @@ my $ignore_tag_re = join '|', (
   'text_encodings',
   'virtual_table_constraint_operator_codes',
   'virtual_table_indexing_information',
+  'options_for_sqlite3session_object_config',
 );
 
 my %compat = map {$_ => 1} qw/
@@ -282,7 +295,7 @@ sub extract_constants {
       }
       next;
     }
-    if ($tag && /^#define SQLITE_(\S+)\s+(\d+|\(SQLITE)/) {
+    if ($tag && /^#\s*define SQLITE_(\S+)\s+(\d+|\(SQLITE)/) {
       my ($name, $value) = ($1, $2);
       if ($name eq 'VERSION_NUMBER' and $value =~ /^\d+$/) {
           $known_versions{$value} = 1;
@@ -465,6 +478,9 @@ sub year {
   my $self = shift;
   return "snapshot" if $self->is_snapshot;
   my $version = $self->as_num;
+  return 2024 if $version >= 3450000;
+  return 2023 if $version >= 3410000;
+  return 2022 if $version >= 3370200;
   return 2021 if $version >= 3340100;
   return 2020 if $version >= 3310000;
   return 2019 if $version >= 3270000;