sqlite3 1.4.2 → 1.7.2

data/ext/sqlite3/extconf.rb

@@ -1,100 +1,285 @@
-ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
-
-require 'mkmf'
-
-# :stopdoc:
-
-RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
-
-ldflags = cppflags = nil
-if RbConfig::CONFIG["host_os"] =~ /darwin/
-  begin
-    if with_config('sqlcipher')
-      brew_prefix = `brew --prefix sqlcipher`.chomp
-      ldflags   = "#{brew_prefix}/lib"
-      cppflags  = "#{brew_prefix}/include/sqlcipher"
-      pkg_conf  = "#{brew_prefix}/lib/pkgconfig"
-    else
-      brew_prefix = `brew --prefix sqlite3`.chomp
-      ldflags   = "#{brew_prefix}/lib"
-      cppflags  = "#{brew_prefix}/include"
-      pkg_conf  = "#{brew_prefix}/lib/pkgconfig"
-    end
+require "mkmf"
+require "yaml"
 
-    # 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
+module Sqlite3
+  module ExtConf
+    ENV_ALLOWLIST = ["CC", "CFLAGS", "LDFLAGS", "LIBS", "CPPFLAGS", "LT_SYS_LIBRARY_PATH", "CPP"]
 
-if with_config('sqlcipher')
-  pkg_config("sqlcipher")
-else
-  pkg_config("sqlite3")
-end
+    class << self
+      def configure
+        configure_cross_compiler
 
-# --with-sqlite3-{dir,include,lib}
-if with_config('sqlcipher')
-  $CFLAGS << ' -DUSING_SQLCIPHER'
-  dir_config("sqlcipher", cppflags, ldflags)
-else
-  dir_config("sqlite3", cppflags, ldflags)
-end
+        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
 
-if RbConfig::CONFIG["host_os"] =~ /mswin/
-  $CFLAGS << ' -W3'
-end
+        configure_extension
 
-if RUBY_VERSION < '2.7'
-  $CFLAGS << ' -DTAINTING_SUPPORT'
-end
+        create_makefile('sqlite3/sqlite3_native')
+      end
 
-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
+      def configure_cross_compiler
+        RbConfig::CONFIG["CC"] = RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
+        ENV["CC"] = RbConfig::CONFIG["CC"]
+      end
 
-asplode('sqlite3.h')  unless find_header  'sqlite3.h'
-find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
+      def system_libraries?
+        sqlcipher? || enable_config("system-libraries")
+      end
 
-have_library 'dl' # for static builds
+      def libname
+        sqlcipher? ? "sqlcipher" : "sqlite3"
+      end
 
-if with_config('sqlcipher')
-  asplode('sqlcipher') unless find_library 'sqlcipher', 'sqlite3_libversion_number'
-else
-  asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
-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",
+            "--enable-fts5",
+          ]
+          ENV.to_h.tap do |env|
+            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"] = [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))
+            recipe.cook
+          end
+          recipe.activate
+
+          # 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
+        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
+        require "mini_portile2"
+
+        MiniPortile.new(libname, sqlite3_config[:version]).tap do |recipe|
+          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
+
+      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
+        # TODO: once Ruby 2.7 is no longer supported, use symbolize_names: true
+        YAML.load_file(File.join(package_root_dir, "dependencies.yml"))
+      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
 
-# Functions defined in 1.9 but not 1.8
-have_func('rb_proc_arity')
+      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
 
-# Functions defined in 2.1 but not 2.0
-have_func('rb_integer_pack')
+      def cross_build?
+        enable_config("cross-build")
+      end
 
-# 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')
+      def sqlite_source_dir
+        arg_config("--with-sqlite-source-dir")
+      end
 
