extralite 1.22 → 1.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f89c90ddd416f49777f9962a2abeac953eb1303cee79b2c612f6936cf7eb033
-  data.tar.gz: fc2604b1b6ef38a7e52bdeaaf579a84728885a09e0005c4a436064b4a919f5d7
+  metadata.gz: 7466fb655d5f2cc65862d604190d52208773a9cc8fb611b184bc46a20ccb8d1f
+  data.tar.gz: bbc9b59c5c2297df34d716a19b53ccc95008bea3be4d38d3cdd91340089962b5
 SHA512:
-  metadata.gz: 892b73c7eb255b0e65f7a7b23b4b07fb9ad824a0b4766bcbcfff9d5996fb6954f664725f7bff0682a09b10c0d45690d53311b1e59038fce3b23805f919f53909
-  data.tar.gz: 2e1a19b0d9053e40a13ae905fc6f78acead1d6a625c009e8d55b9b47402b392012c68ee2fa2acd0d6f1a78aa8c5da1bed946d6a20d85db44209f9a1b897eeca1
+  metadata.gz: 227a7fb703cca6eed8b25f0adb32cf8421f3c503149a715006c381d5cca475e692048650acc561ccfcb5ff1203c489fa6fe429922aecb2c0486cd0ec83c85360
+  data.tar.gz: 131aa35e939c4623a306be6e7a756d40cfe77a5b199ffc90cb1937194e7066ba6fa4de3d4cc8618b8123b68dcfe9e92a60b3e821c49b51145497deb005467f24

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,11 @@
+# 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.23)
 
 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

@@ -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,6 +7,7 @@ VALUE cSQLError;
 VALUE cBusyError;
 VALUE cInterruptError;
 
+ID ID_CALL;
 ID ID_KEYS;
 ID ID_NEW;
 ID ID_STRIP;
@@ -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);
@@ -86,6 +93,8 @@ VALUE Database_initialize(VALUE self, VALUE path) {
   }
 #endif
 
+  db->trace_block = Qnil;
+
   return Qnil;
 }
 
@@ -134,6 +143,7 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
 
   // 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);
   bind_all_parameters(stmt, argc - 1, argv + 1);
   query_ctx ctx = { self, db->sqlite3_db, stmt };
@@ -550,7 +560,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 +575,75 @@ 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;
+}
+
 void Init_ExtraliteDatabase(void) {
   VALUE mExtralite = rb_define_module("Extralite");
   rb_define_singleton_method(mExtralite, "runtime_status", Extralite_runtime_status, -1);
@@ -574,6 +653,7 @@ 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);
@@ -583,6 +663,7 @@ void Init_ExtraliteDatabase(void) {
   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 +672,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,6 +689,7 @@ 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");

data/ext/extralite/extralite.h

@@ -27,6 +27,7 @@ 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;
@@ -34,11 +35,13 @@ 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;
@@ -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

@@ -50,6 +50,7 @@ VALUE PreparedStatement_initialize(VALUE self, VALUE db, VALUE 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 +66,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,50 @@
+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  
+end

data/lib/extralite/version.rb

@@ -1,3 +1,3 @@
 module Extralite
-  VERSION = '1.22'
+  VERSION = '1.23'
 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

@@ -269,6 +269,68 @@ 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 = 0.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')
+
+    # try to provoke a timeout
+    db1.query('begin exclusive')
+    db2.busy_timeout = 0.1
+    t0 = Time.now
+    t = Thread.new do
+      sleep 0.5
+    ensure
+      db1.query('rollback')
+    end
+    assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+    t1 = Time.now
+    assert t1 - t0 >= 0.1
+    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
 end
 
 class ScenarioTest < MiniTest::Test
@@ -336,6 +398,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extralite
 version: !ruby/object:Gem::Version
-  version: '1.22'
+  version: '1.23'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-23 00:00:00.000000000 Z
+date: 2023-01-26 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