sqlite3 1.7.3 → 2.5.0

data/ext/sqlite3/database.h

@@ -3,17 +3,26 @@
 
 #include <sqlite3_ruby.h>
 
+/* bits in the `flags` field */
+#define SQLITE3_RB_DATABASE_READONLY  0x01
+#define SQLITE3_RB_DATABASE_DISCARDED 0x02
+
 struct _sqlite3Ruby {
-  sqlite3 *db;
+    sqlite3 *db;
+    VALUE busy_handler;
+    int stmt_timeout;
+    struct timespec stmt_deadline;
+    rb_pid_t owner;
+    int flags;
 };
 
 typedef struct _sqlite3Ruby sqlite3Ruby;
-typedef sqlite3Ruby * sqlite3RubyPtr;
+typedef sqlite3Ruby *sqlite3RubyPtr;
 
 void init_sqlite3_database();
-void set_sqlite3_func_result(sqlite3_context * ctx, VALUE result);
+void set_sqlite3_func_result(sqlite3_context *ctx, VALUE result);
 
 sqlite3RubyPtr sqlite3_database_unwrap(VALUE database);
-VALUE sqlite3val2rb(sqlite3_value * val);
+VALUE sqlite3val2rb(sqlite3_value *val);
 
 #endif

data/ext/sqlite3/exception.c

@@ -1,98 +1,122 @@
 #include <sqlite3_ruby.h>
 
