sqlite3 1.3.12-x64-mingw32 → 1.5.0.rc2-x64-mingw32

data/ext/sqlite3/extconf.rb

@@ -1,71 +1,252 @@
-ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+require "mkmf"
+require "mini_portile2"
+
+module Sqlite3
+  module ExtConf
+    ENV_ALLOWLIST = ["CC", "CFLAGS", "LDFLAGS", "LIBS", "CPPFLAGS", "LT_SYS_LIBRARY_PATH", "CPP"]
+
+    class << self
+      def configure
+        configure_cross_compiler
+
+        if system_libraries?
+          message "Building sqlite3-ruby using system #{libname}.\n"
+          configure_system_libraries
+        else
+          message "Building sqlite3-ruby using packaged sqlite3.\n"
+          configure_packaged_libraries
+        end
+
+        configure_extension
+
+        create_makefile('sqlite3/sqlite3_native')
+      end
+
+      def configure_cross_compiler
+        RbConfig::CONFIG["CC"] = RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
+        ENV["CC"] = RbConfig::CONFIG["CC"]
+      end
+
+      def system_libraries?
+        sqlcipher? || enable_config("system-libraries")
+      end
+
+      def libname
+        sqlcipher? ? "sqlcipher" : "sqlite3"
+      end
+
+      def sqlcipher?
+        with_config("sqlcipher") ||
+          with_config("sqlcipher-dir") ||
+          with_config("sqlcipher-include") ||
+          with_config("sqlcipher-lib")
+      end
+
+      def configure_system_libraries
+        pkg_config(libname)
+        append_cppflags("-DUSING_SQLCIPHER") if sqlcipher?
+      end
+
+      def configure_packaged_libraries
+        minimal_recipe.tap do |recipe|
+          recipe.configure_options += ["--enable-shared=no", "--enable-static=yes"]
+          ENV.to_h.tap do |env|
+            additional_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
+            ]
+            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}" }
+          end
+
+          unless File.exist?(File.join(recipe.target, recipe.host, recipe.name, recipe.version))
+            recipe.cook
+          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")
+          end
+        end
+      end
+
+      def configure_extension
+        if Gem::Requirement.new("< 2.7").satisfied_by?(Gem::Version.new(RUBY_VERSION))
+          append_cppflags("-DTAINTING_SUPPORT")
+        end
+
+        if find_header("sqlite3.h")
+          # noop
+        elsif sqlcipher? && find_header("sqlcipher/sqlite3.h")
+          append_cppflags("-DUSING_SQLCIPHER_INC_SUBDIR")
+        else
+          abort_could_not_find("sqlite3.h")
+        end
+
+        abort_could_not_find(libname) unless find_library(libname, "sqlite3_libversion_number", "sqlite3.h")
+
+        # Functions defined in 1.9 but not 1.8
+        have_func('rb_proc_arity')
+
+        # Functions defined in 2.1 but not 2.0
+        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')
+
+        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')
+      end
+
+      def minimal_recipe
+        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
+        end
+      end
+
+      def package_root_dir
+        File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+      end
+
+      def sqlite3_config
+        mini_portile_config[:sqlite3]
+      end
+
+      def mini_portile_config
+        {
+          sqlite3: {
+            # checksum verified by first checking the published sha3(256) checksum:
+            #
+            # $ sha3sum -a 256 ports/archives/sqlite-autoconf-3390200.tar.gz
+            # b195891eb32305481e61c6718b8cc3b090685b613c4824a076c63166a46c5bee  ports/archives/sqlite-autoconf-3390200.tar.gz
+            #
+            # $ sha256sum ports/archives/sqlite-autoconf-3390200.tar.gz
+            # 852be8a6183a17ba47cee0bbff7400b7aa5affd283bf3beefc34fcd088a239de  ports/archives/sqlite-autoconf-3390200.tar.gz
+            #
+            version: "3.39.2",
+            files: [{
+                      url: "https://www.sqlite.org/2022/sqlite-autoconf-3390200.tar.gz",
+                      sha256: "852be8a6183a17ba47cee0bbff7400b7aa5affd283bf3beefc34fcd088a239de",
+                    }],
+          }
+        }
+      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 cross_build?
+        enable_config("cross-build")
+      end
+
+      def download
+        minimal_recipe.download
+      end
+
+      def print_help
+        print(<<~TEXT)
+          USAGE: ruby #{$PROGRAM_NAME} [options]
+
+            Flags that are always valid:
+
+                --disable-system-libraries
+                    Use the packaged libraries, and ignore the system libraries.
+                    (This is the default behavior.)
 