-unless have_func('sqlite3_open_v2')
-  abort "Please use a newer version of SQLite3"
+      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]
+
+            Flags that are always valid:
+
+                --disable-system-libraries
+                    Use the packaged libraries, and ignore the system libraries.
+                    (This is the default behavior.)
+
+                --enable-system-libraries
+                    Use system libraries instead of building and using the packaged libraries.
+
+                --with-sqlcipher
+                    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.
+
+
+            Flags only used when using system libraries:
+
+                General (applying to all system libraries):
+
+                    --with-opt-dir=DIRECTORY
+                        Look for headers and libraries in DIRECTORY.
+
+                    --with-opt-lib=DIRECTORY
+                        Look for libraries in DIRECTORY.
+
+                    --with-opt-include=DIRECTORY
+                        Look for headers in DIRECTORY.
+
+                Related to sqlcipher:
+
+                    --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:
+
+                --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 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 sqlite:
+
+                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
 
-have_func('sqlite3_prepare_v2')
-have_type('sqlite3_int64', 'sqlite3.h')
-have_type('sqlite3_uint64', 'sqlite3.h')
+if arg_config("--download-dependencies")
+  Sqlite3::ExtConf.download
+  exit!(0)
+end
 
-create_makefile('sqlite3/sqlite3_native')
+Sqlite3::ExtConf.configure

data/ext/sqlite3/sqlite3.c

@@ -82,7 +82,7 @@ static VALUE threadsafe_p(VALUE UNUSED(klass))
   return INT2NUM(sqlite3_threadsafe());
 }
 
-void init_sqlite3_constants()
+void init_sqlite3_constants(void)
 {
   VALUE mSqlite3Constants;
   VALUE mSqlite3Open;
@@ -127,7 +127,8 @@ void init_sqlite3_constants()
 #endif
 }
 
