extralite-bundle 1.22 → 1.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 273cbd77f6231b5de32d1829c819553bbf60068251a4c994d0c038f89b908601
-  data.tar.gz: be32cecd7e3c6915f85dccf7a5c88757e952f45424fef84127bcf602de1a7074
+  metadata.gz: eed963dc582b5492ef4601faf29359be35a322c4e0fee60cca6d4c532e7e41bf
+  data.tar.gz: 16776f46b60e4ed42408269a0a635de370830b390699991b56768fab625a2ce5
 SHA512:
-  metadata.gz: 5eccc418d3dc8038263d596275d40cef9cb5690e954b8f284b37c0809be2221087899e57dd040448d8ac6c1445aabc296f81f9aa32c0e597d691fa5557eba4fa
-  data.tar.gz: a645e5bba9b35ebbdcdf14946c7e7233a1d055cbbbf8ca9d0971d67f3588b4461fa5417ca72a62a6e4ef048638c8c456d347c10a000848ed4b535d52af52df3d
+  metadata.gz: 48547b23314d89314a3051de82db89eadee325bf553627b4c494dbe4399b2072338cd78d3603bafafae294b2f44250d004e85963b4bb39cd5f5793b7b7194a7b
+  data.tar.gz: cd824816449323ec6b35d2adc6f2ff9b4e3822c3c65d86af202a6dd571a7b5a9532a07f67be9e973f7931c68128aaa82d680a5790e2fb6cacbe8c63b144518b3

data/.github/workflows/test.yml