-require 'mkmf'
+                --enable-system-libraries
+                    Use system libraries instead of building and using the packaged libraries.
 
-# :stopdoc:
+                --with-sqlcipher
+                    Use libsqlcipher instead of libsqlite3.
+                    (Implies `--enable-system-libraries`.)
 
-RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+                --help
+                    Display this message.
 
 
+            Flags only used when using system libraries:
 
-ldflags = cppflags = nil
-if RbConfig::CONFIG["host_os"] =~ /darwin/
-  begin
-    brew_info = `brew info sqlite3`
-    ldflags   = brew_info[/LDFLAGS.*$/].split(/-L/).last
-    cppflags  = brew_info[/CPPFLAGS.*$/].split(/-I/).last
-    pkg_conf  = brew_info[/PKG_CONFIG_PATH.*$/].split(": ").last
+                General (applying to all system libraries):
 
-    # pkg_config should be less error prone than parsing compiler
-    # commandline options, but we need to set default ldflags and cpp flags
-    # in case the user doesn't have pkg-config installed
-    ENV['PKG_CONFIG_PATH'] ||= pkg_conf
-  rescue
-  end
-end
+                    --with-opt-dir=DIRECTORY
+                        Look for headers and libraries in DIRECTORY.
 
-pkg_config("sqlite3")
+                    --with-opt-lib=DIRECTORY
+                        Look for libraries in DIRECTORY.
 
-# --with-sqlite3-{dir,include,lib}
-dir_config("sqlite3", cppflags, ldflags)
+                    --with-opt-include=DIRECTORY
+                        Look for headers in DIRECTORY.
 
-if RbConfig::CONFIG["host_os"] =~ /mswin/
-  $CFLAGS << ' -W3'
-end
+                Related to sqlcipher:
 
-def asplode missing
-  if RUBY_PLATFORM =~ /mingw|mswin/
-    abort "#{missing} is missing. Install SQLite3 from " +
-          "http://www.sqlite.org/ first."
-  else
-    abort <<-error
-#{missing} is missing. Try 'brew install sqlite3',
-'yum install sqlite-devel' or 'apt-get install libsqlite3-dev'
-and check your shared library search path (the
-location where your sqlite3 shared library is located).
-    error
-  end
-end
+                    --with-sqlcipher-dir=DIRECTORY
+                        Look for sqlcipher headers and library in DIRECTORY.
+                        (Implies `--with-sqlcipher` and `--enable-system-libraries`.)
+
+                    --with-sqlcipher-lib=DIRECTORY
+                        Look for sqlcipher library in DIRECTORY.
+                        (Implies `--with-sqlcipher` and `--enable-system-libraries`.)
+
+                    --with-sqlcipher-include=DIRECTORY
+                        Look for sqlcipher headers in DIRECTORY.
+                        (Implies `--with-sqlcipher` and `--enable-system-libraries`.)
+
+
+            Flags only used when building and using the packaged libraries:
+
+                --enable-cross-build
+                    Enable cross-build mode. (You probably do not want to set this manually.)
 
-asplode('sqlite3.h')  unless find_header  'sqlite3.h'
-find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
-asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
 
-# Functions defined in 1.9 but not 1.8
-have_func('rb_proc_arity')
+            Environment variables used for compiling the C extension:
 
-# Functions defined in 2.1 but not 2.0
-have_func('rb_integer_pack')
+                CC
+                    Use this path to invoke the compiler instead of `RbConfig::CONFIG['CC']`
 
-# 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_open_v2')
-have_func('sqlite3_prepare_v2')
-have_type('sqlite3_int64', 'sqlite3.h')
-have_type('sqlite3_uint64', 'sqlite3.h')
 
