aim-sqlite3 2.9.6.1.rc1 → 2.9.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43e86d899fe688464f75e560fbd568366ccd7a03065170aa8e634bc888de7ec0
-  data.tar.gz: 93f35aebba061a7aceed8f51f66fec2354373befa946d41b3f97969e95c9ae1c
+  metadata.gz: 132caf70af607720e4d50454eda4ca7be764e79cc615dfa112fe7f84165a1cec
+  data.tar.gz: eeba8a4aeac89921f93047d02194b4a5df013bab24d6a712436c737586ec2c98
 SHA512:
-  metadata.gz: cde63444c99ced87de1e331bb39210dd02b1938f861ef29f6b1b0aecd79ef92a138a1c44e7840009b64445c107ce6b27afc86c82c63ff5819d305dc0005f9d0d
-  data.tar.gz: '08fe4986933a45180c049379a54fd7eb3d895d21c80912683e636c5448ed1e31b54a3c4ea4dd1a09016bc93662ca67a79fb56679713a33872252a920b445e9bd'
+  metadata.gz: 18f7beb3c30c88a2ebafea3d3815e5881f61d747fd80d8187491d6d029f9ed77d080f5a5cd3358b73073dfe845e9e7b2d60317fbf33dff672b8be168aeb752a3
+  data.tar.gz: 88b51d43013b21766b70766a6bfa1a89867b7965ff3e0197d094c5d549fa0add864f4938836f3c60bda3003f77c6433ea38d11d4d0de42a5d033f52f815a281b

data/README.md

@@ -4,17 +4,21 @@
 >
 > - **`statement_timeout` honors its duration.** Upstream sets the deadline to "now", so long
 >   queries are interrupted almost at once; the deadline is also cleared on `Statement#reset!`.
-> - **Queries run without the GVL.** `Statement#step` and `execute_batch2` release the GVL, so
->   other threads keep running during long queries, and `Thread#kill` / `Thread#raise` cancel a
->   running query through `sqlite3_interrupt`. Ruby callbacks (UDFs, aggregates, busy handler,
->   authorizer, collations, trace) take the GVL back first. See `ext/sqlite3/gvl.c`.
-> - **Published as `aim-sqlite3`**, versioned `<upstream>.<n>` (e.g. `2.9.6.1`) and released by
->   pushing tag `v2.9.6.1` on `main`. PR branches publish release candidates (`v2.9.6.1.rc1`,
->   `rc2`, …) to validate in apps before merging. Precompiled for x86_64/aarch64 Linux and x86_64/arm64 macOS, with a
->   source gem for anything else. The packaged sqlite is built with `SQLITE_MAX_ATTACHED=50`,
->   and every gem carries the `sqlite3` program from the same build at `SQLite3.cli_path`.
->   CI and releases use `aim-ci.yml` / `aim-release.yml`; upstream workflows are disabled in the
->   repository settings.
+> - **Queries run without the GVL.** `Statement#step` and `execute_batch2` release the GVL, so other
+>   threads keep running during long queries. Each connection's progress handler checks for Ruby
+>   interrupts every 1000 steps: `Thread#kill`, `Thread#raise` and `throw` stop the query, while
+>   signals and `Thread#wakeup` let it continue. Ruby callbacks (UDFs, aggregates, busy handler,
+>   authorizer, collations, trace) take the GVL back first. A `Database` must not be used by two
+>   threads at once. See `ext/sqlite3/gvl.c`.
+> - **Published as `aim-sqlite3`**, versioned `<upstream>.<n>` (e.g. `2.9.6.1`; `<n>` is
+>   `SQLite3::AIM_VERSION` in `lib/sqlite3/aim_version.rb`) and released by pushing tag `v2.9.6.1`
+>   on `main`. PR branches publish release candidates (`v2.9.6.1.rc1`, `rc2`, …) to validate in apps
+>   before merging. Precompiled for x86_64/aarch64 Linux and x86_64/arm64 macOS, with a source gem
+>   for anything else. The packaged sqlite is built with `SQLITE_MAX_ATTACHED=50`, and every gem
+>   carries the `sqlite3` program from the same build at `SQLite3.cli_path`. CI and releases use
+>   `aim-ci.yml` / `aim-release.yml`; upstream workflows are disabled in the repository settings.
+> - **Fork tests** live in their own files (`test/test_aim_statement.rb`, `test/test_cli.rb`) so
+>   upstream's test files stay untouched.
 >
 > To pull in upstream: `git fetch upstream && git rebase upstream/main`.
 

data/ext/sqlite3/database.c

@@ -198,6 +198,8 @@ sqlite3_database_unwrap(VALUE database)
     return ctx;
 }
 
