sqlite3 2.9.6 → 2.10.2

data/ext/sqlite3/database.c

@@ -74,51 +74,6 @@ close_or_discard_db(sqlite3RubyPtr ctx)
 }
 
 
-void
-rb_sqlite3_pin_array_and_contents(VALUE ary)
-{
-    long i;
-
-    if (NIL_P(ary) || !ary) { return; }
-
-    rb_gc_mark(ary);
-    for (i = 0; i < RARRAY_LEN(ary); i++) {
-        rb_gc_mark(RARRAY_AREF(ary, i));
-    }
-}
-
-static int
-pin_hash_value(VALUE UNUSED(key), VALUE value, VALUE UNUSED(arg))
-{
-    rb_gc_mark(value);
-    return ST_CONTINUE;
-}
-
-static void
-pin_hash_and_contents(VALUE hash)
-{
-    if (NIL_P(hash) || !hash) { return; }
-
-    rb_gc_mark(hash);
-    rb_hash_foreach(hash, pin_hash_value, 0);
-}
-
-/* Each wrapper also owns live aggregate instances, whose VALUEs sqlite keeps in
- * its own aggregate contexts. */
-static void
-pin_aggregators(VALUE aggregators)
-{
-    long i;
-
-    rb_sqlite3_pin_array_and_contents(aggregators);
-
-    if (NIL_P(aggregators) || !aggregators) { return; }
-
-    for (i = 0; i < RARRAY_LEN(aggregators); i++) {
-        rb_sqlite3_aggregator_pin_instances(RARRAY_AREF(aggregators, i));
-    }
-}
-
 static void
 database_mark(void *ctx)
 {
@@ -130,8 +85,8 @@ database_mark(void *ctx)
     rb_gc_mark(c->authorizer);
 
     rb_sqlite3_pin_array_and_contents(c->functions);
-    pin_hash_and_contents(c->collations);
-    pin_aggregators(c->aggregators);
+    rb_sqlite3_pin_array_and_contents(c->collations);
+    rb_sqlite3_aggregator_pin(c->aggregators);
 }
 
 static void
@@ -150,7 +105,7 @@ database_memsize(const void *ctx)
 }
 
 static const rb_data_type_t database_type = {
-    .wrap_struct_name = "SQLite3::Backup",
+    .wrap_struct_name = "SQLite3::Database",
     .function = {
         .dmark = database_mark,
         .dfree = deallocate,
@@ -321,11 +276,21 @@ total_changes(VALUE self)
     return INT2NUM(sqlite3_total_changes(ctx->db));
 }
 
+static VALUE
+tracefunc_protected(VALUE args_value)
+{
+    VALUE *args = (VALUE *)args_value;
+    return rb_funcall(args[0], rb_intern("call"), 1, rb_str_new2((const char *)args[1]));
+}
+
 static void
 tracefunc(void *data, const char *sql)
 {
     sqlite3RubyPtr ctx = (sqlite3RubyPtr)data;
-    rb_funcall(ctx->trace_handler, rb_intern("call"), 1, rb_str_new2(sql));
+    VALUE args[] = { ctx->trace_handler, (VALUE)sql };
+    int failed;
+
+    rb_sqlite3_protect_callback(tracefunc_protected, (VALUE)args, &failed);
 }
 
 /* call-seq:
@@ -356,15 +321,24 @@ trace(int argc, VALUE *argv, VALUE self)
     return self;
 }
 
+static VALUE
+rb_sqlite3_busy_handler_protected(VALUE args_value)
+{
+    VALUE *args = (VALUE *)args_value;
+    return rb_funcall(args[0], rb_intern("call"), 1, INT2NUM((int)args[1]));
+}
+
 static int
 rb_sqlite3_busy_handler(void *context, int count)
 {
     sqlite3RubyPtr ctx = (sqlite3RubyPtr)context;
+    VALUE args[] = { ctx->busy_handler, (VALUE)count };
+    VALUE result;
+    int failed;
 
-    VALUE handle = ctx->busy_handler;
-    VALUE result = rb_funcall(handle, rb_intern("call"), 1, INT2NUM(count));
+    result = rb_sqlite3_protect_callback(rb_sqlite3_busy_handler_protected, (VALUE)args, &failed);
 
-    if (Qfalse == result) { return 0; }
+    if (failed || Qfalse == result) { return 0; }
 
     return 1;
 }
@@ -417,8 +391,10 @@ rb_sqlite3_statement_timeout(void *context)
     clock_gettime(CLOCK_MONOTONIC, &currentTime);
 
     if (!timespecisset(&ctx->stmt_deadline)) {
-        // Set stmt_deadline if not already set
-        ctx->stmt_deadline = currentTime;
+        struct timespec timeout;
+        timeout.tv_sec = ctx->stmt_timeout / 1000;
+        timeout.tv_nsec = (ctx->stmt_timeout % 1000) * 1000000L;
+        timespecadd(&currentTime, &timeout, &ctx->stmt_deadline);
     } else if (timespecafter(&currentTime, &ctx->stmt_deadline)) {
         return 1;
     }
@@ -527,14 +503,14 @@ set_sqlite3_func_result(sqlite3_context *ctx, VALUE result)
                 sqlite3_result_blob(
                     ctx,
                     (const void *)StringValuePtr(result),
-                    (int)RSTRING_LEN(result),
+                    RSTRING_LENINT(result),
                     SQLITE_TRANSIENT
                 );
             } else {
                 sqlite3_result_text(
                     ctx,
                     (const char *)StringValuePtr(result),
-                    (int)RSTRING_LEN(result),
+                    RSTRING_LENINT(result),
                     SQLITE_TRANSIENT
                 );
             }
@@ -576,13 +552,13 @@ static void
 rb_sqlite3_func(sqlite3_context *ctx, int argc, sqlite3_value **argv)
 {
     rb_sqlite3_func_args_t args = { .ctx = ctx, .argc = argc, .argv = argv };
-    int exc_status;
+    int failed;
 
-    rb_protect(rb_sqlite3_func_protected, (VALUE)&args, &exc_status);
+    rb_sqlite3_protect_callback(rb_sqlite3_func_protected, (VALUE)&args, &failed);
 
-    if (exc_status) {
+    if (failed) {
         /* the user should never see this message, because Statement#step will
-         * re-raise the exception still in rb_errinfo */
+         * resume the Ruby exception instead */
         sqlite3_result_error(ctx, "Ruby Exception occurred", -1);
     }
 }
