sqlite3 1.3.7 → 1.3.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b430789a68a6d6079e0395db6fc53421e4b317ab
+  data.tar.gz: db014f4a1f4e980913a3dcb48d9aab14a5a9eca1
+SHA512:
+  metadata.gz: 7e2764239b107677240476bb608bcb46cc0966c06d06e90881113b91dbdb8342c6c7558760cf0645a56449ac8e267f13a0e25dbef0d3e820a38f5857a96c4e05
+  data.tar.gz: 1e08a478ed043d22bbe95df2151bf009a7f03a1457c37df4199c8601fa1ccb9de27986e64341c4fb9a009e5ab4023638704078222f88441b55ac1ee2773838d8

data/CHANGELOG.rdoc

@@ -1,7 +1,51 @@
-=== 1.3.7
+=== 1.3.12
+
+* Bugfixes:
+  * OS X install will default to homebrew if available. Fixes #195
+
+=== 1.3.11 / 2015-10-10
+
+* Enhancements:
+  * Windows: build against SQLite 3.8.11.1
+
+* Internal:
+  * Use rake-compiler-dock to build Windows binaries. Pull #159 [larskanis]
+  * Expand Ruby versions being tested for Travis and AppVeyor
+
+=== 1.3.10 / 2014-10-30
+
+* Enhancements:
+  * Windows: build against SQLite 3.8.7.1. Closes #134, #135 [Hubro]
+
+=== 1.3.9 / 2014-02-25
+
+* Bugfixes:
+  * Reset exception message. Closes #80
+  * Reduce warnings due unused pointers. Closes #89
+  * Add BSD-3 license reference to gemspec. Refs #99 and #106
+
+=== 1.3.8 / 2013-08-17
+
+* Enhancements:
+  * Windows: build against SQLite 3.7.17
+
+* Bugfixes:
+  * Reset exception message. Closes #80
+  * Correctly convert BLOB values to Ruby. Closes #65
+  * Add MIT license reference to gemspec. Closes #99
+  * Remove unused pointer. Closes #89
+
+* Internal:
+  * Backport improvements in cross compilation for Windows
+  * Use of Minitest for internal tests
+  * Use Gemfile (generated by Hoe) to deal with dependencies
+  * Cleanup Travis CI
+
+=== 1.3.7 / 2013-01-11
 
 * Bugfixes
   * Closing a bad statement twice will not segv.
+  * Aggregate handlers are initialized on each query. Closes #44
 
 * Internal
   * Unset environment variables that could affect cross compilation.

data/Gemfile

@@ -0,0 +1,15 @@
+# -*- ruby -*-
+
+# DO NOT EDIT THIS FILE. Instead, edit Rakefile, and run `rake bundler:gemfile`.
+
+source "https://rubygems.org/"
+
+
+gem "minitest", "~>5.9", :group => [:development, :test]
+gem "rake-compiler", "~>0.9.3", :group => [:development, :test]
+gem "rake-compiler-dock", "~>0.5.2", :group => [:development, :test]
+gem "mini_portile", "~>0.6.2", :group => [:development, :test]
+gem "hoe-bundler", "~>1.0", :group => [:development, :test]
+gem "hoe", "~>3.15", :group => [:development, :test]
+
+# vim: syntax=ruby

data/Manifest.txt

@@ -1,6 +1,7 @@
 API_CHANGES.rdoc
 CHANGELOG.rdoc
 ChangeLog.cvs
+Gemfile
 LICENSE
 Manifest.txt
 README.rdoc
@@ -45,6 +46,7 @@ test/test_integration_open_close.rb
 test/test_integration_pending.rb
 test/test_integration_resultset.rb
 test/test_integration_statement.rb
+test/test_result_set.rb
 test/test_sqlite3.rb
 test/test_statement.rb
 test/test_statement_execute.rb

data/README.rdoc

@@ -1,7 +1,11 @@
 = SQLite3/Ruby Interface
 
