sqlite3 2.10.0-x86_64-linux-gnu → 2.10.2-x86_64-linux-gnu

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;
 }
@@ -529,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
                 );
             }
@@ -578,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);
     }
 }
@@ -722,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,
@@ -732,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
@@ -815,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;
@@ -826,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());
@@ -838,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)
@@ -854,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;
 }
@@ -934,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;
 }
 
 
@@ -987,21 +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);
 
+    sql_cstr = StringValuePtr(sql);
     timespecclear(&ctx->stmt_deadline);
 
-    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);
+    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);

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);
 

data/ext/sqlite3/exception.c

@@ -120,3 +120,98 @@ rb_sqlite3_raise_with_sql(sqlite3 *db, int status, const char *sql)
 
     rb_exc_raise(exception);
 }
+
+/* Each call into sqlite that can run callbacks pushes a frame on the current
+ * fiber's chain. A callback that fails records its rb_protect state in the top
+ * frame, and the call resumes Ruby's pending jump once sqlite returns. Ruby
+ * code that runs in between, such as a finalizer during an allocation, pushes
+ * its own frame for any nested call, so it never takes the outer call's jump.
+ * The chain is fiber-local because Ruby code inside a callback can switch
+ * threads or fibers, and a Ruby thread can move between native threads inside
+ * rb_protect. */
+typedef struct {
+    rb_sqlite3_callback_frame_t *top;
+} callback_frames_t;
+
+static const rb_data_type_t callback_frames_type = {
+    .wrap_struct_name = "SQLite3::CallbackFrames",
+    .function = {
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static ID id_callback_frames;
+
+/* Ruby code can overwrite or delete the fiber-local, so check its type. */
+static VALUE
+current_callback_frames_holder(void)
+{
+    VALUE holder = rb_thread_local_aref(rb_thread_current(), id_callback_frames);
+    return rb_typeddata_is_kind_of(holder, &callback_frames_type) ? holder : Qnil;
+}
+
+static callback_frames_t *
+current_callback_frames(void)
+{
+    VALUE holder = current_callback_frames_holder();
+    return NIL_P(holder) ? NULL : (callback_frames_t *)RTYPEDDATA_DATA(holder);
+}
+
+void
+rb_sqlite3_push_callback_frame(rb_sqlite3_callback_frame_t *frame)
+{
+    VALUE holder = current_callback_frames_holder();
+    callback_frames_t *frames;
+
+    if (NIL_P(holder)) {
+        holder = TypedData_Make_Struct(rb_cObject, callback_frames_t, &callback_frames_type, frames);
+        rb_thread_local_aset(rb_thread_current(), id_callback_frames, holder);
+    }
+    frames = (callback_frames_t *)RTYPEDDATA_DATA(holder);
+
+    frame->state = 0;
+    frame->prev = frames->top;
+    frame->holder = holder;
+    frames->top = frame;
+}
+
+int
+rb_sqlite3_pop_callback_frame(rb_sqlite3_callback_frame_t *frame)
+{
+    ((callback_frames_t *)RTYPEDDATA_DATA(frame->holder))->top = frame->prev;
+    return frame->state;
+}
+
+VALUE
+rb_sqlite3_protect_callback(VALUE (*body)(VALUE), VALUE data, int *failed)
+{
+    callback_frames_t *frames = current_callback_frames();
+    rb_sqlite3_callback_frame_t *frame = frames ? frames->top : NULL;
+    VALUE result;
+    int state;
+
+    if (frame && frame->state) {
+        *failed = 1;
+        return Qnil;
+    }
+
+    result = rb_protect(body, data, &state);
+    *failed = state != 0;
+
+    if (frame) {
+        frame->state = state;
+    } else if (state) {
+        /* sqlite ran the callback from a call that cannot resume the jump, such
+         * as Statement#reset!, so the error is dropped */
+        rb_set_errinfo(Qnil);
+    }
+
+    return result;
+}
+
+void
+init_sqlite3_exception(void)
+{
+    id_callback_frames = rb_intern("__sqlite3_callback_frames__");
+}

data/ext/sqlite3/exception.h

@@ -9,4 +9,25 @@ void rb_sqlite3_raise(sqlite3 *db, int status);
 void rb_sqlite3_raise_msg(sqlite3 *db, int status, const char *msg);
 void rb_sqlite3_raise_with_sql(sqlite3 *db, int status, const char *sql);
 
+typedef struct rb_sqlite3_callback_frame {
+    int state;
+    struct rb_sqlite3_callback_frame *prev;
+    /* the frame lives on the C stack, so GC marks and pins this */
+    VALUE holder;
+} rb_sqlite3_callback_frame_t;
+
+/* A call into sqlite that can run callbacks is wrapped in a frame. sqlite
+ * cannot carry a raise or a throw, so a failed callback records its rb_protect
+ * state in the frame, and later callbacks skip their Ruby code. Pop the frame
+ * when sqlite returns, then resume the jump with rb_jump_tag if the returned
+ * state is nonzero. Run nothing but the sqlite call in between, because a
+ * raise there would skip the pop. */
+void rb_sqlite3_push_callback_frame(rb_sqlite3_callback_frame_t *frame);
+int rb_sqlite3_pop_callback_frame(rb_sqlite3_callback_frame_t *frame);
+
+/* Runs a callback's Ruby code for sqlite. Sets *failed if it did not complete. */
+VALUE rb_sqlite3_protect_callback(VALUE (*body)(VALUE), VALUE data, int *failed);
+
+void init_sqlite3_exception(void);
+
 #endif

data/ext/sqlite3/sqlite3.c

@@ -60,6 +60,19 @@ bignum_to_int64(VALUE value, sqlite3_int64 *result)
 #endif
 }
 
+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 VALUE
 libversion(VALUE UNUSED(klass))
 {
@@ -191,6 +204,7 @@ Init_sqlite3_native(void)
     sqlite3_initialize();
 #endif
 
+    init_sqlite3_exception();
     init_sqlite3_constants();
     init_sqlite3_database();
     init_sqlite3_statement();

data/ext/sqlite3/sqlite3_ruby.h

@@ -45,4 +45,7 @@ extern VALUE cSqlite3Blob;
 
 int bignum_to_int64(VALUE big, sqlite3_int64 *result);
 
+/* Pinning a collection doesn't pin what's in it, hence both. */
+void rb_sqlite3_pin_array_and_contents(VALUE ary);
+
 #endif