@@ -720,6 +696,33 @@ changes(VALUE self)
     return INT2NUM(sqlite3_changes(ctx->db));
 }
 
+typedef struct {
+    VALUE authorizer;
+    int action;
+    const char *a;
+    const char *b;
+    const char *c;
+    const char *d;
+} rb_sqlite3_auth_args_t;
+
+static VALUE
+rb_sqlite3_auth_protected(VALUE auth_args_value)
+{
+    rb_sqlite3_auth_args_t *args = (rb_sqlite3_auth_args_t *)auth_args_value;
+    VALUE action = INT2NUM(args->action);
+    VALUE a      = args->a ? rb_str_new2(args->a) : Qnil;
+    VALUE b      = args->b ? rb_str_new2(args->b) : Qnil;
+    VALUE c      = args->c ? rb_str_new2(args->c) : Qnil;
+    VALUE d      = args->d ? rb_str_new2(args->d) : Qnil;
+    VALUE result = rb_funcall(args->authorizer, rb_intern("call"), 5, action, a, b, c, d);
+
+    if (T_FIXNUM == TYPE(result)) { return INT2FIX(NUM2INT(result)); }
+    if (Qtrue == result) { return INT2FIX(SQLITE_OK); }
+    if (Qfalse == result) { return INT2FIX(SQLITE_DENY); }
+
+    return INT2FIX(SQLITE_IGNORE);
+}
+
 static int
 rb_sqlite3_auth(
     void *ctx,
@@ -730,18 +733,17 @@ rb_sqlite3_auth(
     const char *_d)
 {
     sqlite3RubyPtr db_ctx = (sqlite3RubyPtr)ctx;
-    VALUE action = INT2NUM(_action);
-    VALUE a      = _a ? rb_str_new2(_a) : Qnil;
-    VALUE b      = _b ? rb_str_new2(_b) : Qnil;
-    VALUE c      = _c ? rb_str_new2(_c) : Qnil;
-    VALUE d      = _d ? rb_str_new2(_d) : Qnil;
-    VALUE result = rb_funcall(db_ctx->authorizer, rb_intern("call"), 5, action, a, b, c, d);
-
-    if (T_FIXNUM == TYPE(result)) { return (int)NUM2INT(result); }
-    if (Qtrue == result) { return SQLITE_OK; }
-    if (Qfalse == result) { return SQLITE_DENY; }
-
-    return SQLITE_IGNORE;
+    rb_sqlite3_auth_args_t args = {
+        .authorizer = db_ctx->authorizer, .action = _action, .a = _a, .b = _b, .c = _c, .d = _d
+    };
+    VALUE result;
+    int failed;
+
+    result = rb_sqlite3_protect_callback(rb_sqlite3_auth_protected, (VALUE)&args, &failed);
+
+    if (failed) { return SQLITE_DENY; }
+
+    return FIX2INT(result);
 }
 
 /* call-seq: set_authorizer = auth
@@ -813,10 +815,19 @@ set_extended_result_codes(VALUE self, VALUE enable)
     return self;
 }
 
-int
-rb_comparator_func(void *ctx, int a_len, const void *a, int b_len, const void *b)
-{
+typedef struct {
     VALUE comparator;
+    int a_len;
+    const void *a;
+    int b_len;
+    const void *b;
+    int comparison;
+} rb_comparator_args_t;
+
+static VALUE
+rb_comparator_protected(VALUE comparator_args_value)
+{
+    rb_comparator_args_t *args = (rb_comparator_args_t *)comparator_args_value;
     VALUE a_str;
     VALUE b_str;
     VALUE comparison;
@@ -824,9 +835,8 @@ rb_comparator_func(void *ctx, int a_len, const void *a, int b_len, const void *b
 
     internal_encoding = rb_default_internal_encoding();
 
-    comparator = (VALUE)ctx;
-    a_str = rb_str_new((const char *)a, a_len);
-    b_str = rb_str_new((const char *)b, b_len);
+    a_str = rb_str_new((const char *)args->a, args->a_len);
+    b_str = rb_str_new((const char *)args->b, args->b_len);
 
     rb_enc_associate_index(a_str, rb_utf8_encindex());
     rb_enc_associate_index(b_str, rb_utf8_encindex());
@@ -836,9 +846,30 @@ rb_comparator_func(void *ctx, int a_len, const void *a, int b_len, const void *b
         b_str = rb_str_export_to_enc(b_str, internal_encoding);
     }
 
-    comparison = rb_funcall(comparator, rb_intern("compare"), 2, a_str, b_str);
+    comparison = rb_funcall(args->comparator, rb_intern("compare"), 2, a_str, b_str);
+
+    args->comparison = NUM2INT(comparison);
 
-    return NUM2INT(comparison);
+    return Qnil;
+}
+
+int
+rb_comparator_func(void *ctx, int a_len, const void *a, int b_len, const void *b)
+{
+    rb_comparator_args_t args = { .comparator = (VALUE)ctx, .a_len = a_len, .a = a, .b_len = b_len, .b = b };
+    int failed;
+
+    rb_sqlite3_protect_callback(rb_comparator_protected, (VALUE)&args, &failed);
+
+    /* sqlite has no way to report a comparator error */
+    return failed ? 0 : args.comparison;
+}
+
+static int
+push_hash_value(VALUE UNUSED(key), VALUE value, VALUE ary)
+{
+    rb_ary_push(ary, value);
+    return ST_CONTINUE;
 }
 
 /* call-seq: db.collation(name, comparator)
@@ -852,21 +883,42 @@ static VALUE
 collation(VALUE self, VALUE name, VALUE comparator)
 {
     sqlite3RubyPtr ctx;
-    VALUE collations;
+    VALUE registry, key, comparators;
+    char *key_ptr;
+    long i;
     TypedData_Get_Struct(self, sqlite3Ruby, &database_type, ctx);
     REQUIRE_OPEN_DB(ctx);
 
+    /* sqlite holds a raw pointer to the comparator, so keep it alive and
+     * unmoved. The registry is private because callers can mutate the public
+     * @collations hash, and the snapshot is an array so database_mark can pin
+     * it without iterating a hash. sqlite matches collation names without
+     * regard to ASCII case, so the registry does too. The key and registry
+     * are prepared before sqlite takes the pointer, and the snapshot is
+     * published before the public hash, whose write can raise. */
+    key = rb_str_new_cstr(StringValuePtr(name));
+    key_ptr = RSTRING_PTR(key);
+    for (i = 0; i < RSTRING_LEN(key); i++) {
+        if (key_ptr[i] >= 'A' && key_ptr[i] <= 'Z') { key_ptr[i] += 'a' - 'A'; }
+    }
+    if (!rb_ivar_defined(self, rb_intern("-collations"))) {
+        rb_iv_set(self, "-collations", rb_hash_new());
+    }
+    registry = rb_iv_get(self, "-collations");
+
     CHECK(ctx->db, sqlite3_create_collation(
               ctx->db,
-              StringValuePtr(name),
+              RSTRING_PTR(name),
               SQLITE_UTF8,
               (void *)comparator,
               NIL_P(comparator) ? NULL : rb_comparator_func));
 
