Hello community,

here is the log from the commit of package rubygem-sqlite3 for openSUSE:Factory 
checked in at 2016-10-18 10:40:34
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/rubygem-sqlite3 (Old)
 and      /work/SRC/openSUSE:Factory/.rubygem-sqlite3.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "rubygem-sqlite3"

Changes:
--------
--- /work/SRC/openSUSE:Factory/rubygem-sqlite3/rubygem-sqlite3.changes  
2015-10-14 16:44:55.000000000 +0200
+++ /work/SRC/openSUSE:Factory/.rubygem-sqlite3.new/rubygem-sqlite3.changes     
2016-10-18 10:40:34.000000000 +0200
@@ -1,0 +2,11 @@
+Sun Oct  9 04:36:48 UTC 2016 - co...@suse.com
+
+- updated to version 1.3.12
+ see installed CHANGELOG.rdoc
+
+  === 1.3.12
+  
+  * Bugfixes:
+    * OS X install will default to homebrew if available. Fixes #195
+
+-------------------------------------------------------------------

Old:
----
  sqlite3-1.3.11.gem

New:
----
  sqlite3-1.3.12.gem

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ rubygem-sqlite3.spec ++++++
--- /var/tmp/diff_new_pack.DtPEeJ/_old  2016-10-18 10:40:35.000000000 +0200
+++ /var/tmp/diff_new_pack.DtPEeJ/_new  2016-10-18 10:40:35.000000000 +0200
@@ -1,7 +1,7 @@
 #
 # spec file for package rubygem-sqlite3
 #
-# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany.
 #
 # All modifications and additions to the file contributed by third parties
 # remain the property of their copyright owners, unless otherwise agreed
@@ -24,7 +24,7 @@
 #
 
 Name:           rubygem-sqlite3
-Version:        1.3.11
+Version:        1.3.12
 Release:        0
 %define mod_name sqlite3
 %define mod_full_name %{mod_name}-%{version}

++++++ sqlite3-1.3.11.gem -> sqlite3-1.3.12.gem ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/CHANGELOG.rdoc new/CHANGELOG.rdoc
--- old/CHANGELOG.rdoc  2015-10-10 23:20:32.000000000 +0200
+++ new/CHANGELOG.rdoc  2016-10-09 03:02:02.000000000 +0200
@@ -1,3 +1,8 @@
+=== 1.3.12
+
+* Bugfixes:
+  * OS X install will default to homebrew if available. Fixes #195
+
 === 1.3.11 / 2015-10-10
 
 * Enhancements:
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/Gemfile new/Gemfile
--- old/Gemfile 2015-10-10 23:20:32.000000000 +0200
+++ new/Gemfile 2016-10-09 03:02:02.000000000 +0200
@@ -5,12 +5,11 @@
 source "https://rubygems.org/";
 
 
-gem "minitest", "~>5.8", :group => [:development, :test]
-gem "rdoc", "~>4.0", :group => [:development, :test]
+gem "minitest", "~>5.9", :group => [:development, :test]
 gem "rake-compiler", "~>0.9.3", :group => [:development, :test]
-gem "rake-compiler-dock", "~>0.4.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.14", :group => [:development, :test]
+gem "hoe", "~>3.15", :group => [:development, :test]
 
 # vim: syntax=ruby
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/README.rdoc new/README.rdoc
--- old/README.rdoc     2015-10-10 23:20:32.000000000 +0200
+++ new/README.rdoc     2016-10-09 03:02:02.000000000 +0200
@@ -5,6 +5,8 @@
 * 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
 
 This module allows Ruby programs to interface with the SQLite3
@@ -20,7 +22,7 @@
   # 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),
@@ -36,12 +38,27 @@
     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 (?, ?, ?, ?)", [@name, @email, @grade, @blog])
+              VALUES (?, ?, ?, ?)", ["Jane", "m...@janedoe.com", "A", 
"http://blog.janedoe.com";])
   