+static int rb_sqlite3_progress(void *context);
+
 static VALUE
 rb_sqlite3_open_v2(VALUE self, VALUE file, VALUE mode, VALUE zvfs)
 {
@@ -232,6 +234,8 @@ rb_sqlite3_open_v2(VALUE self, VALUE file, VALUE mode, VALUE zvfs)
         CHECK_MSG(ctx->db, status, msg);
     }
 
+    sqlite3_progress_handler(ctx->db, 1000, rb_sqlite3_progress, (void *)ctx);
+
     if (flags & SQLITE_OPEN_READONLY) {
         ctx->flags |= SQLITE3_RB_DATABASE_READONLY;
     }
@@ -471,6 +475,14 @@ rb_sqlite3_statement_timeout(void *context)
     return 0;
 }
 
+/* Installed for the connection's lifetime, since sqlite allows one progress handler. */
+static int
+rb_sqlite3_progress(void *context)
+{
+    sqlite3RubyPtr ctx = (sqlite3RubyPtr)context;
+    return rb_sqlite3_interrupted() || (ctx->stmt_timeout && rb_sqlite3_statement_timeout(ctx));
+}
+
 /* call-seq: db.statement_timeout = ms
  *
  * Indicates that if a query lasts longer than the indicated number of
@@ -485,9 +497,6 @@ set_statement_timeout(VALUE self, VALUE milliseconds)
     TypedData_Get_Struct(self, sqlite3Ruby, &database_type, ctx);
 
     ctx->stmt_timeout = NUM2INT(milliseconds);
-    int n = NUM2INT(milliseconds) == 0 ? -1 : 1000;
-
-    sqlite3_progress_handler(ctx->db, n, rb_sqlite3_statement_timeout, (void *)ctx);
 
     return self;
 }
@@ -1204,6 +1213,8 @@ rb_sqlite3_open16(VALUE self, VALUE file)
         CHECK_MSG(ctx->db, status, msg);
     }
 
+    sqlite3_progress_handler(ctx->db, 1000, rb_sqlite3_progress, (void *)ctx);
+
     return INT2NUM(status);
 }
 

data/ext/sqlite3/gvl.c

@@ -10,34 +10,107 @@
 /* Per OS thread: set while this thread is inside a without_gvl sqlite call. */
 static SQLITE3_TLS int in_nogvl = 0;
 
-/* Unblocking function: Thread#kill / Thread#raise call this from another
- * thread; sqlite3_interrupt is thread-safe and makes the running call return
- * SQLITE_INTERRUPT. */
-static void
-interrupt_db(void *db)
+typedef struct nogvl_call {
+    void *(*func)(void *);
+    void *data;
+    int status;
+    VALUE thread;
+    int pending_state;
+    VALUE pending_error;
+    struct nogvl_call *outer;
+} nogvl_call_t;
+
+/* Per OS thread: the innermost without_gvl call; a callback may run a nested one. */
+static SQLITE3_TLS nogvl_call_t *current_call = NULL;
+
+static VALUE
+check_ints_body(VALUE UNUSED(arg))
 {
-    sqlite3_interrupt((sqlite3 *)db);
+    rb_thread_check_ints();
+    return Qnil;
 }
 
 static void *
-step_body(void *stmt)
+check_ints(void *ptr)
 {
-    return (void *)(intptr_t)sqlite3_step((sqlite3_stmt *)stmt);
+    nogvl_call_t *call = (nogvl_call_t *)ptr;
+
+    rb_protect(check_ints_body, Qnil, &call->pending_state);
+    call->pending_error = rb_errinfo();
+    return NULL;
 }
 
+/* Called from the progress handler. Ruby flags a thread for Thread#raise and Thread#kill, but also
+ * for signals and Thread#wakeup, so the flag alone must not stop the query: run what is pending
+ * (trap handlers included) and stop only if that raised.
+ *
+ * Taking the GVL here deadlocks if another thread holds it while blocked on this connection's
+ * mutex, so a Database must not be used by two threads at once. */
 int
-rb_sqlite3_step_without_gvl(sqlite3_stmt *stmt)
+rb_sqlite3_interrupted(void)
 {
-    int was_nogvl = in_nogvl;
-    int status;
+    nogvl_call_t *call = current_call;
+
+    if (!in_nogvl || !rb_thread_interrupted(call->thread)) { return 0; }
+
+    rb_sqlite3_with_gvl(check_ints, call);
+    return call->pending_state != 0;
+}
+
+static VALUE
+run_without_gvl(VALUE ptr)
+{
+    nogvl_call_t *call = (nogvl_call_t *)ptr;
+    call->status = (int)(intptr_t)rb_thread_call_without_gvl(call->func, call->data, NULL, NULL);
+    return Qnil;
+}
+
+/* Runs even when rb_thread_call_without_gvl raises on its way out. */
+static VALUE
+end_call(VALUE ptr)
+{
+    nogvl_call_t *call = (nogvl_call_t *)ptr;
+
+    in_nogvl = 0;
+    current_call = call->outer;
+    return Qnil;
+}
 