-void rb_sqlite3_raise(sqlite3 * db, int status)
+static VALUE
+status2klass(int status)
 {
-  VALUE klass = Qnil;
+    /* Consider only lower 8 bits, to work correctly when
+       extended result codes are enabled. */
+    switch (status & 0xff) {
+        case SQLITE_OK:
+            return Qnil;
+        case SQLITE_ERROR:
+            return rb_path2class("SQLite3::SQLException");
+        case SQLITE_INTERNAL:
+            return rb_path2class("SQLite3::InternalException");
+        case SQLITE_PERM:
+            return rb_path2class("SQLite3::PermissionException");
+        case SQLITE_ABORT:
+            return rb_path2class("SQLite3::AbortException");
+        case SQLITE_BUSY:
+            return rb_path2class("SQLite3::BusyException");
+        case SQLITE_LOCKED:
+            return rb_path2class("SQLite3::LockedException");
+        case SQLITE_NOMEM:
+            return rb_path2class("SQLite3::MemoryException");
+        case SQLITE_READONLY:
+            return rb_path2class("SQLite3::ReadOnlyException");
+        case SQLITE_INTERRUPT:
+            return rb_path2class("SQLite3::InterruptException");
+        case SQLITE_IOERR:
+            return rb_path2class("SQLite3::IOException");
+        case SQLITE_CORRUPT:
+            return rb_path2class("SQLite3::CorruptException");
+        case SQLITE_NOTFOUND:
+            return rb_path2class("SQLite3::NotFoundException");
+        case SQLITE_FULL:
+            return rb_path2class("SQLite3::FullException");
+        case SQLITE_CANTOPEN:
+            return rb_path2class("SQLite3::CantOpenException");
+        case SQLITE_PROTOCOL:
+            return rb_path2class("SQLite3::ProtocolException");
+        case SQLITE_EMPTY:
+            return rb_path2class("SQLite3::EmptyException");
+        case SQLITE_SCHEMA:
+            return rb_path2class("SQLite3::SchemaChangedException");
+        case SQLITE_TOOBIG:
+            return rb_path2class("SQLite3::TooBigException");
+        case SQLITE_CONSTRAINT:
+            return rb_path2class("SQLite3::ConstraintException");
+        case SQLITE_MISMATCH:
+            return rb_path2class("SQLite3::MismatchException");
+        case SQLITE_MISUSE:
+            return rb_path2class("SQLite3::MisuseException");
+        case SQLITE_NOLFS:
+            return rb_path2class("SQLite3::UnsupportedException");
+        case SQLITE_AUTH:
+            return rb_path2class("SQLite3::AuthorizationException");
+        case SQLITE_FORMAT:
+            return rb_path2class("SQLite3::FormatException");
+        case SQLITE_RANGE:
+            return rb_path2class("SQLite3::RangeException");
+        case SQLITE_NOTADB:
+            return rb_path2class("SQLite3::NotADatabaseException");
+        default:
+            return rb_path2class("SQLite3::Exception");
+    }
+}
+
+void
+rb_sqlite3_raise(sqlite3 *db, int status)
+{
+    VALUE klass = status2klass(status);
+    if (NIL_P(klass)) {
+        return;
+    }
+
+    VALUE exception = rb_exc_new2(klass, sqlite3_errmsg(db));
+    rb_iv_set(exception, "@code", INT2FIX(status));
+
+    rb_exc_raise(exception);
+}
+
+/*
+ *  accepts a sqlite3 error message as the final argument, which will be `sqlite3_free`d
+ */
+void
+rb_sqlite3_raise_msg(sqlite3 *db, int status, const char *msg)
+{
+    VALUE klass = status2klass(status);
+    if (NIL_P(klass)) {
+        return;
+    }
+
+    VALUE exception = rb_exc_new2(klass, msg);
+    rb_iv_set(exception, "@code", INT2FIX(status));
+    sqlite3_free((void *)msg);
+
+    rb_exc_raise(exception);
+}
+
+void
+rb_sqlite3_raise_with_sql(sqlite3 *db, int status, const char *sql)
+{
+    VALUE klass = status2klass(status);
+    if (NIL_P(klass)) {
+        return;
+    }
+
+    const char *error_msg = sqlite3_errmsg(db);
+    int error_offset = -1;
+#ifdef HAVE_SQLITE3_ERROR_OFFSET
+    error_offset = sqlite3_error_offset(db);
+#endif
 
-  /* Consider only lower 8 bits, to work correctly when
-     extended result codes are enabled. */
-  switch(status & 0xff) {
-    case SQLITE_OK:
-      return;
-      break;
-    case SQLITE_ERROR:
-      klass = rb_path2class("SQLite3::SQLException");
-      break;
-    case SQLITE_INTERNAL:
-      klass = rb_path2class("SQLite3::InternalException");
-      break;
-    case SQLITE_PERM:
-      klass = rb_path2class("SQLite3::PermissionException");
-      break;
-    case SQLITE_ABORT:
-      klass = rb_path2class("SQLite3::AbortException");
-      break;
-    case SQLITE_BUSY:
-      klass = rb_path2class("SQLite3::BusyException");
-      break;
-    case SQLITE_LOCKED:
-      klass = rb_path2class("SQLite3::LockedException");
-      break;
-    case SQLITE_NOMEM:
-      klass = rb_path2class("SQLite3::MemoryException");
-      break;
-    case SQLITE_READONLY:
-      klass = rb_path2class("SQLite3::ReadOnlyException");
-      break;
-    case SQLITE_INTERRUPT:
-      klass = rb_path2class("SQLite3::InterruptException");
-      break;
-    case SQLITE_IOERR:
-      klass = rb_path2class("SQLite3::IOException");
-      break;
-    case SQLITE_CORRUPT:
-      klass = rb_path2class("SQLite3::CorruptException");
-      break;
-    case SQLITE_NOTFOUND:
-      klass = rb_path2class("SQLite3::NotFoundException");
-      break;
-    case SQLITE_FULL:
-      klass = rb_path2class("SQLite3::FullException");
-      break;
-    case SQLITE_CANTOPEN:
-      klass = rb_path2class("SQLite3::CantOpenException");
-      break;
-    case SQLITE_PROTOCOL:
-      klass = rb_path2class("SQLite3::ProtocolException");
-      break;
-    case SQLITE_EMPTY:
-      klass = rb_path2class("SQLite3::EmptyException");
-      break;
-    case SQLITE_SCHEMA:
-      klass = rb_path2class("SQLite3::SchemaChangedException");
-      break;
-    case SQLITE_TOOBIG:
-      klass = rb_path2class("SQLite3::TooBigException");
-      break;
-    case SQLITE_CONSTRAINT:
-      klass = rb_path2class("SQLite3::ConstraintException");
-      break;
-    case SQLITE_MISMATCH:
-      klass = rb_path2class("SQLite3::MismatchException");
-      break;
-    case SQLITE_MISUSE:
-      klass = rb_path2class("SQLite3::MisuseException");
-      break;
-    case SQLITE_NOLFS:
-      klass = rb_path2class("SQLite3::UnsupportedException");
-      break;
-    case SQLITE_AUTH:
-      klass = rb_path2class("SQLite3::AuthorizationException");
-      break;
-    case SQLITE_FORMAT:
-      klass = rb_path2class("SQLite3::FormatException");
-      break;
-    case SQLITE_RANGE:
-      klass = rb_path2class("SQLite3::RangeException");
-      break;
-    case SQLITE_NOTADB:
-      klass = rb_path2class("SQLite3::NotADatabaseException");
-      break;
-    default:
-      klass = rb_eRuntimeError;
-  }
+    VALUE exception = rb_exc_new2(klass, error_msg);
+    rb_iv_set(exception, "@code", INT2FIX(status));
+    if (sql) {
+        rb_iv_set(exception, "@sql", rb_str_new2(sql));
+        rb_iv_set(exception, "@sql_offset", INT2FIX(error_offset));
+    }
 
-  klass = rb_exc_new2(klass, sqlite3_errmsg(db));
-  rb_iv_set(klass, "@code", INT2FIX(status));
-  rb_exc_raise(klass);
+    rb_exc_raise(exception);
 }

