extralite 1.23 → 1.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7466fb655d5f2cc65862d604190d52208773a9cc8fb611b184bc46a20ccb8d1f
-  data.tar.gz: bbc9b59c5c2297df34d716a19b53ccc95008bea3be4d38d3cdd91340089962b5
+  metadata.gz: bbe4f33eced375588c90c6f0e2c3dd5b25ca19e44e3a9b4a20f21e43d7a833ff
+  data.tar.gz: 709a92b6edd0b54531652d3c572b5dcac21e8db09b6c516c8f07332bb4daa6ee
 SHA512:
-  metadata.gz: 227a7fb703cca6eed8b25f0adb32cf8421f3c503149a715006c381d5cca475e692048650acc561ccfcb5ff1203c489fa6fe429922aecb2c0486cd0ec83c85360
-  data.tar.gz: 131aa35e939c4623a306be6e7a756d40cfe77a5b199ffc90cb1937194e7066ba6fa4de3d4cc8618b8123b68dcfe9e92a60b3e821c49b51145497deb005467f24
+  metadata.gz: b1c8f1cfc27bfe888f6c92be36f00631dda67471f937c7d94d5b731c94b90fd3b83f322891186f1cc9baf792dafe2df02cd1dc09f8cef7e4030bce79c048f9c1
+  data.tar.gz: 6e4de82d209255d623bc090b29b5d71da1922a6d70d5b3879a475ace8acb77de8b75ee688c51b45b71c9e9b66c56e71bc341da6377366baf66388cbc261f65b5

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 1.24 2023-02-02
+
+- Fix closing database with open statements
+- Improve error reporting in  `Database#initialize`
+- Fix `extralite-bundle` gem compilation
+- Improve error handling, add methods for error information
+  - Use extended result codes
+  - Add `Database#errcode`
+  - Add `Database#errmsg`
+  - Add `Database#error_offset`
+
 # 1.23 2023-01-26
 
 - Add `Database#trace` (#21)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    extralite (1.23)
+    extralite (1.24)
 
 GEM
   remote: https://rubygems.org/

data/ext/extralite/common.c

@@ -23,7 +23,7 @@ static inline VALUE get_column_value(sqlite3_stmt *stmt, int col, int type) {
 void bind_parameter_value(sqlite3_stmt *stmt, int pos, VALUE value);
 
 void bind_hash_parameter_values(sqlite3_stmt *stmt, VALUE hash) {
-  VALUE keys = rb_funcall(hash, ID_KEYS, 0);
+  VALUE keys = rb_funcall(hash, ID_keys, 0);
   long len = RARRAY_LEN(keys);
   for (long i = 0; i < len; i++) {
     VALUE k = RARRAY_AREF(keys, i);
@@ -34,7 +34,7 @@ void bind_hash_parameter_values(sqlite3_stmt *stmt, VALUE hash) {
         bind_parameter_value(stmt, FIX2INT(k), v);
         break;
       case T_SYMBOL:
-        k = rb_funcall(k, ID_TO_S, 0);
+        k = rb_funcall(k, ID_to_s, 0);
       case T_STRING:
         if(RSTRING_PTR(k)[0] != ':') k = rb_str_plus(rb_str_new2(":"), k);
         int pos = sqlite3_bind_parameter_index(stmt, StringValuePtr(k));

data/ext/extralite/database.c

@@ -7,11 +7,11 @@ VALUE cSQLError;
 VALUE cBusyError;
 VALUE cInterruptError;
 
-ID ID_CALL;
-ID ID_KEYS;
-ID ID_NEW;
-ID ID_STRIP;
-ID ID_TO_S;
+ID ID_call;
+ID ID_keys;
+ID ID_new;
+ID ID_strip;
+ID ID_to_s;
 
 static size_t Database_size(const void *ptr) {
   return sizeof(Database_t);
@@ -19,7 +19,7 @@ static size_t Database_size(const void *ptr) {
 
 static void Database_free(void *ptr) {
   Database_t *db = ptr;
-  if (db->sqlite3_db) sqlite3_close(db->sqlite3_db);
+  if (db->sqlite3_db) sqlite3_close_v2(db->sqlite3_db);
   free(ptr);
 }
 
@@ -81,14 +81,21 @@ VALUE Database_initialize(VALUE self, VALUE path) {
 
   rc = sqlite3_open(StringValueCStr(path), &db->sqlite3_db);
   if (rc) {
-    sqlite3_close(db->sqlite3_db);
+    sqlite3_close_v2(db->sqlite3_db);
+    rb_raise(cError, "%s", sqlite3_errstr(rc));
+  }
+
+  // Enable extended result codes
+  rc = sqlite3_extended_result_codes(db->sqlite3_db, 1);
+  if (rc) {
+    sqlite3_close_v2(db->sqlite3_db);
     rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
   }
 
 #ifdef HAVE_SQLITE3_ENABLE_LOAD_EXTENSION
   rc = sqlite3_enable_load_extension(db->sqlite3_db, 1);
   if (rc) {
-    sqlite3_close(db->sqlite3_db);
+    sqlite3_close_v2(db->sqlite3_db);
     rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
   }
 #endif
@@ -108,7 +115,7 @@ VALUE Database_close(VALUE self) {
   Database_t *db;
   GetDatabase(self, db);
 
-  rc = sqlite3_close(db->sqlite3_db);
+  rc = sqlite3_close_v2(db->sqlite3_db);
   if (rc) {
     rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
   }
@@ -138,13 +145,15 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
 
   // extract query from args
   rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
-  sql = rb_funcall(argv[0], ID_STRIP, 0);
+  sql = rb_funcall(argv[0], ID_strip, 0);
   if (RSTRING_LEN(sql) == 0) return Qnil;
 
   // prepare query ctx
   GetOpenDatabase(self, db);
-  if (db->trace_block != Qnil) rb_funcall(db->trace_block, ID_CALL, 1, sql);
+  if (db->trace_block != Qnil) rb_funcall(db->trace_block, ID_call, 1, sql);
   prepare_multi_stmt(db->sqlite3_db, &stmt, sql);
+  RB_GC_GUARD(sql);
+
   bind_all_parameters(stmt, argc - 1, argv + 1);
   query_ctx ctx = { self, db->sqlite3_db, stmt };
 
@@ -394,7 +403,7 @@ VALUE Database_load_extension(VALUE self, VALUE path) {
  * Creates a prepared statement with the given SQL query.
  */
 VALUE Database_prepare(VALUE self, VALUE sql) {
-  return rb_funcall(cPreparedStatement, ID_NEW, 2, self, sql);
+  return rb_funcall(cPreparedStatement, ID_new, 2, self, sql);
 }
 
 /* call-seq:
@@ -476,7 +485,7 @@ VALUE backup_cleanup(VALUE ptr) {
   sqlite3_backup_finish(ctx->backup);
 
   if (ctx->close_dst_on_cleanup)
-    sqlite3_close(ctx->dst);
+    sqlite3_close_v2(ctx->dst);
   return Qnil;
 }
 
@@ -508,7 +517,7 @@ VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
   if (dst_is_fn) {
     int rc = sqlite3_open(StringValueCStr(dst), &dst_db);
     if (rc) {
-      sqlite3_close(dst_db);
+      sqlite3_close_v2(dst_db);
       rb_raise(cError, "%s", sqlite3_errmsg(dst_db));
     }
   }
@@ -524,7 +533,7 @@ VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
   backup = sqlite3_backup_init(dst_db, StringValueCStr(dst_name), src->sqlite3_db, StringValueCStr(src_name));
   if (!backup) {
     if (dst_is_fn)
-      sqlite3_close(dst_db);
+      sqlite3_close_v2(dst_db);
     rb_raise(cError, "%s", sqlite3_errmsg(dst_db));
   }
 
@@ -609,7 +618,6 @@ VALUE Database_busy_timeout_set(VALUE self, VALUE sec) {
   GetOpenDatabase(self, db);
 
   int ms = (sec == Qnil) ? 0 : (int)(NUM2DBL(sec) * 1000);
-
   int rc = sqlite3_busy_timeout(db->sqlite3_db, ms);
   if (rc != SQLITE_OK) rb_raise(cError, "Failed to set busy timeout");
 
@@ -644,6 +652,44 @@ VALUE Database_trace(VALUE self) {
   return self;
 }
 
+/* call-seq:
+ *   db.errcode -> errcode
+ *
+ * Returns the last error code for the database.
+ */
+VALUE Database_errcode(VALUE self) {
+  Database_t *db;
+  GetOpenDatabase(self, db);
+
+  return INT2NUM(sqlite3_errcode(db->sqlite3_db));
+}
+
+/* call-seq:
+ *   db.errmsg -> errmsg
+ *
+ * Returns the last error message for the database.
+ */
+VALUE Database_errmsg(VALUE self) {
+  Database_t *db;
+  GetOpenDatabase(self, db);
+
+  return rb_str_new2(sqlite3_errmsg(db->sqlite3_db));
+}
+
+#ifdef HAVE_SQLITE3_ERROR_OFFSET
+/* call-seq:
+ *   db.error_offset -> ofs
+ *
+ * Returns the offset for the last error
+ */
+VALUE Database_error_offset(VALUE self) {
+  Database_t *db;
+  GetOpenDatabase(self, db);
+
+  return INT2NUM(sqlite3_error_offset(db->sqlite3_db));
+}
+#endif
+
 void Init_ExtraliteDatabase(void) {
   VALUE mExtralite = rb_define_module("Extralite");
   rb_define_singleton_method(mExtralite, "runtime_status", Extralite_runtime_status, -1);
@@ -658,6 +704,13 @@ void Init_ExtraliteDatabase(void) {
   rb_define_method(cDatabase, "close", Database_close, 0);
   rb_define_method(cDatabase, "closed?", Database_closed_p, 0);
   rb_define_method(cDatabase, "columns", Database_columns, 1);
+  rb_define_method(cDatabase, "errcode", Database_errcode, 0);
+  rb_define_method(cDatabase, "errmsg", Database_errmsg, 0);
+
+  #ifdef HAVE_SQLITE3_ERROR_OFFSET
+  rb_define_method(cDatabase, "error_offset", Database_error_offset, 0);
+  #endif
+
   rb_define_method(cDatabase, "execute_multi", Database_execute_multi, 2);
   rb_define_method(cDatabase, "filename", Database_filename, -1);
   rb_define_method(cDatabase, "initialize", Database_initialize, 1);
@@ -689,9 +742,9 @@ void Init_ExtraliteDatabase(void) {
   rb_gc_register_mark_object(cBusyError);
   rb_gc_register_mark_object(cInterruptError);
 
-  ID_CALL   = rb_intern("call");
-  ID_KEYS   = rb_intern("keys");
-  ID_NEW    = rb_intern("new");
-  ID_STRIP  = rb_intern("strip");
-  ID_TO_S   = rb_intern("to_s");
+  ID_call   = rb_intern("call");
+  ID_keys   = rb_intern("keys");
+  ID_new    = rb_intern("new");
+  ID_strip  = rb_intern("strip");
+  ID_to_s   = rb_intern("to_s");
 }

data/ext/extralite/extconf-bundle.rb

@@ -2,8 +2,15 @@
 
 require 'mkmf'
 
-$CFLAGS << " -Wno-undef"
-$CFLAGS << " -Wno-discarded-qualifiers"
+$CFLAGS << ' -Wno-undef'
+$CFLAGS << ' -Wno-discarded-qualifiers'
+$CFLAGS << ' -Wno-unused-function'
+
+$defs << "-DHAVE_SQLITE3_ENABLE_LOAD_EXTENSION"
+$defs << "-DHAVE_SQLITE3_LOAD_EXTENSION"
+$defs << "-DHAVE_SQLITE3_ERROR_OFFSET"
+
+have_func('usleep')
 
 dir_config('extralite_ext')
 create_makefile('extralite_ext')

data/ext/extralite/extconf.rb

@@ -1,115 +1,93 @@
 # frozen_string_literal: true
 
-# require 'rubygems'
-# require 'mkmf'
-
-# # $CFLAGS << "-Wdiscarded-qualifier"
-#   # $CFLAGS << " -Wno-comment"
-#   # $CFLAGS << " -Wno-unused-result"
-#   # $CFLAGS << " -Wno-dangling-else"
-#   # $CFLAGS << " -Wno-parentheses"
-
-# dir_config 'extralite_ext'
-# create_makefile 'extralite_ext'
-
-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"
+if ENV['EXTRALITE_BUNDLE']
+  require_relative('extconf-bundle')
+else
+  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
+      
+      # 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
-
-    # 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
-
-if with_config('sqlcipher')
-  pkg_config("sqlcipher")
-else
-  pkg_config("sqlite3")
-end
-
-# --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 RbConfig::CONFIG["host_os"] =~ /mswin/
-  $CFLAGS << ' -W3'
-end
-
-if RUBY_VERSION < '2.7'
-  $CFLAGS << ' -DTAINTING_SUPPORT'
-end
-
-def asplode missing
-  if RUBY_PLATFORM =~ /mingw|mswin/
-    abort "#{missing} is missing. Install SQLite3 from " +
-          "http://www.sqlite.org/ first."
+  
+  if with_config('sqlcipher')
+    pkg_config("sqlcipher")
   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
+    pkg_config("sqlite3")
   end
-end
-
-asplode('sqlite3.h')  unless find_header  'sqlite3.h'
-find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
-
-have_library 'dl' # for static builds
-
-if with_config('sqlcipher')
-  asplode('sqlcipher') unless find_library 'sqlcipher', 'sqlite3_libversion_number'
-else
-  asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
-end
-
-# 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_enable_load_extension')
-have_func('sqlite3_load_extension')
-
-unless have_func('sqlite3_open_v2')
-  abort 'Please use a newer version of SQLite3'
-end
-
-have_func('sqlite3_prepare_v2')
-have_type('sqlite3_int64', 'sqlite3.h')
-have_type('sqlite3_uint64', 'sqlite3.h')
-
-$defs << "-DEXTRALITE_NO_BUNDLE"
-
-dir_config('extralite_ext')
-create_makefile('extralite_ext')
+  
+  # --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 RbConfig::CONFIG["host_os"] =~ /mswin/
+    $CFLAGS << ' -W3'
+  end
+  
+  if RUBY_VERSION < '2.7'
+    $CFLAGS << ' -DTAINTING_SUPPORT'
+  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
+    
+    asplode('sqlite3.h')  unless find_header  'sqlite3.h'
+    find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
+    
+    have_library 'dl' # for static builds
+    
+    if with_config('sqlcipher')
+      asplode('sqlcipher') unless find_library 'sqlcipher', 'sqlite3_libversion_number'
+    else
+      asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
+    end
+    
+    have_func('sqlite3_enable_load_extension')
+    have_func('sqlite3_load_extension')
+    have_func('sqlite3_prepare_v2')
+    have_func('sqlite3_error_offset')
+    
+    $defs << "-DEXTRALITE_NO_BUNDLE"
+    
+    dir_config('extralite_ext')
+    create_makefile('extralite_ext')
+  end

data/ext/extralite/extralite.h

@@ -27,11 +27,11 @@ extern VALUE cSQLError;
 extern VALUE cBusyError;
 extern VALUE cInterruptError;
 
-extern ID ID_CALL;
-extern ID ID_KEYS;
-extern ID ID_NEW;
-extern ID ID_STRIP;
-extern ID ID_TO_S;
+extern ID ID_call;
+extern ID ID_keys;
+extern ID ID_new;
+extern ID ID_strip;
+extern ID ID_to_s;
 
 typedef struct {
   sqlite3 *sqlite3_db;
@@ -59,13 +59,13 @@ typedef struct {
   sqlite3_backup *p;
 } backup_t;
 
+VALUE safe_execute_multi(query_ctx *ctx);
 VALUE safe_query_ary(query_ctx *ctx);
+VALUE safe_query_columns(query_ctx *ctx);
 VALUE safe_query_hash(query_ctx *ctx);
 VALUE safe_query_single_column(query_ctx *ctx);
 VALUE safe_query_single_row(query_ctx *ctx);
 VALUE safe_query_single_value(query_ctx *ctx);
-VALUE safe_execute_multi(query_ctx *ctx);
-VALUE safe_query_columns(query_ctx *ctx);
 
 void prepare_single_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
 void prepare_multi_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);

data/ext/extralite/prepared_statement.c

@@ -20,7 +20,7 @@ static void PreparedStatement_free(void *ptr) {
 }
 
 static const rb_data_type_t PreparedStatement_type = {
-    "Database",
+    "PreparedStatement",
     {PreparedStatement_mark, PreparedStatement_free, PreparedStatement_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
@@ -41,11 +41,10 @@ static VALUE PreparedStatement_allocate(VALUE klass) {
  * Initializes a new SQLite prepared statement with the given path.
  */
 VALUE PreparedStatement_initialize(VALUE self, VALUE db, VALUE sql) {
-  // int rc;
   PreparedStatement_t *stmt;
   GetPreparedStatement(self, stmt);
 
-  sql = rb_funcall(sql, ID_STRIP, 0);
+  sql = rb_funcall(sql, ID_strip, 0);
   if (!RSTRING_LEN(sql))
     rb_raise(cError, "Cannot prepare an empty SQL query");
 
@@ -66,7 +65,7 @@ static inline VALUE PreparedStatement_perform_query(int argc, VALUE *argv, VALUE
   if (!stmt->stmt)
     rb_raise(cError, "Prepared statement is closed");
 
-  if (stmt->db_struct->trace_block != Qnil) rb_funcall(stmt->db_struct->trace_block, ID_CALL, 1, stmt->sql);
+  if (stmt->db_struct->trace_block != Qnil) rb_funcall(stmt->db_struct->trace_block, ID_call, 1, stmt->sql);
 
   sqlite3_reset(stmt->stmt);
   sqlite3_clear_bindings(stmt->stmt);

data/lib/extralite/sqlite3_constants.rb

@@ -46,5 +46,113 @@ module Extralite
   SQLITE_LIMIT_LIKE_PATTERN_LENGTH    =  8
   SQLITE_LIMIT_VARIABLE_NUMBER        =  9
   SQLITE_LIMIT_TRIGGER_DEPTH          = 10
-  SQLITE_LIMIT_WORKER_THREADS         = 11  
+  SQLITE_LIMIT_WORKER_THREADS         = 11
+  
+  SQLITE_OK                           =   0
+  SQLITE_ERROR                        =   1
+  SQLITE_INTERNAL                     =   2
+  SQLITE_PERM                         =   3
+  SQLITE_ABORT                        =   4
+  SQLITE_BUSY                         =   5
+  SQLITE_LOCKED                       =   6
+  SQLITE_NOMEM                        =   7
+  SQLITE_READONLY                     =   8
+  SQLITE_INTERRUPT                    =   9
+  SQLITE_IOERR                        =  10
+  SQLITE_CORRUPT                      =  11
+  SQLITE_NOTFOUND                     =  12
+  SQLITE_FULL                         =  13
+  SQLITE_CANTOPEN                     =  14
+  SQLITE_PROTOCOL                     =  15
+  SQLITE_EMPTY                        =  16
+  SQLITE_SCHEMA                       =  17
+  SQLITE_TOOBIG                       =  18
+  SQLITE_CONSTRAINT                   =  19
+  SQLITE_MISMATCH                     =  20
+  SQLITE_MISUSE                       =  21
+  SQLITE_NOLFS                        =  22
+  SQLITE_AUTH                         =  23
+  SQLITE_FORMAT                       =  24
+  SQLITE_RANGE                        =  25
+  SQLITE_NOTADB                       =  26
+  SQLITE_NOTICE                       =  27
+  SQLITE_WARNING                      =  28
+  SQLITE_ROW                          = 100
+  SQLITE_DONE                         = 101
+
+  SQLITE_ERROR_MISSING_COLLSEQ        = (SQLITE_ERROR | (1<<8))
+  SQLITE_ERROR_RETRY                  = (SQLITE_ERROR | (2<<8))
+  SQLITE_ERROR_SNAPSHOT               = (SQLITE_ERROR | (3<<8))
+  SQLITE_IOERR_READ                   = (SQLITE_IOERR | (1<<8))
+  SQLITE_IOERR_SHORT_READ             = (SQLITE_IOERR | (2<<8))
+  SQLITE_IOERR_WRITE                  = (SQLITE_IOERR | (3<<8))
+  SQLITE_IOERR_FSYNC                  = (SQLITE_IOERR | (4<<8))
+  SQLITE_IOERR_DIR_FSYNC              = (SQLITE_IOERR | (5<<8))
+  SQLITE_IOERR_TRUNCATE               = (SQLITE_IOERR | (6<<8))
+  SQLITE_IOERR_FSTAT                  = (SQLITE_IOERR | (7<<8))
+  SQLITE_IOERR_UNLOCK                 = (SQLITE_IOERR | (8<<8))
+  SQLITE_IOERR_RDLOCK                 = (SQLITE_IOERR | (9<<8))
+  SQLITE_IOERR_DELETE                 = (SQLITE_IOERR | (10<<8))
+  SQLITE_IOERR_BLOCKED                = (SQLITE_IOERR | (11<<8))
+  SQLITE_IOERR_NOMEM                  = (SQLITE_IOERR | (12<<8))
+  SQLITE_IOERR_ACCESS                 = (SQLITE_IOERR | (13<<8))
+  SQLITE_IOERR_CHECKRESERVEDLOCK      = (SQLITE_IOERR | (14<<8))
+  SQLITE_IOERR_LOCK                   = (SQLITE_IOERR | (15<<8))
+  SQLITE_IOERR_CLOSE                  = (SQLITE_IOERR | (16<<8))
+  SQLITE_IOERR_DIR_CLOSE              = (SQLITE_IOERR | (17<<8))
+  SQLITE_IOERR_SHMOPEN                = (SQLITE_IOERR | (18<<8))
+  SQLITE_IOERR_SHMSIZE                = (SQLITE_IOERR | (19<<8))
+  SQLITE_IOERR_SHMLOCK                = (SQLITE_IOERR | (20<<8))
+  SQLITE_IOERR_SHMMAP                 = (SQLITE_IOERR | (21<<8))
+  SQLITE_IOERR_SEEK                   = (SQLITE_IOERR | (22<<8))
+  SQLITE_IOERR_DELETE_NOENT           = (SQLITE_IOERR | (23<<8))
+  SQLITE_IOERR_MMAP                   = (SQLITE_IOERR | (24<<8))
+  SQLITE_IOERR_GETTEMPPATH            = (SQLITE_IOERR | (25<<8))
+  SQLITE_IOERR_CONVPATH               = (SQLITE_IOERR | (26<<8))
+  SQLITE_IOERR_VNODE                  = (SQLITE_IOERR | (27<<8))
+  SQLITE_IOERR_AUTH                   = (SQLITE_IOERR | (28<<8))
+  SQLITE_IOERR_BEGIN_ATOMIC           = (SQLITE_IOERR | (29<<8))
+  SQLITE_IOERR_COMMIT_ATOMIC          = (SQLITE_IOERR | (30<<8))
+  SQLITE_IOERR_ROLLBACK_ATOMIC        = (SQLITE_IOERR | (31<<8))
+  SQLITE_IOERR_DATA                   = (SQLITE_IOERR | (32<<8))
+  SQLITE_IOERR_CORRUPTFS              = (SQLITE_IOERR | (33<<8))
+  SQLITE_LOCKED_SHAREDCACHE           = (SQLITE_LOCKED |  (1<<8))
+  SQLITE_LOCKED_VTAB                  = (SQLITE_LOCKED |  (2<<8))
+  SQLITE_BUSY_RECOVERY                = (SQLITE_BUSY   |  (1<<8))
+  SQLITE_BUSY_SNAPSHOT                = (SQLITE_BUSY   |  (2<<8))
+  SQLITE_BUSY_TIMEOUT                 = (SQLITE_BUSY   |  (3<<8))
+  SQLITE_CANTOPEN_NOTEMPDIR           = (SQLITE_CANTOPEN | (1<<8))
+  SQLITE_CANTOPEN_ISDIR               = (SQLITE_CANTOPEN | (2<<8))
+  SQLITE_CANTOPEN_FULLPATH            = (SQLITE_CANTOPEN | (3<<8))
+  SQLITE_CANTOPEN_CONVPATH            = (SQLITE_CANTOPEN | (4<<8))
+  SQLITE_CANTOPEN_DIRTYWAL            = (SQLITE_CANTOPEN | (5<<8))
+  SQLITE_CANTOPEN_SYMLINK             = (SQLITE_CANTOPEN | (6<<8))
+  SQLITE_CORRUPT_VTAB                 = (SQLITE_CORRUPT | (1<<8))
+  SQLITE_CORRUPT_SEQUENCE             = (SQLITE_CORRUPT | (2<<8))
+  SQLITE_CORRUPT_INDEX                = (SQLITE_CORRUPT | (3<<8))
+  SQLITE_READONLY_RECOVERY            = (SQLITE_READONLY | (1<<8))
+  SQLITE_READONLY_CANTLOCK            = (SQLITE_READONLY | (2<<8))
+  SQLITE_READONLY_ROLLBACK            = (SQLITE_READONLY | (3<<8))
+  SQLITE_READONLY_DBMOVED             = (SQLITE_READONLY | (4<<8))
+  SQLITE_READONLY_CANTINIT            = (SQLITE_READONLY | (5<<8))
+  SQLITE_READONLY_DIRECTORY           = (SQLITE_READONLY | (6<<8))
+  SQLITE_ABORT_ROLLBACK               = (SQLITE_ABORT | (2<<8))
+  SQLITE_CONSTRAINT_CHECK             = (SQLITE_CONSTRAINT | (1<<8))
+  SQLITE_CONSTRAINT_COMMITHOOK        = (SQLITE_CONSTRAINT | (2<<8))
+  SQLITE_CONSTRAINT_FOREIGNKEY        = (SQLITE_CONSTRAINT | (3<<8))
+  SQLITE_CONSTRAINT_FUNCTION          = (SQLITE_CONSTRAINT | (4<<8))
+  SQLITE_CONSTRAINT_NOTNULL           = (SQLITE_CONSTRAINT | (5<<8))
+  SQLITE_CONSTRAINT_PRIMARYKEY        = (SQLITE_CONSTRAINT | (6<<8))
+  SQLITE_CONSTRAINT_TRIGGER           = (SQLITE_CONSTRAINT | (7<<8))
+  SQLITE_CONSTRAINT_UNIQUE            = (SQLITE_CONSTRAINT | (8<<8))
+  SQLITE_CONSTRAINT_VTAB              = (SQLITE_CONSTRAINT | (9<<8))
+  SQLITE_CONSTRAINT_ROWID             = (SQLITE_CONSTRAINT |(10<<8))
+  SQLITE_CONSTRAINT_PINNED            = (SQLITE_CONSTRAINT |(11<<8))
+  SQLITE_CONSTRAINT_DATATYPE          = (SQLITE_CONSTRAINT |(12<<8))
+  SQLITE_NOTICE_RECOVER_WAL           = (SQLITE_NOTICE | (1<<8))
+  SQLITE_NOTICE_RECOVER_ROLLBACK      = (SQLITE_NOTICE | (2<<8))
+  SQLITE_WARNING_AUTOINDEX            = (SQLITE_WARNING | (1<<8))
+  SQLITE_AUTH_USER                    = (SQLITE_AUTH | (1<<8))
+  SQLITE_OK_LOAD_PERMANENTLY          = (SQLITE_OK | (1<<8))
+  SQLITE_OK_SYMLINK                   = (SQLITE_OK | (2<<8))
 end

data/lib/extralite/version.rb

@@ -1,3 +1,3 @@
 module Extralite
-  VERSION = '1.23'
+  VERSION = '1.24'
 end

data/test/test_database.rb

@@ -169,8 +169,6 @@ end
     assert_nil r
   end
 
-
-
   def test_extension_loading
     case RUBY_PLATFORM
     when /linux/
@@ -291,7 +289,7 @@ end
     db1.query('begin exclusive')
     assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
 
-    db2.busy_timeout = 0.3
+    db2.busy_timeout = 3
     t0 = Time.now
     t = Thread.new { sleep 0.1; db1.query('rollback') }
     result = db2.query('begin exclusive')
@@ -300,19 +298,24 @@ end
     assert_equal [], result
     assert t1 - t0 >= 0.1
     db2.query('rollback')
+    t.join
 
     # try to provoke a timeout
     db1.query('begin exclusive')
-    db2.busy_timeout = 0.1
+    db2.busy_timeout = nil
+    assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+
+    db2.busy_timeout = 0.2
     t0 = Time.now
     t = Thread.new do
-      sleep 0.5
+      sleep 3
     ensure
       db1.query('rollback')
     end
     assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+
     t1 = Time.now
-    assert t1 - t0 >= 0.1
+    assert t1 - t0 >= 0.2
     t.kill
     t.join
 
@@ -331,6 +334,33 @@ end
 
     assert_equal 3, @db.total_changes
   end
+
+  def test_database_errcode_errmsg
+    assert_equal 0, @db.errcode
+    assert_equal 'not an error', @db.errmsg
+
+    @db.query('select foo') rescue nil
+
+    assert_equal 1, @db.errcode
+    assert_equal 'no such column: foo', @db.errmsg
+
+    if Extralite.sqlite3_version >= '3.38.5'
+      assert_equal 7, @db.error_offset
+    end
+
+    @db.query('create table t2 (v not null)')
+    
+    assert_raises(Extralite::Error) { @db.query('insert into t2 values (null)') }
+    assert_equal Extralite::SQLITE_CONSTRAINT_NOTNULL, @db.errcode
+    assert_equal 'NOT NULL constraint failed: t2.v', @db.errmsg
+  end
+
+
+  def test_close_with_open_prepared_statement
+    stmt = @db.prepare('select * from t')
+    stmt.query
+    @db.close
+  end
 end
 
 class ScenarioTest < MiniTest::Test

data/test/test_prepared_statement.rb

@@ -216,4 +216,10 @@ end
     assert_equal 3, @stmt.status(Extralite::SQLITE_STMTSTATUS_RUN, true)
     assert_equal 0, @stmt.status(Extralite::SQLITE_STMTSTATUS_RUN)
   end
+
+  def test_query_after_db_close
+    assert_equal [{ x: 4, y: 5, z: 6}], @stmt.query(4)
+    @db.close
+    assert_equal [{ x: 4, y: 5, z: 6}], @stmt.query(4)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extralite
 version: !ruby/object:Gem::Version
-  version: '1.23'
+  version: '1.24'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-26 00:00:00.000000000 Z
+date: 2023-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler