sqlite3 1.3.5 → 1.3.13

data/ext/sqlite3/extconf.rb

@@ -6,14 +6,29 @@ require 'mkmf'
 
 RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
-# --with-sqlite3-{dir,include,lib}
-dir_config("sqlite3")
 
-# prioritize local builds
-if enable_config("local", false)
-  $LDFLAGS = ENV.fetch("LDFLAGS", nil)
+
+ldflags = cppflags = nil
+if RbConfig::CONFIG["host_os"] =~ /darwin/
+  begin
+    brew_prefix = `brew --prefix sqlite3`.chomp
+    ldflags   = "#{brew_prefix}/lib"
+    cppflags  = "#{brew_prefix}/include"
+    pkg_conf  = "#{brew_prefix}/lib/pkgconfig"
+
+    # 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
 
+pkg_config("sqlite3")
+
+# --with-sqlite3-{dir,include,lib}
+dir_config("sqlite3", cppflags, ldflags)
+
 if RbConfig::CONFIG["host_os"] =~ /mswin/
   $CFLAGS << ' -W3'
 end
@@ -24,24 +39,33 @@ def asplode missing
           "http://www.sqlite.org/ first."
   else
     abort <<-error
-#{missing} is missing. Try 'port install sqlite3 +universal'
-or 'yum install sqlite-devel' and check your shared library search path (the
+#{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
 
 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')
 
+# 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')
+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')

data/ext/sqlite3/sqlite3.c

@@ -3,11 +3,121 @@
 VALUE mSqlite3;
 VALUE cSqlite3Blob;
 
+int bignum_to_int64(VALUE value, sqlite3_int64 *result)
+{
+#ifdef HAVE_RB_INTEGER_PACK
+  const int nails = 0;
+  int t = rb_integer_pack(value, result, 1, sizeof(*result), nails,
+			  INTEGER_PACK_NATIVE_BYTE_ORDER|
+			  INTEGER_PACK_2COMP);
+  switch (t) {
+  case -2: case +2:
+    return 0;
+  case +1:
+    if (!nails) {
+      if (*result < 0) return 0;
+    }
+    break;
+  case -1:
+    if (!nails) {
+      if (*result >= 0) return 0;
+    }
+    else {
+      *result += INT64_MIN;
+    }
+    break;
+  }
+  return 1;
+#else
+# ifndef RBIGNUM_LEN
+#   define RBIGNUM_LEN(x) RBIGNUM(x)->len
+# endif
+  const long len = RBIGNUM_LEN(value);
+  if (len == 0) {
+    *result = 0;
+    return 1;
+  }
+  if (len > 63 / (SIZEOF_BDIGITS * CHAR_BIT) + 1) return 0;
+  if (len == 63 / (SIZEOF_BDIGITS * CHAR_BIT) + 1) {
+    const BDIGIT *digits = RBIGNUM_DIGITS(value);
+    BDIGIT blast = digits[len-1];
+    BDIGIT bmax = (BDIGIT)1UL << (63 % (CHAR_BIT * SIZEOF_BDIGITS));
+    if (blast > bmax) return 0;
+    if (blast == bmax) {
+      if (RBIGNUM_POSITIVE_P(value)) {
+	return 0;
+      }
+      else {
+	long i = len-1;
+	while (i) {
+	  if (digits[--i]) return 0;
+	}
+      }
+    }
+  }
+  *result = (sqlite3_int64)NUM2LL(value);
+  return 1;
+#endif
+}
+
 static VALUE libversion(VALUE UNUSED(klass))
 {
   return INT2NUM(sqlite3_libversion_number());
 }
 
+/* Returns the compile time setting of the SQLITE_THREADSAFE flag.
+ * See: https://www.sqlite.org/c3ref/threadsafe.html
+ */
+static VALUE threadsafe_p(VALUE UNUSED(klass))
+{
+  return INT2NUM(sqlite3_threadsafe());
+}
+
+void init_sqlite3_constants()
+{
+  VALUE mSqlite3Constants;
+  VALUE mSqlite3Open;
+
+  mSqlite3Constants = rb_define_module_under(mSqlite3, "Constants");
+
+  /* sqlite3_open_v2 flags for Database::new */
+  mSqlite3Open = rb_define_module_under(mSqlite3Constants, "Open");
+
+  /* symbols = IO.readlines('sqlite3.h').map { |n| /\A#define\s+(SQLITE_OPEN_\w+)\s/ =~ n && $1 }.compact
+   * pad = symbols.map(&:length).max - 9
+   * symbols.each { |s| printf %Q{  rb_define_const(mSqlite3Open, %-#{pad}s INT2FIX(#{s}));\n}, '"' + s[12..-1] + '",' }
+   */
+  rb_define_const(mSqlite3Open, "READONLY",       INT2FIX(SQLITE_OPEN_READONLY));
+  rb_define_const(mSqlite3Open, "READWRITE",      INT2FIX(SQLITE_OPEN_READWRITE));
+  rb_define_const(mSqlite3Open, "CREATE",         INT2FIX(SQLITE_OPEN_CREATE));
+  rb_define_const(mSqlite3Open, "DELETEONCLOSE",  INT2FIX(SQLITE_OPEN_DELETEONCLOSE));
+  rb_define_const(mSqlite3Open, "EXCLUSIVE",      INT2FIX(SQLITE_OPEN_EXCLUSIVE));
+  rb_define_const(mSqlite3Open, "MAIN_DB",        INT2FIX(SQLITE_OPEN_MAIN_DB));
+  rb_define_const(mSqlite3Open, "TEMP_DB",        INT2FIX(SQLITE_OPEN_TEMP_DB));
+  rb_define_const(mSqlite3Open, "TRANSIENT_DB",   INT2FIX(SQLITE_OPEN_TRANSIENT_DB));
+  rb_define_const(mSqlite3Open, "MAIN_JOURNAL",   INT2FIX(SQLITE_OPEN_MAIN_JOURNAL));
+  rb_define_const(mSqlite3Open, "TEMP_JOURNAL",   INT2FIX(SQLITE_OPEN_TEMP_JOURNAL));
+  rb_define_const(mSqlite3Open, "SUBJOURNAL",     INT2FIX(SQLITE_OPEN_SUBJOURNAL));
+  rb_define_const(mSqlite3Open, "MASTER_JOURNAL", INT2FIX(SQLITE_OPEN_MASTER_JOURNAL));
+  rb_define_const(mSqlite3Open, "NOMUTEX",        INT2FIX(SQLITE_OPEN_NOMUTEX));
+  rb_define_const(mSqlite3Open, "FULLMUTEX",      INT2FIX(SQLITE_OPEN_FULLMUTEX));
+#ifdef SQLITE_OPEN_AUTOPROXY
+  /* SQLITE_VERSION_NUMBER>=3007002 */
+  rb_define_const(mSqlite3Open, "AUTOPROXY",      INT2FIX(SQLITE_OPEN_AUTOPROXY));
+  rb_define_const(mSqlite3Open, "SHAREDCACHE",    INT2FIX(SQLITE_OPEN_SHAREDCACHE));
+  rb_define_const(mSqlite3Open, "PRIVATECACHE",   INT2FIX(SQLITE_OPEN_PRIVATECACHE));
+  rb_define_const(mSqlite3Open, "WAL",            INT2FIX(SQLITE_OPEN_WAL));
+#endif
+#ifdef SQLITE_OPEN_URI
+  /* SQLITE_VERSION_NUMBER>=3007007 */
+  rb_define_const(mSqlite3Open, "URI",            INT2FIX(SQLITE_OPEN_URI));
+#endif
+#ifdef SQLITE_OPEN_MEMORY
+  /* SQLITE_VERSION_NUMBER>=3007013 */
+  rb_define_const(mSqlite3Open, "MEMORY",         INT2FIX(SQLITE_OPEN_MEMORY));
+#endif
+}
+
 void Init_sqlite3_native()
 {
   /*
@@ -28,6 +138,7 @@ void Init_sqlite3_native()
   sqlite3_initialize();
 #endif
 
+  init_sqlite3_constants();
   init_sqlite3_database();
   init_sqlite3_statement();
 #ifdef HAVE_SQLITE3_BACKUP_INIT
@@ -35,6 +146,7 @@ void Init_sqlite3_native()
 #endif
 
   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));
 }

data/ext/sqlite3/sqlite3_ruby.h

@@ -12,15 +12,13 @@
 # define UNUSED(x) x
 #endif
 
-#ifndef RBIGNUM_LEN
-#define RBIGNUM_LEN(x) RBIGNUM(x)->len
-#endif
-
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
 
+#define USASCII_P(_obj) (rb_enc_get_index(_obj) == rb_usascii_encindex())
 #define UTF8_P(_obj) (rb_enc_get_index(_obj) == rb_utf8_encindex())
 #define UTF16_LE_P(_obj) (rb_enc_get_index(_obj) == rb_enc_find_index("UTF-16LE"))
+#define UTF16_BE_P(_obj) (rb_enc_get_index(_obj) == rb_enc_find_index("UTF-16BE"))
 #define SQLITE3_UTF8_STR_NEW2(_obj) \
     (rb_enc_associate_index(rb_str_new2(_obj), rb_utf8_encindex()))
 
@@ -33,6 +31,14 @@
 
 #include <sqlite3.h>
 
+#ifndef HAVE_TYPE_SQLITE3_INT64
+typedef sqlite_int64 sqlite3_int64;
+#endif
+
+#ifndef HAVE_TYPE_SQLITE3_UINT64
+typedef sqlite_uint64 sqlite3_uint64;
+#endif
+
 extern VALUE mSqlite3;
 extern VALUE cSqlite3Blob;
 
@@ -41,4 +47,6 @@ extern VALUE cSqlite3Blob;
 #include <exception.h>
 #include <backup.h>
 
+int bignum_to_int64(VALUE big, sqlite3_int64 *result);
+
 #endif

data/ext/sqlite3/statement.c

@@ -49,7 +49,11 @@ static VALUE initialize(VALUE self, VALUE db, VALUE sql)
   }
 #endif
 
+#ifdef HAVE_SQLITE3_PREPARE_V2
   status = sqlite3_prepare_v2(
+#else
+  status = sqlite3_prepare(
+#endif
       db_ctx->db,
       (const char *)StringValuePtr(sql),
       (int)RSTRING_LEN(sql),
@@ -75,15 +79,12 @@ static VALUE initialize(VALUE self, VALUE db, VALUE sql)
 static VALUE sqlite3_rb_close(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
-  sqlite3 * db;
 
   Data_Get_Struct(self, sqlite3StmtRuby, ctx);
 
   REQUIRE_OPEN_STMT(ctx);
 
-  db = sqlite3_db_handle(ctx->st);
-  CHECK(db, sqlite3_finalize(ctx->st));
-
+  sqlite3_finalize(ctx->st);
   ctx->st = NULL;
 
   return self;
@@ -111,7 +112,6 @@ static VALUE step(VALUE self)
   VALUE list;
 #ifdef HAVE_RUBY_ENCODING_H
   rb_encoding * internal_encoding;
-  int enc_index;
 #endif
 
   Data_Get_Struct(self, sqlite3StmtRuby, ctx);
@@ -123,8 +123,7 @@ static VALUE step(VALUE self)
 #ifdef HAVE_RUBY_ENCODING_H
   {
       VALUE db          = rb_iv_get(self, "@connection");
-      VALUE encoding    = rb_funcall(db, rb_intern("encoding"), 0);
-      enc_index = NIL_P(encoding) ? rb_utf8_encindex() : rb_to_encoding_index(encoding);
+      rb_funcall(db, rb_intern("encoding"), 0);
       internal_encoding = rb_default_internal_encoding();
   }
 #endif
@@ -154,7 +153,7 @@ static VALUE step(VALUE self)
                     (long)sqlite3_column_bytes(stmt, i)
                 );
 #ifdef HAVE_RUBY_ENCODING_H
-                rb_enc_associate_index(str, enc_index);
+                rb_enc_associate_index(str, rb_utf8_encindex());
                 if(internal_encoding)
                   str = rb_str_export_to_enc(str, internal_encoding);
 #endif
@@ -184,6 +183,8 @@ static VALUE step(VALUE self)
       return Qnil;
       break;
     default:
+      sqlite3_reset(stmt);
+      ctx->done_p = 0;
       CHECK(sqlite3_db_handle(ctx->st), value);
   }
 
@@ -236,15 +237,22 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
             SQLITE_TRANSIENT
             );
       } else {
+
+
 #ifdef HAVE_RUBY_ENCODING_H
-        if(!UTF8_P(value)) {
-              VALUE db          = rb_iv_get(self, "@connection");
-              VALUE encoding    = rb_funcall(db, rb_intern("encoding"), 0);
-              rb_encoding * enc = rb_to_encoding(encoding);
-              value = rb_str_export_to_enc(value, enc);
+        if (UTF16_LE_P(value) || UTF16_BE_P(value)) {
+          status = sqlite3_bind_text16(
+              ctx->st,
+              index,
+              (const char *)StringValuePtr(value),
+              (int)RSTRING_LEN(value),
+              SQLITE_TRANSIENT
+              );
+        } else {
+          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,
@@ -252,13 +260,18 @@ 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:
-      if (RBIGNUM_LEN(value) * SIZEOF_BDIGITS <= 8) {
-          status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)NUM2LL(value));
+    case T_BIGNUM: {
+      sqlite3_int64 num64;
+      if (bignum_to_int64(value, &num64)) {
+          status = sqlite3_bind_int64(ctx->st, index, num64);
           break;
       }
+    }
     case T_FLOAT:
       status = sqlite3_bind_double(ctx->st, index, NUM2DBL(value));
       break;
@@ -287,12 +300,11 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
 static VALUE reset_bang(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
-  int status;
 
   Data_Get_Struct(self, sqlite3StmtRuby, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
-  status = sqlite3_reset(ctx->st);
+  sqlite3_reset(ctx->st);
 
   ctx->done_p = 0;
 
@@ -307,12 +319,11 @@ static VALUE reset_bang(VALUE self)
 static VALUE clear_bindings(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
-  int status;
 
   Data_Get_Struct(self, sqlite3StmtRuby, ctx);
   REQUIRE_OPEN_STMT(ctx);
 
-  status = sqlite3_clear_bindings(ctx->st);
+  sqlite3_clear_bindings(ctx->st);
 
   ctx->done_p = 0;
 
@@ -359,7 +370,7 @@ static VALUE column_name(VALUE self, VALUE index)
 
   name = sqlite3_column_name(ctx->st, (int)NUM2INT(index));
 
-  if(name) return rb_str_new2(name);
+  if(name) return SQLITE3_UTF8_STR_NEW2(name);
   return Qnil;
 }
 

data/faq/faq.yml

@@ -331,7 +331,7 @@
       p obj == h
     </pre>
 
-- "How do insert binary data into the database?": >-
+- "How do I insert binary data into the database?": >-
     Use blobs. Blobs are new features of SQLite3. You have to use bind
     variables to make it work:
 

data/lib/sqlite3.rb

@@ -1,6 +1,6 @@
 # support multiple ruby version (fat binaries under windows)
 begin
-  RUBY_VERSION =~ /(\d+.\d+)/
+  RUBY_VERSION =~ /(\d+\.\d+)/
   require "sqlite3/#{$1}/sqlite3_native"
 rescue LoadError
   require 'sqlite3/sqlite3_native'
@@ -8,3 +8,8 @@ end
 
 require 'sqlite3/database'
 require 'sqlite3/version'
+
+module SQLite3
+  # Was sqlite3 compiled with thread safety on?
+  def self.threadsafe?; threadsafe > 0; end
+end

data/lib/sqlite3/database.rb

@@ -94,10 +94,17 @@ in version 2.0.0.
       begin
         yield stmt
       ensure
-        stmt.close
+        stmt.close unless stmt.closed?
       end
     end
 
+    # Returns the filename for the database named +db_name+.  +db_name+ defaults
+    # to "main".  Main return `nil` or an empty string if the database is
+    # temporary or in-memory.
+    def filename db_name = 'main'
+      db_filename db_name
+    end
+
     # Executes the given SQL statement. If additional parameters are given,
     # they are treated as bind variables, and are bound to the placeholders in
     # the query.
@@ -113,10 +120,6 @@ in version 2.0.0.
     # See also #execute2, #query, and #execute_batch for additional ways of
     # executing statements.
     def execute sql, bind_vars = [], *args, &block
-      # FIXME: This is a terrible hack and should be removed but is required
-      # for older versions of rails
-      hack = Object.const_defined?(:ActiveRecord) && sql =~ /^PRAGMA index_list/
-
       if bind_vars.nil? || !args.empty?
         if args.empty?
           bind_vars = []
@@ -147,12 +150,7 @@ Support for bind parameters as *args will be removed in 2.0.0.
         else
           if @results_as_hash
             stmt.map { |row|
-              h = type_translation ? row : ordered_map_for(columns, row)
-
-              # FIXME UGH TERRIBLE HACK!
-              h['unique'] = h['unique'].to_s if hack
-
-              h
+              type_translation ? row : ordered_map_for(columns, row)
             }
           else
             stmt.to_a
@@ -221,22 +219,25 @@ Support for this behavior will be removed in version 2.0.0.
       sql = sql.strip
       until sql.empty? do
         prepare( sql ) do |stmt|
-          # FIXME: this should probably use sqlite3's api for batch execution
-          # This implementation requires stepping over the results.
-          if bind_vars.length == stmt.bind_parameter_count
-            stmt.bind_params(bind_vars)
+          unless stmt.closed?
+            # FIXME: this should probably use sqlite3's api for batch execution
+            # This implementation requires stepping over the results.
+            if bind_vars.length == stmt.bind_parameter_count
+              stmt.bind_params(bind_vars)
+            end
+            stmt.step
           end
-          stmt.step
           sql = stmt.remainder.strip
         end
       end
+      # FIXME: we should not return `nil` as a success return value
       nil
     end
 
     # This is a convenience method for creating a statement, binding
     # paramters to it, and calling execute:
     #
-    #   result = db.query( "select * from foo where a=?", 5 )
+    #   result = db.query( "select * from foo where a=?", [5])
     #   # is the same as
     #   result = db.prepare( "select * from foo where a=?" ).execute( 5 )
     #
@@ -250,7 +251,7 @@ Support for this behavior will be removed in version 2.0.0.
         if args.empty?
           bind_vars = []
         else
-          bind_vars = [nil] + args
+          bind_vars = [bind_vars] + args
         end
 
         warn(<<-eowarn) if $VERBOSE
@@ -392,6 +393,9 @@ Support for this will be removed in version 2.0.0.
 
         def finalize
           super(@ctx)
+          result = @ctx.result
+          @ctx = FunctionProxy.new
+          result
         end
       })
       proxy.ctx = FunctionProxy.new
@@ -428,6 +432,7 @@ Support for this will be removed in version 2.0.0.
     #
     #   class LengthsAggregateHandler
     #     def self.arity; 1; end
+    #     def self.name; 'lengths'; end
     #
     #     def initialize
     #       @total = 0
@@ -446,21 +451,28 @@ Support for this will be removed in version 2.0.0.
     #   puts db.get_first_value( "select lengths(name) from A" )
     def create_aggregate_handler( handler )
       proxy = Class.new do
-        def initialize handler
-          @handler  = handler
-          @fp       = FunctionProxy.new
+        def initialize klass
+          @klass = klass
+          @fp    = FunctionProxy.new
         end
 
         def step( *args )
-          @handler.step(@fp, *args)
+          instance.step(@fp, *args)
         end
 
         def finalize
-          @handler.finalize @fp
+          instance.finalize @fp
+          @instance = nil
           @fp.result
         end
+
+        private
+
+        def instance
+          @instance ||= @klass.new
+        end
       end
-      define_aggregator(handler.name, proxy.new(handler.new))
+      define_aggregator(handler.name, proxy.new(handler))
       self
     end