-    /* sqlite holds a raw pointer to the comparator, so keep it alive and unmoved. */
-    collations = rb_iv_get(self, "@collations");
-    rb_hash_aset(collations, name, comparator);
-    RB_OBJ_WRITE(self, &ctx->collations, collations);
+    rb_hash_aset(registry, key, comparator);
+    comparators = rb_ary_new();
+    rb_hash_foreach(registry, push_hash_value, comparators);
+    RB_OBJ_WRITE(self, &ctx->collations, comparators);
+
+    rb_hash_aset(rb_iv_get(self, "@collations"), name, comparator);
 
     return self;
 }
@@ -932,42 +984,68 @@ transaction_active_p(VALUE self)
     return sqlite3_get_autocommit(ctx->db) ? Qfalse : Qtrue;
 }
 
-static int
-hash_callback_function(VALUE callback_ary, int count, char **data, char **columns)
+typedef struct {
+    VALUE callback_ary;
+    VALUE (*build_row)(VALUE);
+} rb_sqlite3_exec_batch_t;
+
+typedef struct {
+    VALUE callback_ary;
+    int count;
+    char **data;
+    char **columns;
+} rb_sqlite3_exec_row_t;
+
+static VALUE
+hash_callback_protected(VALUE row_value)
 {
+    rb_sqlite3_exec_row_t *row = (rb_sqlite3_exec_row_t *)row_value;
     VALUE new_hash = rb_hash_new();
     int i;
 
-    for (i = 0; i < count; i++) {
-        if (data[i] == NULL) {
-            rb_hash_aset(new_hash, rb_str_new_cstr(columns[i]), Qnil);
+    for (i = 0; i < row->count; i++) {
+        if (row->data[i] == NULL) {
+            rb_hash_aset(new_hash, rb_str_new_cstr(row->columns[i]), Qnil);
         } else {
-            rb_hash_aset(new_hash, rb_str_new_cstr(columns[i]), rb_str_new_cstr(data[i]));
+            rb_hash_aset(new_hash, rb_str_new_cstr(row->columns[i]), rb_str_new_cstr(row->data[i]));
         }
     }
 
-    rb_ary_push(callback_ary, new_hash);
+    rb_ary_push(row->callback_ary, new_hash);
 
-    return 0;
+    return Qnil;
 }
 
-static int
-regular_callback_function(VALUE callback_ary, int count, char **data, char **columns)
+static VALUE
+regular_callback_protected(VALUE row_value)
 {
+    rb_sqlite3_exec_row_t *row = (rb_sqlite3_exec_row_t *)row_value;
     VALUE new_ary = rb_ary_new();
     int i;
 
-    for (i = 0; i < count; i++) {
-        if (data[i] == NULL) {
+    for (i = 0; i < row->count; i++) {
+        if (row->data[i] == NULL) {
             rb_ary_push(new_ary, Qnil);
         } else {
-            rb_ary_push(new_ary, rb_str_new_cstr(data[i]));
+            rb_ary_push(new_ary, rb_str_new_cstr(row->data[i]));
         }
     }
 
-    rb_ary_push(callback_ary, new_ary);
+    rb_ary_push(row->callback_ary, new_ary);
 
-    return 0;
+    return Qnil;
+}
+
+static int
+exec_batch_callback_function(void *batch_ptr, int count, char **data, char **columns)
+{
+    rb_sqlite3_exec_batch_t *batch = (rb_sqlite3_exec_batch_t *)batch_ptr;
+    rb_sqlite3_exec_row_t row = { .callback_ary = batch->callback_ary, .count = count, .data = data, .columns = columns };
+    int failed;
+
+    rb_sqlite3_protect_callback(batch->build_row, (VALUE)&row, &failed);
+
+    return failed;
 }
 
 
@@ -985,19 +1063,27 @@ exec_batch(VALUE self, VALUE sql, VALUE results_as_hash)
     sqlite3RubyPtr ctx;
     int status;
     VALUE callback_ary = rb_ary_new();
+    rb_sqlite3_exec_batch_t batch = {
+        .callback_ary = callback_ary,
+        .build_row = results_as_hash == Qtrue ? hash_callback_protected : regular_callback_protected
+    };
+    rb_sqlite3_callback_frame_t frame;
+    int callback_state;
+    const char *sql_cstr;
     char *errMsg;
 
     TypedData_Get_Struct(self, sqlite3Ruby, &database_type, ctx);
     REQUIRE_OPEN_DB(ctx);
 
-    if (results_as_hash == Qtrue) {
-        status = sqlite3_exec(ctx->db, StringValuePtr(sql), (sqlite3_callback)hash_callback_function,
-                              (void *)callback_ary,
-                              &errMsg);
-    } else {
-        status = sqlite3_exec(ctx->db, StringValuePtr(sql), (sqlite3_callback)regular_callback_function,
-                              (void *)callback_ary,
-                              &errMsg);
+    sql_cstr = StringValuePtr(sql);
+    timespecclear(&ctx->stmt_deadline);
+
+    rb_sqlite3_push_callback_frame(&frame);
+    status = sqlite3_exec(ctx->db, sql_cstr, exec_batch_callback_function, (void *)&batch, &errMsg);
+
+    if ((callback_state = rb_sqlite3_pop_callback_frame(&frame))) {
+        sqlite3_free(errMsg);
+        rb_jump_tag(callback_state);
     }
 
     CHECK_MSG(ctx->db, status, errMsg);
@@ -1024,6 +1110,137 @@ db_filename(VALUE self, VALUE db_name)
     return Qnil;
 }
 
+#ifdef HAVE_SQLITE3_SERIALIZE
+/* call-seq: db.serialize(database_name = "main")
+ *
+ * Serialize the database into a binary string.
+ *
+ * [database_name]  The name of the database to serialize. The default value
+ *                  is +main+ which is the main database file. For ATTACHed
+ *                  databases, use the name given in the ATTACH statement.
+ *
+ * Returns the contents of the database as a binary string. For an ordinary
+ * on-disk database file, this is just a copy of the disk file. For an
+ * in-memory database or a "TEMP" database, this is the same sequence of bytes
+ * which would be written to disk if that database were backed up to disk.
+ *
+ * Note: This method will only be defined if SQLite was compiled without
+ * +SQLITE_OMIT_DESERIALIZE+.
+ *
+ * See also: https://www.sqlite.org/c3ref/serialize.html
+ */
+static VALUE
+serialize(int argc, VALUE *argv, VALUE self)
+{
+    sqlite3RubyPtr ctx;
+    VALUE db_name;
+    const char *zSchema;
+    sqlite3_int64 size;
+    unsigned char *data;
+    VALUE result;
+
+    TypedData_Get_Struct(self, sqlite3Ruby, &database_type, ctx);
+    REQUIRE_OPEN_DB(ctx);
+
+    rb_scan_args(argc, argv, "01", &db_name);
+
+    zSchema = NIL_P(db_name) ? NULL : StringValueCStr(db_name);
+
+    data = sqlite3_serialize(ctx->db, zSchema, &size, 0);
+
+    if (data == NULL && size < 0) {
+        rb_raise(rb_path2class("SQLite3::Exception"), "unable to serialize database \"%s\"",
+                 zSchema ? zSchema : "main");
+    }
+    if (data == NULL && size > 0) {
+        rb_raise(rb_eNoMemError, "failed to allocate %lld bytes for serialization", (long long)size);
+    }
+
+    result = rb_str_new((const char *)data, (long)size);
+    sqlite3_free(data);
+
+    return result;
+}
+#endif
+
+#ifdef HAVE_SQLITE3_DESERIALIZE
+/* call-seq: db.deserialize(data, database_name = "main")
+ *
+ * Deserialize a binary string into the database. The database is replaced with
+ * the contents of the serialized data.
+ *
+ * [data]           A binary string containing the serialized database content.
+ *                  This is typically obtained from a prior call to #serialize.
+ *
+ * [database_name]  The name of the database to replace. The default value is
+ *                  +main+ which is the main database file. For ATTACHed
+ *                  databases, use the name given in the ATTACH statement.
+ *
+ * Raises SQLite3::BusyException if the database has an open read or write
+ * transaction, including one held by an unfinished statement, or is involved in
+ * a backup.
+ *
+ * Deserializing into a database backed by a file detaches the connection from
+ * that file. The file is left unchanged, and #filename(database_name) returns an
+ * empty string afterwards.
+ *
+ * ⚠ An image of a database in WAL mode deserializes without error, but later
+ * statements, even <tt>SELECT 1</tt>, raise SQLite3::CantOpenException. Rails
+ * enables WAL mode by default.
+ *
+ * ⚠ Deserializing untrusted data carries the same risks as opening an untrusted
+ * database file. See https://www.sqlite.org/security.html
+ *
+ * Note: This method will only be defined if the loaded SQLite is version 3.54.0
+ * or later and was compiled without +SQLITE_OMIT_DESERIALIZE+. Older versions do
+ * not raise SQLite3::BusyException; they free memory that an unfinished statement
+ * still uses.
+ *
+ * See also: https://www.sqlite.org/c3ref/deserialize.html
+ */
+static VALUE
+deserialize(int argc, VALUE *argv, VALUE self)
+{
+    sqlite3RubyPtr ctx;
+    VALUE data, db_name;
+    const char *zSchema;
+    unsigned char *pData;
+    sqlite3_int64 szDb, szBuf;
+    int status;
+
+    TypedData_Get_Struct(self, sqlite3Ruby, &database_type, ctx);
+    REQUIRE_OPEN_DB(ctx);
+
+    rb_scan_args(argc, argv, "11", &data, &db_name);
+
+    StringValue(data);
+    zSchema = NIL_P(db_name) ? NULL : StringValueCStr(db_name);
+    szDb = RSTRING_LEN(data);
+
+    /* SQLite's docs advise padding the buffer with about 20 extra bytes, because a maliciously
+     * malformed image may make SQLite read past its end. See https://www.sqlite.org/c3ref/deserialize.html
+     *
+     * With SQLITE_DESERIALIZE_RESIZEABLE set, SQLite copies pages out of the buffer with bounds
+     * checks instead of reading it in place, so the padding is defensive. It also keeps the
+     * allocation nonzero for an empty string, for which sqlite3_malloc64(0) returns NULL.
+     */
+    szBuf = szDb + 20;
+    pData = sqlite3_malloc64(szBuf);
+    if (pData == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate %lld bytes for deserialization", (long long)szBuf);
+    }
+    memcpy(pData, RSTRING_PTR(data), (size_t)szDb);
+    memset(pData + szDb, 0, (size_t)(szBuf - szDb));
+
+    status = sqlite3_deserialize(ctx->db, zSchema, pData, szDb, szDb,
+                                 SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE);
+
+    CHECK(ctx->db, status);
+
+    return self;
+}
+#endif
+
 static VALUE
 rb_sqlite3_open16(VALUE self, VALUE file)
 {
@@ -1104,6 +1321,16 @@ init_sqlite3_database(void)
 #endif
 #endif
 
+#ifdef HAVE_SQLITE3_SERIALIZE
+    rb_define_method(cSqlite3Database, "serialize", serialize, -1);
+#endif
+
+#ifdef HAVE_SQLITE3_DESERIALIZE
+    /* Before 3.54.0, sqlite3_deserialize frees memory that an unfinished statement still uses. */
+    if (sqlite3_libversion_number() >= 3054000) {
+        rb_define_method(cSqlite3Database, "deserialize", deserialize, -1);
+    }
+#endif
 
     rb_sqlite3_aggregator_init();
 }

data/ext/sqlite3/database.h

@@ -10,6 +10,12 @@
 struct _sqlite3Ruby {
     sqlite3 *db;
     VALUE busy_handler;
+    /* sqlite holds raw pointers to everything in these arrays. functions and
+     * aggregators are append-only, so redefining a name keeps the old object
+     * for the life of the connection: sqlite keys them by name and arity, and
+     * releasing on name alone was GHSA-28hh-pr2h-2w89. collations is rebuilt
+     * from a private hash keyed by name without regard to ASCII case, as
+     * sqlite keys them, so it releases a replaced comparator. */
     VALUE functions;
     VALUE collations;
     VALUE aggregators;
@@ -24,9 +30,6 @@ struct _sqlite3Ruby {
 typedef struct _sqlite3Ruby sqlite3Ruby;
 typedef sqlite3Ruby *sqlite3RubyPtr;
 
-/* Pinning a collection doesn't pin what's in it, hence both. */
-void rb_sqlite3_pin_array_and_contents(VALUE ary);
-
 void init_sqlite3_database();
 void set_sqlite3_func_result(sqlite3_context *ctx, VALUE result);