-  # Find a few rows
-  db.execute( "select * from numbers" ) do |row|
+  db.execute( "select * from students" ) do |row|
     p row
   end
 
Files old/checksums.yaml.gz and new/checksums.yaml.gz differ
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/ext/sqlite3/database.c new/ext/sqlite3/database.c
--- old/ext/sqlite3/database.c  2015-10-10 23:20:32.000000000 +0200
+++ new/ext/sqlite3/database.c  2016-10-09 03:02:02.000000000 +0200
@@ -30,6 +30,8 @@
   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
@@ -45,6 +47,7 @@
   VALUE opts;
   VALUE zvfs;
 #ifdef HAVE_SQLITE3_OPEN_V2
+  VALUE flags;
   int mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
 #endif
   int status;
@@ -77,6 +80,11 @@
       }
 #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;
@@ -84,6 +92,27 @@
         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
       status = sqlite3_open_v2(
           StringValuePtr(file),
@@ -114,14 +143,13 @@
   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;
@@ -288,7 +316,14 @@
          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:
@@ -322,12 +357,25 @@
       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",
@@ -338,22 +386,18 @@
 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);
 }
@@ -778,6 +822,24 @@
   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;
@@ -805,6 +867,7 @@
   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);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/ext/sqlite3/extconf.rb new/ext/sqlite3/extconf.rb
--- old/ext/sqlite3/extconf.rb  2015-10-10 23:20:32.000000000 +0200
+++ new/ext/sqlite3/extconf.rb  2016-10-09 03:02:02.000000000 +0200
@@ -6,8 +6,28 @@
 
 RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
+
+
+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
+
+    # 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")
+dir_config("sqlite3", cppflags, ldflags)
 
 if RbConfig::CONFIG["host_os"] =~ /mswin/
   $CFLAGS << ' -W3'
@@ -19,7 +39,7 @@
           "http://www.sqlite.org/ first."
   else
     abort <<-error