+/* errmsg: sqlite's message for the interrupted call, freed when the call raises instead */
+static int
+call_without_gvl(void *(*func)(void *), void *data, char **errmsg)
+{
+    nogvl_call_t call = { .func = func, .data = data, .thread = rb_thread_current(),
+                          .pending_error = Qnil, .outer = current_call };
+
+    current_call = &call;
     in_nogvl = 1;
-    status = (int)(intptr_t)rb_thread_call_without_gvl(
-                 step_body, stmt, interrupt_db, sqlite3_db_handle(stmt));
+    rb_ensure(run_without_gvl, (VALUE)&call, end_call, (VALUE)&call);
+
+    if (call.pending_state) {
+        if (errmsg) { sqlite3_free(*errmsg); }
+        /* A trap handler run on the way out may have reset errinfo, so exceptions are re-raised
+         * from the captured value; throw and Thread#kill have no public API for that and rely on
+         * errinfo. throw's errinfo is internal data, not an object, hence the T_OBJECT check. */
+        if (RB_TYPE_P(call.pending_error, T_OBJECT) && rb_obj_is_kind_of(call.pending_error, rb_eException)) {
+            rb_exc_raise(call.pending_error);
+        }
+        rb_jump_tag(call.pending_state);
+    }
+
+    return call.status;
+}
 
-    in_nogvl = was_nogvl;
+static void *
+step_body(void *stmt)
+{
+    return (void *)(intptr_t)sqlite3_step((sqlite3_stmt *)stmt);
+}
 
-    return status;
+int
+rb_sqlite3_step_without_gvl(sqlite3_stmt *stmt)
+{
+    return call_without_gvl(step_body, stmt, NULL);
 }
 
 typedef struct {
@@ -61,14 +134,7 @@ rb_sqlite3_exec_without_gvl(sqlite3 *db, const char *sql, sqlite3_callback callb
                             void *callback_arg, char **errmsg)
 {
     exec_args_t args = { db, sql, callback, callback_arg, errmsg };
-    int was_nogvl = in_nogvl;
-    int status;
-
-    in_nogvl = 1;
-    status = (int)(intptr_t)rb_thread_call_without_gvl(exec_body, &args, interrupt_db, db);
-    in_nogvl = was_nogvl;
-
-    return status;
+    return call_without_gvl(exec_body, &args, errmsg);
 }
 
 /* Callbacks also fire from sqlite calls made with the GVL held (prepare,

data/ext/sqlite3/gvl.h

@@ -4,12 +4,13 @@
 #include <sqlite3_ruby.h>
 
 /* sqlite3_step and sqlite3_exec run without the GVL so other threads keep
- * running, and so Thread#kill / Thread#raise can cancel them through
- * sqlite3_interrupt. sqlite calls Ruby callbacks on the same thread, so each
+ * running, and so Thread#kill / Thread#raise can cancel them: each connection's progress
+ * handler asks rb_sqlite3_interrupted. sqlite calls Ruby callbacks on the same thread, so each
  * callback goes through rb_sqlite3_with_gvl to take the GVL back first. */
 int rb_sqlite3_step_without_gvl(sqlite3_stmt *stmt);
 int rb_sqlite3_exec_without_gvl(sqlite3 *db, const char *sql, sqlite3_callback callback,
                                 void *callback_arg, char **errmsg);
 void *rb_sqlite3_with_gvl(void *(*func)(void *), void *data);
+int rb_sqlite3_interrupted(void);
 
 #endif

data/lib/sqlite3/aim_version.rb

@@ -0,0 +1,5 @@
+module SQLite3
+  # (String) aim-sqlite3's release on top of upstream's VERSION; the gem is versioned
+  # "#{VERSION}.#{AIM_VERSION}", e.g. "2.9.6.1.rc1"
+  AIM_VERSION = "1"
+end

data/lib/sqlite3/version.rb

@@ -1,4 +1,4 @@
 module SQLite3
   # (String) the version of the sqlite3 gem, e.g. "2.1.1"
-  VERSION = "2.9.6.1.rc1"
+  VERSION = "2.9.6"
 end

data/lib/sqlite3.rb

@@ -17,4 +17,5 @@ module SQLite3
 end
 
 require "sqlite3/version_info"
+require "sqlite3/aim_version"
 require "sqlite3/cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aim-sqlite3
 version: !ruby/object:Gem::Version
-  version: 2.9.6.1.rc1
+  version: 2.9.6.1
 platform: ruby
 authors:
 - Jamis Buck
@@ -68,6 +68,7 @@ files:
 - ext/sqlite3/statement.h
 - ext/sqlite3/timespec.h
 - lib/sqlite3.rb
+- lib/sqlite3/aim_version.rb
 - lib/sqlite3/cli.rb
 - lib/sqlite3/constants.rb
 - lib/sqlite3/database.rb