@@ -8,7 +8,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest]
-        ruby: ['2.7', '3.0', '3.1', truffleruby]
+        ruby: ['3.0', '3.1', '3.2', truffleruby]
 
     name: >-
       ${{matrix.os}}, ${{matrix.ruby}}

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+# 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)
+- Add `Database#total_changes` (#20)
+- Add `Database#busy_timeout=` (#19)
+- Add `Database#limit` (#16)
+- Improve error handling
+
 # 1.22 2023-01-23
 
 - Improve documentation (#17)

data/Gemfile.lock

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

data/README.md

@@ -1,4 +1,4 @@
-# Extralite - A super fast Ruby gem for working with SQLite3 databases
+# Extralite - a Super Fast Ruby Gem for Working with SQLite3 Databases
 
 * Source code: https://github.com/digital-fabric/extralite
 * Documentation: http://www.rubydoc.info/gems/extralite
@@ -19,7 +19,7 @@ latest features and enhancements.
 
 ## Features
 
-- Super fast - [up to 10x faster](#performance) than the
+- Super fast - [up to 11x faster](#performance) than the
   [sqlite3](https://github.com/sparklemotion/sqlite3-ruby) gem (see also
   [comparison](#why-not-just-use-the-sqlite3-gem).)
 - A variety of methods for different data access patterns: rows as hashes, rows
@@ -48,7 +48,7 @@ gem 'extralite'
 
 You can also run `gem install extralite` if you just want to check it out.
 
-### Installing the Extralite-SQLite3 bundle
+### Installing the Extralite-SQLite3 Bundle
 
 If you don't have sqlite3 installed on your system, do not want to use the
 system-installed version of SQLite3, or would like to use the latest version of
@@ -145,9 +145,9 @@ db.close
 db.closed? #=> true
 ```
 
-## More features
+## More Features
 
-### Interrupting long-running queries
+### Interrupting Long-running Queries
 
 When running long-running queries, you can use `Database#interrupt` to interrupt
 the query:
@@ -168,7 +168,7 @@ ensure
 end
 ```
 
-### Creating backups
+### Creating Backups
 
 You can use `Database#backup` to create backup copies of a database. The
 `#backup` method takes either a filename or a database instance:
@@ -191,7 +191,7 @@ db.backup('backup.db') do |remaining, total|
 end
 ```
 
-### Retrieve status information
+### Retrieving Status Information
 
 Extralite provides methods for retrieving status information about the sqlite
 runtime, database-specific status and prepared statement-specific status,
@@ -217,6 +217,42 @@ current, high_watermark = db.status(Extralite::SQLITE_DBSTATUS_CACHE_USED)
 value = stmt.status(Extralite::SQLITE_STMTSTATUS_RUN)
 ```
 
+### Working with Database Limits
+
+The `Database#limit` can be used to get and set various database limits, as
+[discussed in the SQLite docs](https://www.sqlite.org/limits.html):
+
+```ruby
+# get limit
+value = db.limit(Extralite::SQLITE_LIMIT_ATTACHED)
+
+# set limit
+db.limit(Extralite::SQLITE_LIMIT_ATTACHED, new_value)
+```
+
+### Setting the Busy Timeout
+
+When accessing a database concurrently it can be handy to set a busy timeout, in
+order to not have to deal with rescuing `Extralite::BusyError` exceptions. The
+timeout is given in seconds:
+
+```ruby
+db.busy_timeout = 5
+```
+
+### Tracing SQL Statements
+
+To trace all SQL statements executed on the database, pass a block to
+`Database#trace`. To disable tracing, call `Database#trace` without a block:
+
+```ruby
+# enable tracing
+db.trace { |sql| puts sql: sql }
+
+# disable tracing
+db.trace
+```
+
 ## Usage with Sequel
 
 Extralite includes an adapter for
@@ -231,35 +267,6 @@ p articles.to_a
 
 (Make sure you include `extralite` as a dependency in your `Gemfile`.)
 
-## Why not just use the sqlite3 gem?
-
-The [sqlite3](https://github.com/sparklemotion/sqlite3-ruby) gem is a
-popular, solid, well-maintained project, used by thousands of developers. I've
-been doing a lot of work with SQLite3 databases lately, and wanted to have a
-simpler API that gives me query results in a variety of ways. Thus extralite was
-born.
-
-Extralite is significantly [faster](#performance) than the `sqlite3` gem and is
-also [thread-friendly](#concurrency). On the other hand, Extralite does not have
-support for defining custom functions, aggregates and collations. If you're
-using any of those features, you'll have to stick to the `sqlite3` gem.
-
-Here's a table summarizing the differences between the two gems:
-
-| |sqlite3 1.6.0|Extralite 1.21|
-|-|-|-|
-|SQLite3 dependency|depends on OS-installed libsqlite3|Use either system sqlite3 or [bundled latest version of SQLite3](#installing-the-extralite-sqlite3-bundle)|
-|API design|multiple classes|single class|
-|Query results|row as hash, row as array, single row, single value|row as hash, row as array, __single column__, single row, single value|
-|Execute multiple statements|separate API (#execute_batch)|integrated|
-|Prepared statements|yes|yes|
-|custom functions in Ruby|yes|no|
-|custom collations|yes|no|
-|custom aggregate functions|yes|no|
-|Multithread friendly|no|[yes](#concurrency)|
-|Code size|~2650LoC|~1300LoC|
-|Performance|1x|1.5x to 10x (see [below](#performance))|
-
 ## Concurrency
 
 Extralite releases the GVL while making blocking calls to the sqlite3 library,
@@ -272,10 +279,10 @@ performance, as you can see:
 
 A benchmark script is included, creating a table of various row counts, then
 fetching the entire table using either `sqlite3` or `extralite`. This benchmark
-shows Extralite to be up to ~10 times faster than `sqlite3` when fetching a
+shows Extralite to be up to ~11 times faster than `sqlite3` when fetching a
 large number of rows.
 
-### Rows as hashes
+### Rows as Hashes
 
  [Benchmark source code](https://github.com/digital-fabric/extralite/blob/main/test/perf_hash.rb)
 
@@ -285,7 +292,7 @@ large number of rows.
 |1K|299.2K rows/s|1.983M rows/s|__6.63x__|
 |100K|185.4K rows/s|2.033M rows/s|__10.97x__|
 
-### Rows as arrays
+### Rows as Arrays
 
 [Benchmark source code](https://github.com/digital-fabric/extralite/blob/main/test/perf_ary.rb)
 
@@ -295,7 +302,7 @@ large number of rows.
 |1K|502.1K rows/s|2.065M rows/s|__4.11x__|
 |100K|455.7K rows/s|2.511M rows/s|__5.51x__|
 
-### Prepared statements
+### Prepared Statements
 
 [Benchmark source code](https://github.com/digital-fabric/extralite/blob/main/test/perf_prepared.rb)
 

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));
@@ -174,7 +174,7 @@ void prepare_multi_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql) {
   case SQLITE_ERROR:
     rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
   default:
-    rb_raise(cError, "Invalid return code for prepare_multi_stmt_without_gvl: %d (please open an issue on https://github.com/digital-fabric/extralite)", ctx.rc);
+    rb_raise(cError, "%s", sqlite3_errmsg(db));
   }
 }
 
@@ -216,9 +216,9 @@ void prepare_single_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql) {
   case SQLITE_ERROR:
     rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
   case SQLITE_MULTI_STMT:
-    rb_raise(cSQLError, "A prepared statement does not accept SQL strings with multiple queries");
+    rb_raise(cError, "A prepared statement does not accept SQL strings with multiple queries");
   default:
-    rb_raise(cError, "Invalid return code for prepare_multi_stmt_without_gvl: %d (please open an issue on https://github.com/digital-fabric/extralite)", ctx.rc);
+    rb_raise(cError, "%s", sqlite3_errmsg(db));
   }
 }
 
@@ -248,7 +248,7 @@ int stmt_iterate(sqlite3_stmt *stmt, sqlite3 *db) {
     case SQLITE_ERROR:
       rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
     default:
-      rb_raise(cError, "Invalid return code for sqlite3_step: %d (please open an issue on https://github.com/digital-fabric/extralite)", ctx.rc);
+      rb_raise(cError, "%s", sqlite3_errmsg(db));
   }
 
   return 0;

data/ext/extralite/database.c

@@ -7,10 +7,11 @@ VALUE cSQLError;
 VALUE cBusyError;
 VALUE cInterruptError;
 
-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);
@@ -18,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);
 }
 
@@ -45,6 +46,12 @@ static VALUE Database_allocate(VALUE klass) {
   } \
 }
 
+Database_t *Database_struct(VALUE self) {
+  Database_t *db;
+  GetDatabase(self, db);
+  return db;
+}
+
 sqlite3 *Database_sqlite3_db(VALUE self) {
   Database_t *db;
   GetDatabase(self, db);
@@ -74,18 +81,27 @@ 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
 
+  db->trace_block = Qnil;
+
   return Qnil;
 }
 
@@ -99,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));
   }
@@ -129,12 +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);
   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 };
 
@@ -384,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:
@@ -466,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;
 }
 
@@ -498,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));
     }
   }