-void Init_sqlite3_native()
+RUBY_FUNC_EXPORTED
+void Init_sqlite3_native(void)
 {
   /*
    * SQLite3 is a wrapper around the popular database
@@ -158,4 +159,6 @@ void Init_sqlite3_native()
   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

@@ -21,8 +21,11 @@
 #define SQLITE3_UTF8_STR_NEW2(_obj) \
     (rb_enc_associate_index(rb_str_new2(_obj), rb_utf8_encindex()))
 
-
-#include <sqlite3.h>
+#ifdef USING_SQLCIPHER_INC_SUBDIR
+#  include <sqlcipher/sqlite3.h>
+#else
+#  include <sqlite3.h>
+#endif
 
 #ifndef HAVE_TYPE_SQLITE3_INT64
 typedef sqlite_int64 sqlite3_int64;

data/ext/sqlite3/statement.c

@@ -6,19 +6,29 @@
 
 VALUE cSqlite3Statement;
 
-static void deallocate(void * ctx)
+static size_t statement_memsize(const void *data)
 {
-  sqlite3StmtRubyPtr c = (sqlite3StmtRubyPtr)ctx;
-  xfree(c);
+  const sqlite3StmtRubyPtr s = (const sqlite3StmtRubyPtr)data;
+  // NB: can't account for s->st because the type is incomplete.
+  return sizeof(*s);
 }
 
+static const rb_data_type_t statement_type = {
+  "SQLite3::Backup",
+  {
+      NULL,
+      RUBY_TYPED_DEFAULT_FREE,
+      statement_memsize,
+  },
+  0,
+  0,
+  RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
 static VALUE allocate(VALUE klass)
 {
-  sqlite3StmtRubyPtr ctx = xcalloc((size_t)1, sizeof(sqlite3StmtRuby));
-  ctx->st     = NULL;
-  ctx->done_p = 0;
-
-  return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+  sqlite3StmtRubyPtr ctx;
+  return TypedData_Make_Struct(klass, sqlite3StmtRuby, &statement_type, ctx);
 }
 
 /* call-seq: SQLite3::Statement.new(db, sql)
@@ -30,15 +40,14 @@ static VALUE allocate(VALUE klass)
  */
 static VALUE initialize(VALUE self, VALUE db, VALUE sql)
 {
-  sqlite3RubyPtr db_ctx;
+  sqlite3RubyPtr db_ctx = sqlite3_database_unwrap(db);
   sqlite3StmtRubyPtr ctx;
   const char *tail = NULL;
   int status;
 
   StringValue(sql);
 
-  Data_Get_Struct(db, sqlite3Ruby, db_ctx);
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
 
   if(!db_ctx->db)
     rb_raise(rb_eArgError, "prepare called on a closed database");
@@ -78,7 +87,7 @@ static VALUE sqlite3_rb_close(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
 
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
 
   REQUIRE_OPEN_STMT(ctx);
 
@@ -95,7 +104,7 @@ static VALUE sqlite3_rb_close(VALUE self)
 static VALUE closed_p(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
 
   if(!ctx->st) return Qtrue;
 
@@ -110,7 +119,7 @@ static VALUE step(VALUE self)
   VALUE list;
   rb_encoding * internal_encoding;
 
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
 
   REQUIRE_OPEN_STMT(ctx);
 
@@ -206,7 +215,7 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
   int status;
   int index;
 
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
   switch(TYPE(key)) {
@@ -290,13 +299,13 @@ 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)
 {
   sqlite3StmtRubyPtr ctx;
 
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
   sqlite3_reset(ctx->st);
@@ -309,13 +318,13 @@ 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_bang(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
 
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
   sqlite3_clear_bindings(ctx->st);
@@ -332,7 +341,7 @@ static VALUE clear_bindings_bang(VALUE self)
 static VALUE done_p(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
 
   if(ctx->done_p) return Qtrue;
   return Qfalse;
@@ -345,10 +354,10 @@ static VALUE done_p(VALUE self)
 static VALUE column_count(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
-  return INT2NUM((long)sqlite3_column_count(ctx->st));
+  return INT2NUM(sqlite3_column_count(ctx->st));
 }
 
 /* call-seq: stmt.column_name(index)
@@ -360,7 +369,7 @@ static VALUE column_name(VALUE self, VALUE index)
   sqlite3StmtRubyPtr ctx;
   const char * name;
 
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
   name = sqlite3_column_name(ctx->st, (int)NUM2INT(index));
@@ -378,7 +387,7 @@ static VALUE column_decltype(VALUE self, VALUE index)
   sqlite3StmtRubyPtr ctx;
   const char * name;
 
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
   name = sqlite3_column_decltype(ctx->st, (int)NUM2INT(index));
@@ -394,10 +403,10 @@ static VALUE column_decltype(VALUE self, VALUE index)
 static VALUE bind_parameter_count(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
-  return INT2NUM((long)sqlite3_bind_parameter_count(ctx->st));
+  return INT2NUM(sqlite3_bind_parameter_count(ctx->st));
 }
 
 #ifdef HAVE_SQLITE3_COLUMN_DATABASE_NAME
@@ -409,7 +418,7 @@ static VALUE bind_parameter_count(VALUE self)
 static VALUE database_name(VALUE self, VALUE index)
 {
   sqlite3StmtRubyPtr ctx;
-  Data_Get_Struct(self, sqlite3StmtRuby, ctx);
+  TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
   return SQLITE3_UTF8_STR_NEW2(
@@ -418,7 +427,7 @@ static VALUE database_name(VALUE self, VALUE index)
 
 #endif
 
-void init_sqlite3_statement()
+void init_sqlite3_statement(void)
 {
   cSqlite3Statement = rb_define_class_under(mSqlite3, "Statement", rb_cObject);
 

data/lib/sqlite3/constants.rb

@@ -37,7 +37,7 @@ module SQLite3 ; module Constants
     EMPTY      = 16   # (Internal Only) Database table is empty
     SCHEMA     = 17   # The database schema changed
     TOOBIG     = 18   # Too much data for one row of a table
-    CONSTRAINT = 19   # Abort due to contraint violation
+    CONSTRAINT = 19   # Abort due to constraint violation
     MISMATCH   = 20   # Data type mismatch
     MISUSE     = 21   # Library used incorrectly
     NOLFS      = 22   # Uses OS features not supported on host