sqlite3 1.5.0 → 2.0.2

data/ext/sqlite3/database.h

@@ -4,14 +4,19 @@
 #include <sqlite3_ruby.h>
 
 struct _sqlite3Ruby {
-  sqlite3 *db;
+    sqlite3 *db;
+    VALUE busy_handler;
+    int stmt_timeout;
+    struct timespec stmt_deadline;
 };
 
 typedef struct _sqlite3Ruby sqlite3Ruby;
-typedef sqlite3Ruby * sqlite3RubyPtr;
+typedef sqlite3Ruby *sqlite3RubyPtr;
 
 void init_sqlite3_database();
-void set_sqlite3_func_result(sqlite3_context * ctx, VALUE result);
-VALUE sqlite3val2rb(sqlite3_value * val);
+void set_sqlite3_func_result(sqlite3_context *ctx, VALUE result);
+
+sqlite3RubyPtr sqlite3_database_unwrap(VALUE database);
+VALUE sqlite3val2rb(sqlite3_value *val);
 
 #endif

data/ext/sqlite3/exception.c

@@ -1,98 +1,117 @@
 #include <sqlite3_ruby.h>
 
-void rb_sqlite3_raise(sqlite3 * db, int status)
+void
+rb_sqlite3_raise(sqlite3 *db, int status)
 {
-  VALUE klass = Qnil;
+    VALUE klass = Qnil;
 
-  /* 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;
-  }
+    /* 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_path2class("SQLite3::Exception");
+    }
 
-  klass = rb_exc_new2(klass, sqlite3_errmsg(db));
-  rb_iv_set(klass, "@code", INT2FIX(status));
-  rb_exc_raise(klass);
+    klass = rb_exc_new2(klass, sqlite3_errmsg(db));
+    rb_iv_set(klass, "@code", INT2FIX(status));
+    rb_exc_raise(klass);
+}
+
+/*
+ *  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 exception;
+
+    if (status == SQLITE_OK) {
+        return;
+    }
+
+    exception = rb_exc_new2(rb_path2class("SQLite3::Exception"), msg);
+    sqlite3_free((void *)msg);
+    rb_iv_set(exception, "@code", INT2FIX(status));
+    rb_exc_raise(exception);
 }

data/ext/sqlite3/exception.h

@@ -2,7 +2,9 @@
 #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);
 
-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);
 
 #endif

data/ext/sqlite3/extconf.rb

@@ -1,5 +1,5 @@
 require "mkmf"
-require "mini_portile2"
+require "yaml"
 
 module Sqlite3
   module ExtConf
@@ -19,7 +19,7 @@ module Sqlite3
 
         configure_extension
 
-        create_makefile('sqlite3/sqlite3_native')
+        create_makefile("sqlite3/sqlite3_native")
       end
 
       def configure_cross_compiler
@@ -49,15 +49,22 @@ module Sqlite3
 
       def configure_packaged_libraries
         minimal_recipe.tap do |recipe|
-          recipe.configure_options += ["--enable-shared=no", "--enable-static=yes"]
+          recipe.configure_options += [
+            "--enable-shared=no",
+            "--enable-static=yes",
+            "--enable-fts5"
+          ]
           ENV.to_h.tap do |env|
-            additional_cflags = [
+            user_cflags = with_config("sqlite-cflags")
+            more_cflags = [
               "-fPIC", # needed for linking the static library into a shared library
               "-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"
             ]
-            env["CFLAGS"] = [env["CFLAGS"], additional_cflags].flatten.join(" ")
-            recipe.configure_options += env.select { |k,v| ENV_ALLOWLIST.include?(k) }
-                                           .map { |key, value| "#{key}=#{value.strip}" }
+            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}" }
           end
 
           unless File.exist?(File.join(recipe.target, recipe.host, recipe.name, recipe.version))
@@ -65,22 +72,32 @@ module Sqlite3
           end
           recipe.activate
 
-          ENV["PKG_CONFIG_ALLOW_SYSTEM_CFLAGS"] = "t" # on macos, pkg-config will not return --cflags without this
-          pcfile = File.join(recipe.path, "lib", "pkgconfig", "sqlite3.pc")
-          if pkg_config(pcfile)
-            # see https://bugs.ruby-lang.org/issues/18490
-            libs = xpopen(["pkg-config", "--libs", "--static", pcfile], err: [:child, :out], &:read)
-            libs.split.each { |lib| append_ldflags(lib) } if $?.success?
-          else
-            abort("\nCould not configure the build properly. Please install either the `pkg-config` utility or the `pkg-config` rubygem.\n\n")
+          # on macos, pkg-config will not return --cflags without this
+          ENV["PKG_CONFIG_ALLOW_SYSTEM_CFLAGS"] = "t"
+
+          # only needed for Ruby 3.1.3, see https://bugs.ruby-lang.org/issues/19233
+          RbConfig::CONFIG["PKG_CONFIG"] = config_string("PKG_CONFIG") || "pkg-config"
+
+          lib_path = File.join(recipe.path, "lib")
+          pcfile = File.join(lib_path, "pkgconfig", "sqlite3.pc")
+          abort_pkg_config("pkg_config") unless pkg_config(pcfile)
+
+          # see https://bugs.ruby-lang.org/issues/18490
+          ldflags = xpopen(["pkg-config", "--libs", "--static", pcfile], err: [:child, :out], &:read)
+          abort_pkg_config("xpopen") unless $?.success?
+          ldflags = ldflags.split
+
+          # see https://github.com/flavorjones/mini_portile/issues/118
+          "-L#{lib_path}".tap do |lib_path_flag|
+            ldflags.prepend(lib_path_flag) unless ldflags.include?(lib_path_flag)
           end
+
+          ldflags.each { |ldflag| append_ldflags(ldflag) }
         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")
           # noop
@@ -92,33 +109,43 @@ 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_type("sqlite3_int64", "sqlite3.h")
+        have_type("sqlite3_uint64", "sqlite3.h")
       end
 
       def minimal_recipe
+        require "mini_portile2"
+
         MiniPortile.new(libname, sqlite3_config[:version]).tap do |recipe|
-          recipe.files = sqlite3_config[:files]
-          recipe.target = File.join(package_root_dir, "ports")
-          recipe.patch_files = Dir[File.join(package_root_dir, "patches", "*.patch")].sort
+          if sqlite_source_dir
+            recipe.source_directory = sqlite_source_dir
+          else
+            recipe.files = sqlite3_config[:files]
+            recipe.target = File.join(package_root_dir, "ports")
+            recipe.patch_files = Dir[File.join(package_root_dir, "patches", "*.patch")].sort
+          end
         end
       end
 
@@ -131,37 +158,33 @@ module Sqlite3
       end
 
       def mini_portile_config
-        {
-          sqlite3: {
-            # checksum verified by first checking the published sha3(256) checksum against https://sqlite.org/download.html:
-            #
-            # $ sha3sum -a 256 ports/archives/sqlite-autoconf-3390300.tar.gz
-            # dfa055c70724cd63f0b7da6e9f53530d8da51fe021e3f864d58c7c847d590e1d  ports/archives/sqlite-autoconf-3390300.tar.gz
-            #
-            # $ sha256sum ports/archives/sqlite-autoconf-3390300.tar.gz
-            # 7868fb3082be3f2cf4491c6fba6de2bddcbc293a35fefb0624ee3c13f01422b9  ports/archives/sqlite-autoconf-3390300.tar.gz
-            #
-            version: "3.39.3",
-            files: [{
-                      url: "https://www.sqlite.org/2022/sqlite-autoconf-3390300.tar.gz",
-                      sha256: "7868fb3082be3f2cf4491c6fba6de2bddcbc293a35fefb0624ee3c13f01422b9",
-                    }],
-          }
-        }
+        YAML.load_file(File.join(package_root_dir, "dependencies.yml"), symbolize_names: true)
       end
 
       def abort_could_not_find(missing)
         abort("\nCould not find #{missing}.\nPlease visit https://github.com/sparklemotion/sqlite3-ruby for installation instructions.\n\n")
       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")
+      end
+
       def cross_build?
         enable_config("cross-build")
       end
 
+      def sqlite_source_dir
+        arg_config("--with-sqlite-source-dir")
+      end
+
       def download
         minimal_recipe.download
       end
 
+      def darwin?
+        RbConfig::CONFIG["target_os"].include?("darwin")
+      end
+
       def print_help
         print(<<~TEXT)
           USAGE: ruby #{$PROGRAM_NAME} [options]
@@ -179,6 +202,9 @@ module Sqlite3
                     Use libsqlcipher instead of libsqlite3.
                     (Implies `--enable-system-libraries`.)
 
+                --with-sqlite-source-dir=DIRECTORY
+                    (dev only) Build sqlite from the source code in DIRECTORY
+
                 --help
                     Display this message.
 
@@ -213,17 +239,23 @@ module Sqlite3
 
             Flags only used when building and using the packaged libraries:
 
+                --with-sqlite-cflags=CFLAGS
+                    Explicitly pass compiler flags to the sqlite library build. These flags will
+                    appear on the commandline before any flags set in the CFLAGS environment
+                    variable. This is useful for setting compilation options in your project's
+                    bundler config. See INSTALLATION.md for more information.
+
                 --enable-cross-build
                     Enable cross-build mode. (You probably do not want to set this manually.)
 
 
-            Environment variables used for compiling the C extension:
+            Environment variables used for compiling the gem's C extension:
 
                 CC
                     Use this path to invoke the compiler instead of `RbConfig::CONFIG['CC']`
 
 
-            Environment variables passed through to the compilation of packaged libraries:
+            Environment variables passed through to the compilation of sqlite:
 
                 CC
                 CPPFLAGS