data/ext/sqlite3/exception.h

@@ -2,7 +2,11 @@
 #define SQLITE3_EXCEPTION_RUBY
 
 #define CHECK(_db, _status) rb_sqlite3_raise(_db, _status);
+#define CHECK_MSG(_db, _status, _msg) rb_sqlite3_raise_msg(_db, _status, _msg);
+#define CHECK_PREPARE(_db, _status, _sql) rb_sqlite3_raise_with_sql(_db, _status, _sql)
 
-void rb_sqlite3_raise(sqlite3 * db, int status);
+void rb_sqlite3_raise(sqlite3 *db, int status);
+void rb_sqlite3_raise_msg(sqlite3 *db, int status, const char *msg);
+void rb_sqlite3_raise_with_sql(sqlite3 *db, int status, const char *sql);
 
 #endif

data/ext/sqlite3/extconf.rb

@@ -19,7 +19,7 @@ module Sqlite3
 
         configure_extension
 
-        create_makefile('sqlite3/sqlite3_native')
+        create_makefile("sqlite3/sqlite3_native")
       end
 
       def configure_cross_compiler
@@ -50,9 +50,10 @@ module Sqlite3
       def configure_packaged_libraries
         minimal_recipe.tap do |recipe|
           recipe.configure_options += [
-            "--enable-shared=no",
-            "--enable-static=yes",
-            "--enable-fts5",
+            "--disable-shared",
+            "--enable-static",
+            "--disable-tcl",
+            "--enable-fts5"
           ]
           ENV.to_h.tap do |env|
             user_cflags = with_config("sqlite-cflags")
@@ -61,10 +62,13 @@ module Sqlite3
               "-O2", # see https://github.com/sparklemotion/sqlite3-ruby/issues/335 for some benchmarks
               "-fvisibility=hidden", # see https://github.com/rake-compiler/rake-compiler-dock/issues/87
               "-DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1",
+              "-DSQLITE_USE_URI=1",
+              "-DSQLITE_ENABLE_DBPAGE_VTAB=1",
+              "-DSQLITE_ENABLE_DBSTAT_VTAB=1"
             ]
             env["CFLAGS"] = [user_cflags, env["CFLAGS"], more_cflags].flatten.join(" ")