-create_makefile('sqlite3/sqlite3_native')
+            Environment variables passed through to the compilation of packaged libraries:
+
+                CC
+                CPPFLAGS
+                CFLAGS
+                LDFLAGS
+                LIBS
+                LT_SYS_LIBRARY_PATH
+                CPP
+
+        TEXT
+      end
+    end
+  end
+end
+
+if arg_config("--help")
+  Sqlite3::ExtConf.print_help
+  exit!(0)
+end
+
+if arg_config("--download-dependencies")
+  Sqlite3::ExtConf.download
+  exit!(0)
+end
+
+Sqlite3::ExtConf.configure

data/ext/sqlite3/sqlite3.c

@@ -65,6 +65,15 @@ static VALUE libversion(VALUE UNUSED(klass))
   return INT2NUM(sqlite3_libversion_number());
 }
 
+static VALUE using_sqlcipher(VALUE UNUSED(klass))
+{
+#ifdef USING_SQLCIPHER
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
 /* Returns the compile time setting of the SQLITE_THREADSAFE flag.
  * See: https://www.sqlite.org/c3ref/threadsafe.html
  */
@@ -144,9 +153,11 @@ void Init_sqlite3_native()
 #ifdef HAVE_SQLITE3_BACKUP_INIT
   init_sqlite3_backup();
 #endif
-
+  rb_define_singleton_method(mSqlite3, "sqlcipher?", using_sqlcipher, 0);
   rb_define_singleton_method(mSqlite3, "libversion", libversion, 0);
   rb_define_singleton_method(mSqlite3, "threadsafe", threadsafe_p, 0);
   rb_define_const(mSqlite3, "SQLITE_VERSION", rb_str_new2(SQLITE_VERSION));
   rb_define_const(mSqlite3, "SQLITE_VERSION_NUMBER", INT2FIX(SQLITE_VERSION_NUMBER));
+  rb_define_const(mSqlite3, "SQLITE_LOADED_VERSION", rb_str_new2(sqlite3_libversion()));
+
 }

data/ext/sqlite3/sqlite3_ruby.h

@@ -12,7 +12,6 @@
 # define UNUSED(x) x
 #endif
 
-#ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
 
 #define USASCII_P(_obj) (rb_enc_get_index(_obj) == rb_usascii_encindex())
@@ -22,15 +21,12 @@
 #define SQLITE3_UTF8_STR_NEW2(_obj) \
     (rb_enc_associate_index(rb_str_new2(_obj), rb_utf8_encindex()))
 
+#ifdef USING_SQLCIPHER_INC_SUBDIR
+#  include <sqlcipher/sqlite3.h>
 #else
-
-#define SQLITE3_UTF8_STR_NEW2(_obj) (rb_str_new2(_obj))
-
+#  include <sqlite3.h>
 #endif
 
-
-#include <sqlite3.h>
-
 #ifndef HAVE_TYPE_SQLITE3_INT64
 typedef sqlite_int64 sqlite3_int64;
 #endif

data/ext/sqlite3/statement.c

@@ -43,11 +43,9 @@ static VALUE initialize(VALUE self, VALUE db, VALUE sql)
   if(!db_ctx->db)
     rb_raise(rb_eArgError, "prepare called on a closed database");
 
-#ifdef HAVE_RUBY_ENCODING_H
   if(!UTF8_P(sql)) {
     sql               = rb_str_export_to_enc(sql, rb_utf8_encoding());
   }