@@ -514,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));
   }
 
@@ -550,7 +569,7 @@ VALUE Extralite_runtime_status(int argc, VALUE* argv, VALUE self) {
  * current value and the high water mark value. To reset the high water mark,
  * pass true as reset.
  */
-VALUE Database_status(int argc, VALUE* argv, VALUE self) {
+VALUE Database_status(int argc, VALUE *argv, VALUE self) {
   VALUE op, reset;
   int cur, hwm;
 
@@ -565,6 +584,112 @@ VALUE Database_status(int argc, VALUE* argv, VALUE self) {
   return rb_ary_new3(2, INT2NUM(cur), INT2NUM(hwm));
 }
 
+/* call-seq:
+ *   db.limit(category) -> value
+ *   db.limit(category, new_value) -> prev_value
+ *
+ * Returns the current limit for the given category. If a new value is given,
+ * sets the limit to the new value and returns the previous value.
+ */
+VALUE Database_limit(int argc, VALUE *argv, VALUE self) {
+  VALUE category, new_value;
+
+  rb_scan_args(argc, argv, "11", &category, &new_value);
+
+  Database_t *db;
+  GetOpenDatabase(self, db);
+
+  int value = sqlite3_limit(db->sqlite3_db, NUM2INT(category), RTEST(new_value) ? NUM2INT(new_value) : -1);
+
+  if (value == -1) rb_raise(cError, "Invalid limit category");
+
+  return INT2NUM(value);
+}
+
+/* call-seq:
+ *   db.busy_timeout=(sec) -> db
+ *   db.busy_timeout=nil -> db
+ *
+ * Sets the busy timeout for the database, in seconds or fractions thereof. To
+ * disable the busy timeout, set it to 0 or nil.
+ */
+VALUE Database_busy_timeout_set(VALUE self, VALUE sec) {
+  Database_t *db;
+  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");
+
+  return self;
+}
+
+/* call-seq:
+ *   db.total_changes -> value
+ *
+ * Returns the total number of changes made to the database since opening it.
+ */
+VALUE Database_total_changes(VALUE self) {
+  Database_t *db;
+  GetOpenDatabase(self, db);
+
+  int value = sqlite3_total_changes(db->sqlite3_db);
+  return INT2NUM(value);
+}
+
+/* call-seq:
+ *   db.trace { |sql| } -> db
+ *   db.trace -> db
+ *
+ * Installs or removes a block that will be invoked for every SQL statement
+ * executed.
+ */
+VALUE Database_trace(VALUE self) {
+  Database_t *db;
+  GetOpenDatabase(self, db);
+
+  db->trace_block = rb_block_given_p() ? rb_block_proc() : Qnil;
+  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);
@@ -574,15 +699,24 @@ void Init_ExtraliteDatabase(void) {
   rb_define_alloc_func(cDatabase, Database_allocate);
 
   rb_define_method(cDatabase, "backup", Database_backup, -1);
+  rb_define_method(cDatabase, "busy_timeout=", Database_busy_timeout_set, 1);
   rb_define_method(cDatabase, "changes", Database_changes, 0);
   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);
   rb_define_method(cDatabase, "interrupt", Database_interrupt, 0);
   rb_define_method(cDatabase, "last_insert_rowid", Database_last_insert_rowid, 0);
+  rb_define_method(cDatabase, "limit", Database_limit, -1);
   rb_define_method(cDatabase, "prepare", Database_prepare, 1);
   rb_define_method(cDatabase, "query", Database_query_hash, -1);
   rb_define_method(cDatabase, "query_ary", Database_query_ary, -1);
@@ -591,6 +725,8 @@ void Init_ExtraliteDatabase(void) {
   rb_define_method(cDatabase, "query_single_row", Database_query_single_row, -1);
   rb_define_method(cDatabase, "query_single_value", Database_query_single_value, -1);
   rb_define_method(cDatabase, "status", Database_status, -1);
+  rb_define_method(cDatabase, "total_changes", Database_total_changes, 0);
+  rb_define_method(cDatabase, "trace", Database_trace, 0);
   rb_define_method(cDatabase, "transaction_active?", Database_transaction_active_p, 0);
 
 #ifdef HAVE_SQLITE3_LOAD_EXTENSION
@@ -606,8 +742,9 @@ void Init_ExtraliteDatabase(void) {
   rb_gc_register_mark_object(cBusyError);
   rb_gc_register_mark_object(cInterruptError);
 
-  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,18 +27,21 @@ extern VALUE cSQLError;
 extern VALUE cBusyError;
 extern VALUE cInterruptError;
 
-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;
+  VALUE trace_block;
 } Database_t;
 
 typedef struct {
   VALUE db;
   VALUE sql;
+  Database_t *db_struct;
   sqlite3 *sqlite3_db;
   sqlite3_stmt *stmt;
 } PreparedStatement_t;
@@ -56,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);
@@ -72,5 +75,6 @@ int stmt_iterate(sqlite3_stmt *stmt, sqlite3 *db);
 VALUE cleanup_stmt(query_ctx *ctx);
 
 sqlite3 *Database_sqlite3_db(VALUE self);
+Database_t *Database_struct(VALUE self);
 
 #endif /* EXTRALITE_H */

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,15 +41,15 @@ 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");
 
   stmt->db = db;
+  stmt->db_struct = Database_struct(db);
   stmt->sqlite3_db = Database_sqlite3_db(db);
   stmt->sql = sql;
 
@@ -65,6 +65,8 @@ 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);
+
   sqlite3_reset(stmt->stmt);
   sqlite3_clear_bindings(stmt->stmt);
   bind_all_parameters(stmt->stmt, argc, argv);

data/lib/extralite/sqlite3_constants.rb

@@ -0,0 +1,158 @@
+module Extralite
+
+  SQLITE_STATUS_MEMORY_USED           =  0
+  SQLITE_STATUS_PAGECACHE_USED        =  1
+  SQLITE_STATUS_PAGECACHE_OVERFLOW    =  2
+  SQLITE_STATUS_SCRATCH_USED          =  3 # NOT USED
+  SQLITE_STATUS_SCRATCH_OVERFLOW      =  4 # NOT USED
+  SQLITE_STATUS_MALLOC_SIZE           =  5
+  SQLITE_STATUS_PARSER_STACK          =  6
+  SQLITE_STATUS_PAGECACHE_SIZE        =  7
+  SQLITE_STATUS_SCRATCH_SIZE          =  8 # NOT USED
+  SQLITE_STATUS_MALLOC_COUNT          =  9
+
+  SQLITE_DBSTATUS_LOOKASIDE_USED      =  0
+  SQLITE_DBSTATUS_CACHE_USED          =  1
+  SQLITE_DBSTATUS_SCHEMA_USED         =  2
+  SQLITE_DBSTATUS_STMT_USED           =  3
+  SQLITE_DBSTATUS_LOOKASIDE_HIT       =  4
+  SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE =  5
+  SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL =  6
+  SQLITE_DBSTATUS_CACHE_HIT           =  7
+  SQLITE_DBSTATUS_CACHE_MISS          =  8
+  SQLITE_DBSTATUS_CACHE_WRITE         =  9
+  SQLITE_DBSTATUS_DEFERRED_FKS        = 10
+  SQLITE_DBSTATUS_CACHE_USED_SHARED   = 11
+  SQLITE_DBSTATUS_CACHE_SPILL         = 12
+
+  SQLITE_STMTSTATUS_FULLSCAN_STEP     =  1
+  SQLITE_STMTSTATUS_SORT              =  2
+  SQLITE_STMTSTATUS_AUTOINDEX         =  3
+  SQLITE_STMTSTATUS_VM_STEP           =  4
+  SQLITE_STMTSTATUS_REPREPARE         =  5
+  SQLITE_STMTSTATUS_RUN               =  6
+  SQLITE_STMTSTATUS_FILTER_MISS       =  7
+  SQLITE_STMTSTATUS_FILTER_HIT        =  8
+  SQLITE_STMTSTATUS_MEMUSED           = 99
+
+  SQLITE_LIMIT_LENGTH                 =  0
+  SQLITE_LIMIT_SQL_LENGTH             =  1
+  SQLITE_LIMIT_COLUMN                 =  2
+  SQLITE_LIMIT_EXPR_DEPTH             =  3
+  SQLITE_LIMIT_COMPOUND_SELECT        =  4
+  SQLITE_LIMIT_VDBE_OP                =  5
+  SQLITE_LIMIT_FUNCTION_ARG           =  6
+  SQLITE_LIMIT_ATTACHED               =  7
+  SQLITE_LIMIT_LIKE_PATTERN_LENGTH    =  8
+  SQLITE_LIMIT_VARIABLE_NUMBER        =  9
+  SQLITE_LIMIT_TRIGGER_DEPTH          = 10
+  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.22'
+  VERSION = '1.24'
 end

data/lib/extralite.rb

@@ -1,46 +1,11 @@
 require_relative './extralite_ext'
+require_relative './extralite/sqlite3_constants'
 
 # Extralite is a Ruby gem for working with SQLite databases
 module Extralite
-  
-  SQLITE_STATUS_MEMORY_USED           =  0
-  SQLITE_STATUS_PAGECACHE_USED        =  1
-  SQLITE_STATUS_PAGECACHE_OVERFLOW    =  2
-  SQLITE_STATUS_SCRATCH_USED          =  3 # NOT USED
-  SQLITE_STATUS_SCRATCH_OVERFLOW      =  4 # NOT USED
-  SQLITE_STATUS_MALLOC_SIZE           =  5
-  SQLITE_STATUS_PARSER_STACK          =  6
-  SQLITE_STATUS_PAGECACHE_SIZE        =  7
-  SQLITE_STATUS_SCRATCH_SIZE          =  8 # NOT USED
-  SQLITE_STATUS_MALLOC_COUNT          =  9
 
-  SQLITE_DBSTATUS_LOOKASIDE_USED      =  0
-  SQLITE_DBSTATUS_CACHE_USED          =  1
-  SQLITE_DBSTATUS_SCHEMA_USED         =  2
-  SQLITE_DBSTATUS_STMT_USED           =  3
-  SQLITE_DBSTATUS_LOOKASIDE_HIT       =  4
-  SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE =  5
-  SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL =  6
-  SQLITE_DBSTATUS_CACHE_HIT           =  7
-  SQLITE_DBSTATUS_CACHE_MISS          =  8
-  SQLITE_DBSTATUS_CACHE_WRITE         =  9
-  SQLITE_DBSTATUS_DEFERRED_FKS        = 10
-  SQLITE_DBSTATUS_CACHE_USED_SHARED   = 11
-  SQLITE_DBSTATUS_CACHE_SPILL         = 12
-
-  SQLITE_STMTSTATUS_FULLSCAN_STEP     =  1
-  SQLITE_STMTSTATUS_SORT              =  2
-  SQLITE_STMTSTATUS_AUTOINDEX         =  3
-  SQLITE_STMTSTATUS_VM_STEP           =  4
-  SQLITE_STMTSTATUS_REPREPARE         =  5
-  SQLITE_STMTSTATUS_RUN               =  6
-  SQLITE_STMTSTATUS_FILTER_MISS       =  7
-  SQLITE_STMTSTATUS_FILTER_HIT        =  8
-  SQLITE_STMTSTATUS_MEMUSED           = 99
-
-  # The following class definitions are not really needed, as they're already
-  # defined in the C extension. We put them here for the sake of generating
-  # docs.
+  # The following error classes are already defined in the C extension. We put
+  # them here for the sake of generating docs.
 
   # A base class for Extralite exceptions
   class Error < ::StandardError

data/test/test_database.rb

@@ -169,8 +169,6 @@ end
     assert_nil r
   end
 
-
-
   def test_extension_loading
     case RUBY_PLATFORM
     when /linux/
@@ -269,6 +267,100 @@ end
   def test_database_status
     assert_operator 0, :<, @db.status(Extralite::SQLITE_DBSTATUS_SCHEMA_USED).first
   end
+
+  def test_database_limit
+    result = @db.limit(Extralite::SQLITE_LIMIT_ATTACHED)
+    assert_equal 10, result
+
+    result = @db.limit(Extralite::SQLITE_LIMIT_ATTACHED, 5)
+    assert_equal 10, result
+
+    result = @db.limit(Extralite::SQLITE_LIMIT_ATTACHED)
+    assert_equal 5, result
+
+    assert_raises(Extralite::Error) { @db.limit(-999) }
+  end
+
+  def test_database_busy_timeout
+    fn = "/tmp/extralite-#{rand(10000)}.db"
+    db1 = Extralite::Database.new(fn)
+    db2 = Extralite::Database.new(fn)
+    
+    db1.query('begin exclusive')
+    assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+
+    db2.busy_timeout = 3
+    t0 = Time.now
+    t = Thread.new { sleep 0.1; db1.query('rollback') }
+    result = db2.query('begin exclusive')
+    t1 = Time.now
+
+    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 = nil
+    assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+
+    db2.busy_timeout = 0.2
+    t0 = Time.now
+    t = Thread.new do
+      sleep 3
+    ensure
+      db1.query('rollback')
+    end
+    assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+
+    t1 = Time.now
+    assert t1 - t0 >= 0.2
+    t.kill
+    t.join
+
+    db1.query('begin exclusive')
+    db2.busy_timeout = 0
+    assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+
+    db2.busy_timeout = nil
+    assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+  end
+
+  def test_database_total_changes
+    assert_equal 2, @db.total_changes
+
+    @db.query('insert into t values (7, 8, 9)')
+
+    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
@@ -336,6 +428,30 @@ class ScenarioTest < MiniTest::Test
     result = @db.query_single_column('select x from t')
     assert_equal [1, 4, 7], result
   end
+
+  def test_database_trace
+    sqls = []
+    @db.trace { |sql| sqls << sql }
+
+    @db.query('select 1')
+    assert_equal ['select 1'], sqls
+
+    @db.query('select 2')
+    assert_equal ['select 1', 'select 2'], sqls
+
+    stmt = @db.prepare('select 3')
+    
+    stmt.query
+    assert_equal ['select 1', 'select 2', 'select 3'], sqls
+
+    # turn off
+    @db.trace
+
+    stmt.query
+
+    @db.query('select 4')
+    assert_equal ['select 1', 'select 2', 'select 3'], sqls
+  end
 end
 
 class BackupTest < MiniTest::Test

data/test/test_prepared_statement.rb

@@ -37,6 +37,11 @@ class PreparedStatementTest < MiniTest::Test
     assert_raises(Extralite::SQLError) { @db.prepare('blah') }
   end
 
+  def test_prepared_statement_with_multiple_queries
+    error = begin; @db.prepare('select 1; select 2'); rescue => e; error = e; end
+    assert_equal Extralite::Error, error.class
+  end
+
   def test_prepared_statement_query_hash
     r = @stmt.query_hash(4)
     assert_equal [{x: 4, y: 5, z: 6}], r
@@ -211,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-bundle
 version: !ruby/object:Gem::Version
-  version: '1.22'
+  version: '1.24'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-23 00:00:00.000000000 Z
+date: 2023-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -113,6 +113,7 @@ files:
 - extralite.gemspec
 - gemspec.rb
 - lib/extralite.rb
+- lib/extralite/sqlite3_constants.rb
 - lib/extralite/version.rb
 - lib/sequel/adapters/extralite.rb
 - test/extensions/text.dylib