-* http://github.com/luislavena/sqlite3-ruby
+* https://github.com/sparklemotion/sqlite3-ruby
 * http://groups.google.com/group/sqlite3-ruby
+* http://rubygems.org/gems/sqlite3
+* http://www.rubydoc.info/gems/sqlite3/frames
+
+{<img src="https://travis-ci.org/sparklemotion/sqlite3-ruby.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/sparklemotion/sqlite3-ruby]
 
 == DESCRIPTION
 
@@ -18,7 +22,7 @@ Note that this module is only compatible with SQLite 3.6.16 or newer.
   # Open a database
   db = SQLite3::Database.new "test.db"
   
-  # Create a database
+  # Create a table
   rows = db.execute <<-SQL
     create table numbers (
       name varchar(30),
@@ -33,12 +37,31 @@ Note that this module is only compatible with SQLite 3.6.16 or newer.
   }.each do |pair|
     db.execute "insert into numbers values ( ?, ? )", pair
   end
-  
+
   # Find a few rows
   db.execute( "select * from numbers" ) do |row|
     p row
   end
 
+  # Create another table with multiple columns
+
+  db.execute <<-SQL
+    create table students (
+      name varchar(50),
+      email varchar(50),
+      grade varchar(5),
+      blog varchar(50)
+    );
+  SQL
+
+  # Execute inserts with parameter markers
+  db.execute("INSERT INTO students (name, email, grade, blog) 
+              VALUES (?, ?, ?, ?)", ["Jane", "me@janedoe.com", "A", "http://blog.janedoe.com"])
+  
+  db.execute( "select * from students" ) do |row|
+    p row
+  end
+
 
 == Compilation and Installation
 
@@ -75,10 +98,10 @@ can be found here:
 
 Uh oh.  After contacting the mailing list, you've found that you've actually
 discovered a bug.  You can file the bug at the
-{github issues page}[http://github.com/luislavena/sqlite3-ruby/issues]
+{github issues page}[https://github.com/sparklemotion/sqlite3-ruby/issues]
 which can be found here:
 
-  * http://github.com/luislavena/sqlite3-ruby/issues
+  * https://github.com/sparklemotion/sqlite3-ruby/issues
 
 == Usage
 
@@ -91,5 +114,5 @@ FAQ, please send them to {the mailing list}[http://groups.google.com/group/sqlit
 
 The source repository is accessible via git:
 
-  git clone git://github.com/luislavena/sqlite3-ruby.git
+  git clone git://github.com/sparklemotion/sqlite3-ruby.git
 

data/ext/sqlite3/database.c

@@ -30,6 +30,8 @@ utf16_string_value_ptr(VALUE str)
   return RSTRING_PTR(str);
 }
 
+static VALUE sqlite3_rb_close(VALUE self);
+
 /* call-seq: SQLite3::Database.new(file, options = {})
  *
  * Create a new Database object that opens the given file. If utf16
@@ -44,6 +46,7 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self)
   VALUE file;
   VALUE opts;
   VALUE zvfs;
+  VALUE flags;
 #ifdef HAVE_SQLITE3_OPEN_V2
   int mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
 #endif
@@ -77,11 +80,37 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self)
       }
 #endif
 
+      /* The three primary flag values for sqlite3_open_v2 are:
+       * SQLITE_OPEN_READONLY
+       * SQLITE_OPEN_READWRITE
+       * SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE -- always used for sqlite3_open and sqlite3_open16
+       */
       if (Qtrue == rb_hash_aref(opts, ID2SYM(rb_intern("readonly")))) {
 #ifdef HAVE_SQLITE3_OPEN_V2
         mode = SQLITE_OPEN_READONLY;
 #else
         rb_raise(rb_eNotImpError, "sqlite3-ruby was compiled against a version of sqlite that does not support readonly databases");
+#endif
+      }
+      if (Qtrue == rb_hash_aref(opts, ID2SYM(rb_intern("readwrite")))) {
+#ifdef HAVE_SQLITE3_OPEN_V2
+        if (mode == SQLITE_OPEN_READONLY) {
+            rb_raise(rb_eRuntimeError, "conflicting options: readonly and readwrite");
+        }
+        mode = SQLITE_OPEN_READWRITE;
+#else
+        rb_raise(rb_eNotImpError, "sqlite3-ruby was compiled against a version of sqlite that does not support readwrite without create");
+#endif
+      }
+      flags = rb_hash_aref(opts, ID2SYM(rb_intern("flags")));
+      if (flags != Qnil) {
+#ifdef HAVE_SQLITE3_OPEN_V2
+        if ((mode & SQLITE_OPEN_CREATE) == 0) {
+            rb_raise(rb_eRuntimeError, "conflicting options: flags with readonly and/or readwrite");
+        }
+        mode = (int)NUM2INT(flags);
+#else
+        rb_raise(rb_eNotImpError, "sqlite3-ruby was compiled against a version of sqlite that does not support flags on open");
 #endif
       }
 #ifdef HAVE_SQLITE3_OPEN_V2
@@ -114,14 +143,13 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self)
   rb_iv_set(self, "@results_as_hash", rb_hash_aref(opts, sym_results_as_hash));
   rb_iv_set(self, "@type_translation", rb_hash_aref(opts, sym_type_translation));
 #ifdef HAVE_SQLITE3_OPEN_V2
-  rb_iv_set(self, "@readonly", mode == SQLITE_OPEN_READONLY ? Qtrue : Qfalse);
+  rb_iv_set(self, "@readonly", (mode & SQLITE_OPEN_READONLY) ? Qtrue : Qfalse);
 #else
   rb_iv_set(self, "@readonly", Qfalse);
 #endif
 
   if(rb_block_given_p()) {
-    rb_yield(self);
-    rb_funcall(self, rb_intern("close"), 0);
+    rb_ensure(rb_yield, self, sqlite3_rb_close, self);
   }
 
   return self;
@@ -281,9 +309,23 @@ static VALUE sqlite3val2rb(sqlite3_value * val)
     case SQLITE_TEXT:
       return rb_tainted_str_new2((const char *)sqlite3_value_text(val));
       break;
-    case SQLITE_BLOB:
-      return rb_tainted_str_new2((const char *)sqlite3_value_blob(val));
+    case SQLITE_BLOB: {
+      /* Sqlite warns calling sqlite3_value_bytes may invalidate pointer from sqlite3_value_blob,
+         so we explicitly get the length before getting blob pointer.
+         Note that rb_str_new and rb_tainted_str_new apparently create string with ASCII-8BIT (BINARY) encoding,
+         which is what we want, as blobs are binary
+       */
+      int len = sqlite3_value_bytes(val);
+#ifdef HAVE_RUBY_ENCODING_H
+      return rb_tainted_str_new((const char *)sqlite3_value_blob(val), len);
+#else
+      /* When encoding is not available, make it class SQLite3::Blob. */
+      VALUE strargv[1];
+      strargv[0] = rb_tainted_str_new((const char *)sqlite3_value_blob(val), len);
+      return rb_class_new_instance(1, strargv, cSqlite3Blob);
+#endif
       break;
+    }
     case SQLITE_NULL:
       return Qnil;
       break;
@@ -301,23 +343,39 @@ static void set_sqlite3_func_result(sqlite3_context * ctx, VALUE result)
     case T_FIXNUM:
       sqlite3_result_int64(ctx, (sqlite3_int64)FIX2LONG(result));
       break;
-    case T_BIGNUM:
+    case T_BIGNUM: {
 #if SIZEOF_LONG < 8
-      if (RBIGNUM_LEN(result) * SIZEOF_BDIGITS <= 8) {
-          sqlite3_result_int64(ctx, NUM2LL(result));
-          break;
+      sqlite3_int64 num64;
+
+      if (bignum_to_int64(result, &num64)) {
+	  sqlite3_result_int64(ctx, num64);
+	  break;
       }
 #endif
+    }
     case T_FLOAT:
       sqlite3_result_double(ctx, NUM2DBL(result));
       break;
     case T_STRING:
-      sqlite3_result_text(
-          ctx,
-          (const char *)StringValuePtr(result),
-          (int)RSTRING_LEN(result),
-          SQLITE_TRANSIENT
-      );
+      if(CLASS_OF(result) == cSqlite3Blob
+#ifdef HAVE_RUBY_ENCODING_H
+              || rb_enc_get_index(result) == rb_ascii8bit_encindex()
+#endif
+        ) {
+        sqlite3_result_blob(
+            ctx,
+            (const void *)StringValuePtr(result),
+            (int)RSTRING_LEN(result),
+            SQLITE_TRANSIENT
+        );
+      } else {
+        sqlite3_result_text(
+            ctx,
+            (const char *)StringValuePtr(result),
+            (int)RSTRING_LEN(result),
+            SQLITE_TRANSIENT
+        );
+      }
       break;
     default:
       rb_raise(rb_eRuntimeError, "can't return %s",
@@ -328,22 +386,18 @@ static void set_sqlite3_func_result(sqlite3_context * ctx, VALUE result)
 static void rb_sqlite3_func(sqlite3_context * ctx, int argc, sqlite3_value **argv)
 {
   VALUE callable = (VALUE)sqlite3_user_data(ctx);
-  VALUE * params = NULL;
+  VALUE params = rb_ary_new2(argc);
   VALUE result;
   int i;
 
   if (argc > 0) {
-    params = xcalloc((size_t)argc, sizeof(VALUE *));
-
     for(i = 0; i < argc; i++) {
       VALUE param = sqlite3val2rb(argv[i]);
-      RB_GC_GUARD(param);
-      params[i] = param;
+      rb_ary_push(params, param);
     }
   }
 
-  result = rb_funcall2(callable, rb_intern("call"), argc, params);
-  xfree(params);
+  result = rb_apply(callable, rb_intern("call"), params);
 
   set_sqlite3_func_result(ctx, result);
 }
@@ -768,6 +822,24 @@ static VALUE transaction_active_p(VALUE self)
   return sqlite3_get_autocommit(ctx->db) ? Qfalse : Qtrue;
 }
 
+/* call-seq: db.db_filename(database_name)
+ *
+ * Returns the file associated with +database_name+.  Can return nil or an
+ * empty string if the database is temporary, or in-memory.
+ */
+static VALUE db_filename(VALUE self, VALUE db_name)
+{
+  sqlite3RubyPtr ctx;
+  const char * fname;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  fname = sqlite3_db_filename(ctx->db, StringValueCStr(db_name));
+
+  if(fname) return SQLITE3_UTF8_STR_NEW2(fname);
+  return Qnil;
+}
+
 void init_sqlite3_database()
 {
   ID id_utf16, id_results_as_hash, id_type_translation;
@@ -795,6 +867,7 @@ void init_sqlite3_database()
   rb_define_method(cSqlite3Database, "busy_handler", busy_handler, -1);
   rb_define_method(cSqlite3Database, "busy_timeout=", set_busy_timeout, 1);
   rb_define_method(cSqlite3Database, "transaction_active?", transaction_active_p, 0);
+  rb_define_private_method(cSqlite3Database, "db_filename", db_filename, 1);
 
 #ifdef HAVE_SQLITE3_LOAD_EXTENSION
   rb_define_method(cSqlite3Database, "load_extension", load_extension, 1);

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", "")
+
+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,19 +39,24 @@ 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')

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,13 +12,10 @@
 # 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"))
@@ -50,4 +47,6 @@ extern VALUE cSqlite3Blob;
 #include <exception.h>
 #include <backup.h>
 
+int bignum_to_int64(VALUE big, sqlite3_int64 *result);
+
 #endif