-#endif
 
 #ifdef HAVE_SQLITE3_PREPARE_V2
   status = sqlite3_prepare_v2(
@@ -110,9 +108,7 @@ static VALUE step(VALUE self)
   sqlite3_stmt *stmt;
   int value, length;
   VALUE list;
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding * internal_encoding;
-#endif
 
   Data_Get_Struct(self, sqlite3StmtRuby, ctx);
 
@@ -120,17 +116,24 @@ static VALUE step(VALUE self)
 
   if(ctx->done_p) return Qnil;
 
-#ifdef HAVE_RUBY_ENCODING_H
   {
       VALUE db          = rb_iv_get(self, "@connection");
       rb_funcall(db, rb_intern("encoding"), 0);
       internal_encoding = rb_default_internal_encoding();
   }
-#endif
 
   stmt = ctx->st;
 
   value = sqlite3_step(stmt);
+  if (rb_errinfo() != Qnil) {
+    /* some user defined function was invoked as a callback during step and
+     * it raised an exception that has been suppressed until step returns.
+     * Now re-raise it. */
+    VALUE exception = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    rb_exc_raise(exception);
+  }
+
   length = sqlite3_column_count(stmt);
   list = rb_ary_new2((long)length);
 
@@ -148,21 +151,19 @@ static VALUE step(VALUE self)
               break;
             case SQLITE_TEXT:
               {
-                VALUE str = rb_tainted_str_new(
+                VALUE str = rb_str_new(
                     (const char *)sqlite3_column_text(stmt, i),
                     (long)sqlite3_column_bytes(stmt, i)
                 );
-#ifdef HAVE_RUBY_ENCODING_H
                 rb_enc_associate_index(str, rb_utf8_encindex());
                 if(internal_encoding)
                   str = rb_str_export_to_enc(str, internal_encoding);
-#endif
                 rb_ary_push(list, str);
               }
               break;
             case SQLITE_BLOB:
               {
-                VALUE str = rb_tainted_str_new(
+                VALUE str = rb_str_new(
                     (const char *)sqlite3_column_blob(stmt, i),
                     (long)sqlite3_column_bytes(stmt, i)
                 );
@@ -225,9 +226,7 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
   switch(TYPE(value)) {
     case T_STRING:
       if(CLASS_OF(value) == cSqlite3Blob
-#ifdef HAVE_RUBY_ENCODING_H
               || rb_enc_get_index(value) == rb_ascii8bit_encindex()
-#endif
         ) {
         status = sqlite3_bind_blob(
             ctx->st,
@@ -239,7 +238,6 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
       } else {
 
 
-#ifdef HAVE_RUBY_ENCODING_H
         if (UTF16_LE_P(value) || UTF16_BE_P(value)) {
           status = sqlite3_bind_text16(
               ctx->st,
@@ -252,7 +250,6 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
           if (!UTF8_P(value) || !USASCII_P(value)) {
               value = rb_str_encode(value, rb_enc_from_encoding(rb_utf8_encoding()), 0, Qnil);
           }
-#endif
         status = sqlite3_bind_text(
             ctx->st,
             index,
@@ -260,9 +257,7 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
             (int)RSTRING_LEN(value),
             SQLITE_TRANSIENT
             );
-#ifdef HAVE_RUBY_ENCODING_H
         }
-#endif
       }
       break;
     case T_BIGNUM: {
@@ -295,7 +290,7 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
 /* call-seq: stmt.reset!
  *
  * Resets the statement. This is typically done internally, though it might
- * occassionally be necessary to manually reset the statement.
+ * occasionally be necessary to manually reset the statement.
  */
 static VALUE reset_bang(VALUE self)
 {
@@ -314,9 +309,9 @@ static VALUE reset_bang(VALUE self)
 /* call-seq: stmt.clear_bindings!
  *
  * Resets the statement. This is typically done internally, though it might
- * occassionally be necessary to manually reset the statement.
+ * occasionally be necessary to manually reset the statement.
  */
-static VALUE clear_bindings(VALUE self)
+static VALUE clear_bindings_bang(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
 
@@ -433,7 +428,7 @@ void init_sqlite3_statement()
   rb_define_method(cSqlite3Statement, "closed?", closed_p, 0);
   rb_define_method(cSqlite3Statement, "bind_param", bind_param, 2);
   rb_define_method(cSqlite3Statement, "reset!", reset_bang, 0);
-  rb_define_method(cSqlite3Statement, "clear_bindings!", clear_bindings, 0);
+  rb_define_method(cSqlite3Statement, "clear_bindings!", clear_bindings_bang, 0);
   rb_define_method(cSqlite3Statement, "step", step, 0);
   rb_define_method(cSqlite3Statement, "done?", done_p, 0);
   rb_define_method(cSqlite3Statement, "column_count", column_count, 0);