-#{missing} is missing. Try 'port install sqlite3 +universal',
+#{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).
@@ -28,6 +48,7 @@
 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
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/ext/sqlite3/sqlite3.c new/ext/sqlite3/sqlite3.c
--- old/ext/sqlite3/sqlite3.c   2015-10-10 23:20:32.000000000 +0200
+++ new/ext/sqlite3/sqlite3.c   2016-10-09 03:02:02.000000000 +0200
@@ -65,6 +65,59 @@
   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()
 {
   /*
@@ -85,6 +138,7 @@
   sqlite3_initialize();
 #endif
 
+  init_sqlite3_constants();
   init_sqlite3_database();
   init_sqlite3_statement();
 #ifdef HAVE_SQLITE3_BACKUP_INIT
@@ -92,6 +146,7 @@
 #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));
 }
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/lib/sqlite3/database.rb new/lib/sqlite3/database.rb
--- old/lib/sqlite3/database.rb 2015-10-10 23:20:32.000000000 +0200
+++ new/lib/sqlite3/database.rb 2016-10-09 03:02:02.000000000 +0200
@@ -98,6 +98,13 @@
       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 @@
     # 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 @@
         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
@@ -395,6 +393,9 @@
 
         def finalize
           super(@ctx)
+          result = @ctx.result
+          @ctx = FunctionProxy.new
+          result
         end
       })
       proxy.ctx = FunctionProxy.new
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/lib/sqlite3/pragmas.rb new/lib/sqlite3/pragmas.rb
--- old/lib/sqlite3/pragmas.rb  2015-10-10 23:20:32.000000000 +0200
+++ new/lib/sqlite3/pragmas.rb  2016-10-09 03:02:02.000000000 +0200
@@ -13,7 +13,6 @@
     def get_boolean_pragma( name )
       get_first_value( "PRAGMA #{name}" ) != "0"
     end
-    private :get_boolean_pragma
 
     # Sets the given pragma to the given boolean value. The value itself
     # may be +true+ or +false+, or any other commonly used string or
@@ -39,7 +38,6 @@
 
       execute( "PRAGMA #{name}=#{mode}" )
     end
-    private :set_boolean_pragma
 
     # Requests the given pragma (and parameters), and if the block is given,
     # each row of the result set will be yielded to it. Otherwise, the results
@@ -52,13 +50,11 @@
         execute( "PRAGMA #{name}( #{args} )", &block )
       end
     end
-    private :get_query_pragma
 
     # Return the value of the given pragma.
     def get_enum_pragma( name )
       get_first_value( "PRAGMA #{name}" )
     end
-    private :get_enum_pragma
 
     # Set the value of the given pragma to +mode+. The +mode+ parameter must
     # conform to one of the values in the given +enum+ array. Each entry in
@@ -71,20 +67,17 @@
         "unrecognized #{name} #{mode.inspect}" unless match
       execute( "PRAGMA #{name}='#{match.first.upcase}'" )
     end
-    private :set_enum_pragma
 
     # Returns the value of the given pragma as an integer.
     def get_int_pragma( name )
       get_first_value( "PRAGMA #{name}" ).to_i
     end
-    private :get_int_pragma
 
     # Set the value of the given pragma to the integer value of the +value+
     # parameter.
     def set_int_pragma( name, value )
       execute( "PRAGMA #{name}=#{value.to_i}" )
     end
-    private :set_int_pragma
 
     # The enumeration of valid synchronous modes.
     SYNCHRONOUS_MODES = [ [ 'full', 2 ], [ 'normal', 1 ], [ 'off', 0 ] ]
@@ -92,6 +85,22 @@
     # The enumeration of valid temp store modes.
     TEMP_STORE_MODES  = [ [ 'default', 0 ], [ 'file', 1 ], [ 'memory', 2 ] ]
 
+    # The enumeration of valid auto vacuum modes.
+    AUTO_VACUUM_MODES  = [ [ 'none', 0 ], [ 'full', 1 ], [ 'incremental', 2 ] ]
+
+    # The list of valid journaling modes.
+    JOURNAL_MODES  = [ [ 'delete' ], [ 'truncate' ], [ 'persist' ], [ 'memory' 
],
+                       [ 'wal' ], [ 'off' ] ]
+
+    # The list of valid locking modes.
+    LOCKING_MODES  = [ [ 'normal' ], [ 'exclusive' ] ]
+
+    # The list of valid encodings.
+    ENCODINGS = [ [ 'utf-8' ], [ 'utf-16' ], [ 'utf-16le' ], [ 'utf-16be ' ] ]
+
+    # The list of valid WAL checkpoints.
+    WAL_CHECKPOINTS = [ [ 'passive' ], [ 'full' ], [ 'restart' ], [ 'truncate' 
] ]
+
     # Does an integrity check on the database. If the check fails, a
     # SQLite3::Exception will be raised. Otherwise it
     # returns silently.
@@ -101,28 +110,36 @@
       end
     end
 
+    def application_id
+      get_int_pragma "application_id"
+    end
+
+    def application_id=( integer )
+      set_int_pragma "application_id", integer
+    end
+
     def auto_vacuum
-      get_boolean_pragma "auto_vacuum"
+      get_enum_pragma "auto_vacuum"
     end
 
     def auto_vacuum=( mode )
-      set_boolean_pragma "auto_vacuum", mode
+      set_enum_pragma "auto_vacuum", mode, AUTO_VACUUM_MODES
     end
 
-    def schema_cookie
-      get_int_pragma "schema_cookie"
+    def automatic_index
+      get_boolean_pragma "automatic_index"
     end
 
-    def schema_cookie=( cookie )
-      set_int_pragma "schema_cookie", cookie
+    def automatic_index=( mode )
+      set_boolean_pragma "automatic_index", mode
     end
 
-    def user_cookie
-      get_int_pragma "user_cookie"
+    def busy_timeout
+      get_int_pragma "busy_timeout"
     end
 
-    def user_cookie=( cookie )
-      set_int_pragma "user_cookie", cookie
+    def busy_timeout=( milliseconds )
+      set_int_pragma "busy_timeout", milliseconds
     end
 
     def cache_size
@@ -133,6 +150,58 @@
       set_int_pragma "cache_size", size
     end
 
+    def cache_spill
+      get_boolean_pragma "cache_spill"
+    end
+
+    def cache_spill=( mode )
+      set_boolean_pragma "cache_spill", mode
+    end
+
+    def case_sensitive_like=( mode )
+      set_boolean_pragma "case_sensitive_like", mode
+    end
+
+    def cell_size_check
+      get_boolean_pragma "cell_size_check"
+    end
+
+    def cell_size_check=( mode )
+      set_boolean_pragma "cell_size_check", mode
+    end
+
+    def checkpoint_fullfsync
+      get_boolean_pragma "checkpoint_fullfsync"
+    end
+
+    def checkpoint_fullfsync=( mode )
+      set_boolean_pragma "checkpoint_fullfsync", mode
+    end
+
+    def collation_list( &block ) # :yields: row
+      get_query_pragma "collation_list", &block
+    end
+
+    def compile_options( &block ) # :yields: row
+      get_query_pragma "compile_options", &block
+    end
+
+    def count_changes
+      get_boolean_pragma "count_changes"
+    end
+
+    def count_changes=( mode )
+      set_boolean_pragma "count_changes", mode
+    end
+
+    def data_version
+      get_int_pragma "data_version"
+    end
+
+    def database_list( &block ) # :yields: row
+      get_query_pragma "database_list", &block
+    end
+
     def default_cache_size
       get_int_pragma "default_cache_size"
     end
@@ -149,14 +218,6 @@
       set_enum_pragma "default_synchronous", mode, SYNCHRONOUS_MODES
     end
 
-    def synchronous
-      get_enum_pragma "synchronous"
-    end
-
-    def synchronous=( mode )
-      set_enum_pragma "synchronous", mode, SYNCHRONOUS_MODES
-    end
-
     def default_temp_store
       get_enum_pragma "default_temp_store"
     end
@@ -164,13 +225,41 @@
     def default_temp_store=( mode )
       set_enum_pragma "default_temp_store", mode, TEMP_STORE_MODES
     end
-  
-    def temp_store
-      get_enum_pragma "temp_store"
+
+    def defer_foreign_keys
+      get_boolean_pragma "defer_foreign_keys"
     end
 
-    def temp_store=( mode )
-      set_enum_pragma "temp_store", mode, TEMP_STORE_MODES
+    def defer_foreign_keys=( mode )
+      set_boolean_pragma "defer_foreign_keys", mode
+    end
+
+    def encoding
+      get_enum_pragma "encoding"
+    end
+
+    def encoding=( mode )
+      set_enum_pragma "encoding", mode, ENCODINGS
+    end
+
+    def foreign_key_check( *table, &block ) # :yields: row
+      get_query_pragma "foreign_key_check", *table, &block
+    end
+
+    def foreign_key_list( table, &block ) # :yields: row
+      get_query_pragma "foreign_key_list", table, &block
+    end
+
+    def foreign_keys
+      get_boolean_pragma "foreign_keys"
+    end
+
+    def foreign_keys=( mode )
+      set_boolean_pragma "foreign_keys", mode
+    end
+
+    def freelist_count
+      get_int_pragma "freelist_count"
     end
 
     def full_column_names
@@ -181,14 +270,238 @@
       set_boolean_pragma "full_column_names", mode
     end
   
-    def parser_trace
-      get_boolean_pragma "parser_trace"
+    def fullfsync
+      get_boolean_pragma "fullfsync"
+    end
+
+    def fullfsync=( mode )
+      set_boolean_pragma "fullfsync", mode
+    end
+
+    def ignore_check_constraints=( mode )
+      set_boolean_pragma "ignore_check_constraints", mode
+    end
+
+    def incremental_vacuum( pages, &block ) # :yields: row
+      get_query_pragma "incremental_vacuum", pages, &block
+    end
+
+    def index_info( index, &block ) # :yields: row
+      get_query_pragma "index_info", index, &block
+    end
+
+    def index_list( table, &block ) # :yields: row
+      get_query_pragma "index_list", table, &block
+    end
+
+    def index_xinfo( index, &block ) # :yields: row
+      get_query_pragma "index_xinfo", index, &block
+    end
+
+    def integrity_check( *num_errors, &block ) # :yields: row
+      get_query_pragma "integrity_check", *num_errors, &block
+    end
+
+    def journal_mode
+      get_enum_pragma "journal_mode"
+    end
+
+    def journal_mode=( mode )
+      set_enum_pragma "journal_mode", mode, JOURNAL_MODES
+    end
+
+    def journal_size_limit
+      get_int_pragma "journal_size_limit"
+    end
+
+    def journal_size_limit=( size )
+      set_int_pragma "journal_size_limit", size
+    end
+
+    def legacy_file_format
+      get_boolean_pragma "legacy_file_format"
+    end
+
+    def legacy_file_format=( mode )
+      set_boolean_pragma "legacy_file_format", mode
+    end
+
+    def locking_mode
+      get_enum_pragma "locking_mode"
+    end
+
+    def locking_mode=( mode )
+      set_enum_pragma "locking_mode", mode, LOCKING_MODES
+    end
+
+    def max_page_count
+      get_int_pragma "max_page_count"
+    end
+
+    def max_page_count=( size )
+      set_int_pragma "max_page_count", size
+    end
+
+    def mmap_size
+      get_int_pragma "mmap_size"
+    end
+
+    def mmap_size=( size )
+      set_int_pragma "mmap_size", size
+    end
+
+    def page_count
+      get_int_pragma "page_count"
+    end
+
+    def page_size
+      get_int_pragma "page_size"
+    end
+
+    def page_size=( size )
+      set_int_pragma "page_size", size
     end
 
     def parser_trace=( mode )
       set_boolean_pragma "parser_trace", mode
     end
   
+    def query_only
+      get_boolean_pragma "query_only"
+    end
+
+    def query_only=( mode )
+      set_boolean_pragma "query_only", mode
+    end
+
+    def quick_check( *num_errors, &block ) # :yields: row
+      get_query_pragma "quick_check", *num_errors, &block
+    end
+
+    def read_uncommitted
+      get_boolean_pragma "read_uncommitted"
+    end
+
+    def read_uncommitted=( mode )
+      set_boolean_pragma "read_uncommitted", mode
+    end
+
+    def recursive_triggers
+      get_boolean_pragma "recursive_triggers"
+    end
+
+    def recursive_triggers=( mode )
+      set_boolean_pragma "recursive_triggers", mode
+    end
+
+    def reverse_unordered_selects
+      get_boolean_pragma "reverse_unordered_selects"
+    end
+
+    def reverse_unordered_selects=( mode )
+      set_boolean_pragma "reverse_unordered_selects", mode
+    end
+
+    def schema_cookie
+      get_int_pragma "schema_cookie"
+    end
+
+    def schema_cookie=( cookie )
+      set_int_pragma "schema_cookie", cookie
+    end
+
+    def schema_version
+      get_int_pragma "schema_version"
+    end
+
+    def schema_version=( version )
+      set_int_pragma "schema_version", version
+    end
+
+    def secure_delete
+      get_boolean_pragma "secure_delete"
+    end
+
+    def secure_delete=( mode )
+      set_boolean_pragma "secure_delete", mode
+    end
+
+    def short_column_names
+      get_boolean_pragma "short_column_names"
+    end
+
+    def short_column_names=( mode )
+      set_boolean_pragma "short_column_names", mode
+    end
+
+    def shrink_memory
+      execute( "PRAGMA shrink_memory" )
+    end
+
+    def soft_heap_limit
+      get_int_pragma "soft_heap_limit"
+    end
+
+    def soft_heap_limit=( mode )
+      set_int_pragma "soft_heap_limit", mode
+    end
+
+    def stats( &block ) # :yields: row
+      get_query_pragma "stats", &block
+    end
+
+    def synchronous
+      get_enum_pragma "synchronous"
+    end
+
+    def synchronous=( mode )
+      set_enum_pragma "synchronous", mode, SYNCHRONOUS_MODES
+    end
+
+    def temp_store
+      get_enum_pragma "temp_store"
+    end
+
+    def temp_store=( mode )
+      set_enum_pragma "temp_store", mode, TEMP_STORE_MODES
+    end
+
+    def threads
+      get_int_pragma "threads"
+    end
+
+    def threads=( count )
+      set_int_pragma "threads", count
+    end
+
+    def user_cookie
+      get_int_pragma "user_cookie"
+    end
+
+    def user_cookie=( cookie )
+      set_int_pragma "user_cookie", cookie
+    end
+
+    def user_version
+      get_int_pragma "user_version"
+    end
+
+    def user_version=( version )
+      set_int_pragma "user_version", version
+    end
+
+    def vdbe_addoptrace=( mode )
+      set_boolean_pragma "vdbe_addoptrace", mode
+    end
+
+    def vdbe_debug=( mode )
+      set_boolean_pragma "vdbe_debug", mode
+    end
+
+    def vdbe_listing=( mode )
+      set_boolean_pragma "vdbe_listing", mode
+    end
+
     def vdbe_trace
       get_boolean_pragma "vdbe_trace"
     end
@@ -197,20 +510,24 @@
       set_boolean_pragma "vdbe_trace", mode
     end
 
-    def database_list( &block ) # :yields: row
-      get_query_pragma "database_list", &block
+    def wal_autocheckpoint
+      get_int_pragma "wal_autocheckpoint"
     end
 
-    def foreign_key_list( table, &block ) # :yields: row
-      get_query_pragma "foreign_key_list", table, &block
+    def wal_autocheckpoint=( mode )
+      set_int_pragma "wal_autocheckpoint", mode
     end
 
-    def index_info( index, &block ) # :yields: row
-      get_query_pragma "index_info", index, &block
+    def wal_checkpoint
+      get_enum_pragma "wal_checkpoint"
     end
 
-    def index_list( table, &block ) # :yields: row
-      get_query_pragma "index_list", table, &block
+    def wal_checkpoint=( mode )
+      set_enum_pragma "wal_checkpoint", mode, WAL_CHECKPOINTS
+    end
+
+    def writable_schema=( mode )
+      set_boolean_pragma "writable_schema", mode
     end
 
     ###
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/lib/sqlite3/version.rb new/lib/sqlite3/version.rb
--- old/lib/sqlite3/version.rb  2015-10-10 23:20:32.000000000 +0200
+++ new/lib/sqlite3/version.rb  2016-10-09 03:02:02.000000000 +0200
@@ -1,12 +1,12 @@
 module SQLite3
 
-  VERSION = '1.3.11'
+  VERSION = '1.3.12'
 
   module VersionProxy
 
     MAJOR = 1
     MINOR = 3
-    TINY  = 11
+    TINY  = 12
     BUILD = nil
 
     STRING = [ MAJOR, MINOR, TINY, BUILD ].compact.join( "." )
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/lib/sqlite3.rb new/lib/sqlite3.rb
--- old/lib/sqlite3.rb  2015-10-10 23:20:32.000000000 +0200
+++ new/lib/sqlite3.rb  2016-10-09 03:02:02.000000000 +0200
@@ -8,3 +8,8 @@
 
 require 'sqlite3/database'
 require 'sqlite3/version'
+
+module SQLite3
+  # Was sqlite3 compiled with thread safety on?
+  def self.threadsafe?; threadsafe > 0; end
+end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/metadata new/metadata
--- old/metadata        2015-10-10 23:20:32.000000000 +0200
+++ new/metadata        2016-10-09 03:02:02.000000000 +0200
@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlite3
 version: !ruby/object:Gem::Version
-  version: 1.3.11
+  version: 1.3.12
 platform: ruby
 authors:
 - Jamis Buck
@@ -10,7 +10,7 @@
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-10 00:00:00.000000000 Z
+date: 2016-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -18,14 +18,14 @@
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.8'
+        version: '5.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.8'
+        version: '5.9'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -60,14 +60,14 @@
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.5.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.5.2
 - !ruby/object:Gem::Dependency
   name: mini_portile
   requirement: !ruby/object:Gem::Requirement
@@ -102,14 +102,14 @@
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.14'
+        version: '3.15'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.14'
+        version: '3.15'
 description: |-
   This module allows Ruby programs to interface with the SQLite3
   database engine (http://www.sqlite.org).  You must have the
@@ -208,7 +208,7 @@
       version: 1.3.5
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: This module allows Ruby programs to interface with the SQLite3 
database engine
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/tasks/gem.rake new/tasks/gem.rake
--- old/tasks/gem.rake  2015-10-10 23:20:32.000000000 +0200
+++ new/tasks/gem.rake  2016-10-09 03:02:02.000000000 +0200
@@ -25,7 +25,7 @@
   spec_extras[:extensions] = ["ext/sqlite3/extconf.rb"]
 
   extra_dev_deps << ['rake-compiler', "~> 0.9.3"]
-  extra_dev_deps << ['rake-compiler-dock', "~> 0.4.3"]
+  extra_dev_deps << ['rake-compiler-dock', "~> 0.5.2"]
   extra_dev_deps << ["mini_portile", "~> 0.6.2"]
   extra_dev_deps << ["minitest", "~> 5.0"]
   extra_dev_deps << ["hoe-bundler", "~> 1.0"]
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/test/test_database.rb new/test/test_database.rb
--- old/test/test_database.rb   2015-10-10 23:20:32.000000000 +0200
+++ new/test/test_database.rb   2016-10-09 03:02:02.000000000 +0200
@@ -1,4 +1,5 @@
 require 'helper'
+require 'tempfile'
 
 module SQLite3
   class TestDatabase < SQLite3::TestCase
@@ -6,12 +7,43 @@
 
     def setup
       @db = SQLite3::Database.new(':memory:')
+      super
     end
 
     def test_segv
       assert_raises(TypeError) { SQLite3::Database.new 1 }
     end
 
+    def test_db_filename
+      tf = nil
+      assert_equal '', @db.filename('main')
+      tf = Tempfile.new 'thing'
+      @db = SQLite3::Database.new tf.path
+      assert_equal tf.path, @db.filename('main')
+    ensure
+      tf.unlink if tf
+    end
+
+    def test_filename
+      tf = nil
+      assert_equal '', @db.filename
+      tf = Tempfile.new 'thing'
+      @db = SQLite3::Database.new tf.path
+      assert_equal tf.path, @db.filename
+    ensure
+      tf.unlink if tf
+    end
+
+    def test_filename_with_attachment
+      tf = nil
+      assert_equal '', @db.filename
+      tf = Tempfile.new 'thing'
+      @db.execute "ATTACH DATABASE '#{tf.path}' AS 'testing'"
+      assert_equal tf.path, @db.filename('testing')
+    ensure
+      tf.unlink if tf
+    end
+
     def test_bignum
       num = 4907021672125087844
       db.execute 'CREATE TABLE "employees" ("token" integer(8), "name" 
varchar(20) NOT NULL)'
@@ -109,6 +141,18 @@
       assert thing.closed?
     end
 
+    def test_block_closes_self_even_raised
+      thing = nil
+      begin
+        SQLite3::Database.new(':memory:') do |db|
+          thing = db
+          raise
+        end
+      rescue
+      end
+      assert thing.closed?
+    end
+
     def test_prepare
       db = SQLite3::Database.new(':memory:')
       stmt = db.prepare('select "hello world"')
@@ -261,12 +305,30 @@
     end
 
     def test_function_return_types
-      [10, 2.2, nil, "foo"].each do |thing|
+      [10, 2.2, nil, "foo", Blob.new("foo\0bar")].each do |thing|
         @db.define_function("hello") { |a| thing }
         assert_equal [thing], @db.execute("select hello('world')").first
       end
     end
 
+    def test_function_gc_segfault
+      @db.create_function("bug", -1) { |func, *values| func.result = 
values.join }
+      # With a lot of data and a lot of threads, try to induce a GC segfault.
+      params = Array.new(127, "?" * 28000)
+      proc = Proc.new {
+        db.execute("select bug(#{Array.new(params.length, "?").join(",")})", 
params)
+      }
+      m = Mutex.new
+      30.times.map { Thread.new { m.synchronize { proc.call } } }.each(&:join)
+    end
+
+    def test_function_return_type_round_trip
+      [10, 2.2, nil, "foo", Blob.new("foo\0bar")].each do |thing|
+        @db.define_function("hello") { |a| a }
+        assert_equal [thing], @db.execute("select hello(hello(?))", 
[thing]).first
+      end
+    end
+
     def test_define_function_closed
       @db.close
       assert_raise(SQLite3::Exception) do
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/test/test_database_readonly.rb 
new/test/test_database_readonly.rb
--- old/test/test_database_readonly.rb  2015-10-10 23:20:32.000000000 +0200
+++ new/test/test_database_readonly.rb  2016-10-09 03:02:02.000000000 +0200
@@ -3,7 +3,7 @@
 module SQLite3
   class TestDatabaseReadonly < SQLite3::TestCase
     def setup
-      File.unlink 'test-readonly.db' if File.exists?('test-readonly.db')
+      File.unlink 'test-readonly.db' if File.exist?('test-readonly.db')
       @db = SQLite3::Database.new('test-readonly.db')
       @db.execute("CREATE TABLE foos (id integer)")
       @db.close
@@ -11,7 +11,7 @@
 
     def teardown
       @db.close unless @db.closed?
-      File.unlink 'test-readonly.db'
+      File.unlink 'test-readonly.db' if File.exist?('test-readonly.db')
     end
 
     def test_open_readonly_database
@@ -19,6 +19,13 @@
       assert @db.readonly?
     end
 
+    def test_open_readonly_not_exists_database
+      File.unlink 'test-readonly.db'
+      assert_raise(SQLite3::CantOpenException) do
+        @db = SQLite3::Database.new('test-readonly.db', :readonly => true)
+      end
+    end
+
     def test_insert_readonly_database
       @db = SQLite3::Database.new('test-readonly.db', :readonly => true)
       assert_raise(SQLite3::ReadOnlyException) do
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/test/test_integration.rb new/test/test_integration.rb
--- old/test/test_integration.rb        2015-10-10 23:20:32.000000000 +0200
+++ new/test/test_integration.rb        2016-10-09 03:02:02.000000000 +0200
@@ -499,6 +499,10 @@
 
     value = @db.get_first_value( "select accumulate(a) from foo" )
     assert_equal 6, value
+
+    # calling #get_first_value twice don't add up to the latest result
+    value = @db.get_first_value( "select accumulate(a) from foo" )
+    assert_equal 6, value
   end
 
   def test_create_aggregate_with_block
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/test/test_sqlite3.rb new/test/test_sqlite3.rb
--- old/test/test_sqlite3.rb    2015-10-10 23:20:32.000000000 +0200
+++ new/test/test_sqlite3.rb    2016-10-09 03:02:02.000000000 +0200
@@ -5,5 +5,17 @@
     def test_libversion
       assert_not_nil SQLite3.libversion
     end
+
+    def test_threadsafe
+      assert_not_nil SQLite3.threadsafe
+    end
+
+    def test_threadsafe?
+      if SQLite3.threadsafe > 0
+        assert SQLite3.threadsafe?
+      else
+        refute SQLite3.threadsafe?
+      end
+    end
   end
 end


Reply via email to