-            recipe.configure_options += env.select { |k,v| ENV_ALLOWLIST.include?(k) }
-                                           .map { |key, value| "#{key}=#{value.strip}" }
+            recipe.configure_options += env.select { |k, v| ENV_ALLOWLIST.include?(k) }
+              .map { |key, value| "#{key}=#{value.strip}" }
           end
 
           unless File.exist?(File.join(recipe.target, recipe.host, recipe.name, recipe.version))
@@ -93,14 +97,13 @@ module Sqlite3
           end
 
           ldflags.each { |ldflag| append_ldflags(ldflag) }
+
+          append_cppflags("-DUSING_PACKAGED_LIBRARIES")
+          append_cppflags("-DUSING_PRECOMPILED_LIBRARIES") if cross_build?
         end
       end
 
       def configure_extension
-        if Gem::Requirement.new("< 2.7").satisfied_by?(Gem::Version.new(RUBY_VERSION))
-          append_cppflags("-DTAINTING_SUPPORT")
-        end
-
         append_cflags("-fvisibility=hidden") # see https://github.com/rake-compiler/rake-compiler-dock/issues/87
 
         if find_header("sqlite3.h")
@@ -113,26 +116,33 @@ module Sqlite3
 
         abort_could_not_find(libname) unless find_library(libname, "sqlite3_libversion_number", "sqlite3.h")
 
+        # Truffle Ruby doesn't support this yet:
+        # https://github.com/oracle/truffleruby/issues/3408
+        have_func("rb_enc_interned_str_cstr")
+
         # Functions defined in 1.9 but not 1.8
-        have_func('rb_proc_arity')
+        have_func("rb_proc_arity")
 
         # Functions defined in 2.1 but not 2.0
-        have_func('rb_integer_pack')
+        have_func("rb_integer_pack")
 
         # These functions may not be defined
-        have_func('sqlite3_initialize')
-        have_func('sqlite3_backup_init')
-        have_func('sqlite3_column_database_name')
-        have_func('sqlite3_enable_load_extension')
-        have_func('sqlite3_load_extension')
+        have_func("sqlite3_initialize")
+        have_func("sqlite3_backup_init")
+        have_func("sqlite3_column_database_name")
+        have_func("sqlite3_enable_load_extension")
+        have_func("sqlite3_load_extension")
 
-        unless have_func('sqlite3_open_v2') # https://www.sqlite.org/releaselog/3_5_0.html
+        unless have_func("sqlite3_open_v2") # https://www.sqlite.org/releaselog/3_5_0.html
           abort("\nPlease use a version of SQLite3 >= 3.5.0\n\n")
         end
 
-        have_func('sqlite3_prepare_v2')
-        have_type('sqlite3_int64', 'sqlite3.h')
-        have_type('sqlite3_uint64', 'sqlite3.h')
+        have_func("sqlite3_prepare_v2")
+        have_func("sqlite3_db_name", "sqlite3.h") # v3.39.0
+        have_func("sqlite3_error_offset", "sqlite3.h") # v3.38.0
+
+        have_type("sqlite3_int64", "sqlite3.h")
+        have_type("sqlite3_uint64", "sqlite3.h")
       end
 
       def minimal_recipe
@@ -158,8 +168,7 @@ module Sqlite3
       end
 
       def mini_portile_config
-        # TODO: once Ruby 2.7 is no longer supported, use symbolize_names: true
-        YAML.load_file(File.join(package_root_dir, "dependencies.yml"))
+        YAML.load_file(File.join(package_root_dir, "dependencies.yml"), symbolize_names: true)
       end
 
       def abort_could_not_find(missing)
@@ -167,7 +176,7 @@ module Sqlite3
       end
 
       def abort_pkg_config(id)
-        abort("\nCould not configure the build properly (#{id}). Please install either the `pkg-config` utility or the `pkg-config` rubygem.\n\n")
+        abort("\nCould not configure the build properly (#{id}). Please install the `pkg-config` utility.\n\n")
       end
 
       def cross_build?