sqlite3 2.0.0-x86_64-linux-musl

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2004-2024, Jamis Buck, Luis Lavena, Aaron Patterson, Mike Dalessio, et al.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice, this list of conditions
+  and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright notice, this list of
+  conditions and the following disclaimer in the documentation and/or other materials provided with
+  the distribution.
+
+  3. Neither the name of the copyright holder nor the names of its contributors may be used to
+  endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,181 @@
+# Ruby Interface for SQLite3
+
+## Overview
+
+This library allows Ruby programs to use the SQLite3 database engine (http://www.sqlite.org).
+
+Note that this module is only compatible with SQLite 3.6.16 or newer.
+
+* Source code: https://github.com/sparklemotion/sqlite3-ruby
+* Mailing list: http://groups.google.com/group/sqlite3-ruby
+* Download: http://rubygems.org/gems/sqlite3
+* Documentation: http://www.rubydoc.info/gems/sqlite3
+
+[![Test suite](https://github.com/sparklemotion/sqlite3-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/sparklemotion/sqlite3-ruby/actions/workflows/ci.yml)
+
+
+## Quick start
+
+For help understanding the SQLite3 Ruby API, please read the [FAQ](./FAQ.md) and the [full API documentation](https://rubydoc.info/gems/sqlite3).
+
+A few key classes whose APIs are often-used are:
+
+- SQLite3::Database ([rdoc](https://rubydoc.info/gems/sqlite3/SQLite3/Database))
+- SQLite3::Statement ([rdoc](https://rubydoc.info/gems/sqlite3/SQLite3/Statement))
+- SQLite3::ResultSet ([rdoc](https://rubydoc.info/gems/sqlite3/SQLite3/ResultSet))
+
+If you have any questions that you feel should be addressed in the FAQ, please send them to [the mailing list](http://groups.google.com/group/sqlite3-ruby) or open a [discussion thread](https://github.com/sparklemotion/sqlite3-ruby/discussions/categories/q-a).
+
+
+``` ruby
+require "sqlite3"
+
+# Open a database
+db = SQLite3::Database.new "test.db"
+
+# Create a table
+rows = db.execute <<-SQL
+  create table numbers (
+    name varchar(30),
+    val int
+  );
+SQL
+
+# Execute a few inserts
+{
+  "one" => 1,
+  "two" => 2,
+}.each do |pair|
+  db.execute "insert into numbers values ( ?, ? )", pair
+end
+
+# Find a few rows
+db.execute( "select * from numbers" ) do |row|
+  p row
+end
+# => ["one", 1]
+#    ["two", 2]
+
+# Create another table with multiple columns
+db.execute <<-SQL
+  create table students (
+    name varchar(50),
+    email varchar(50),
+    grade varchar(5),
+    blog varchar(50)
+  );
+SQL
+
+# Execute inserts with parameter markers
+db.execute("INSERT INTO students (name, email, grade, blog)
+            VALUES (?, ?, ?, ?)", ["Jane", "me@janedoe.com", "A", "http://blog.janedoe.com"])
+
+db.execute( "select * from students" ) do |row|
+  p row
+end
+# => ["Jane", "me@janedoe.com", "A", "http://blog.janedoe.com"]
+```
+
+## Thread Safety
+
+When `SQLite3.threadsafe?` returns `true`, then SQLite3 has been compiled to
+support running in a multithreaded environment.  However, this doesn't mean
+that all classes in the SQLite3 gem can be considered "thread safe".
+
+When `SQLite3.threadsafe?` returns `true`, it is safe to share only
+`SQLite3::Database` instances among threads without providing your own locking
+mechanism.  For example, the following code is fine because only the database
+instance is shared among threads:
+
+```ruby
+require 'sqlite3'
+
+db = SQLite3::Database.new ":memory:"
+
+latch = Queue.new
+
+ts = 10.times.map {
+  Thread.new {
+    latch.pop
+    db.execute "SELECT '#{Thread.current.inspect}'"
+  }
+}
+10.times { latch << nil }
+
+p ts.map(&:value)
+```
+
+Other instances can be shared among threads, but they require that you provide
+your own locking for thread safety.  For example, `SQLite3::Statement` objects
+(prepared statements) are mutable, so applications must take care to add
+appropriate locks to avoid data race conditions when sharing these objects
+among threads.
+
+Lets rewrite the above example but use a prepared statement and safely share
+the prepared statement among threads:
+
+```ruby
+db = SQLite3::Database.new ":memory:"
+
+# Prepare a statement
+stmt = db.prepare "SELECT :inspect"
+stmt_lock = Mutex.new
+
+latch = Queue.new
+
+ts = 10.times.map {
+  Thread.new {
+    latch.pop
+
+    # Add a lock when using the prepared statement.
+    # Binding values, and walking over results will mutate the statement, so
+    # in order to prevent other threads from "seeing" this thread's data, we
+    # must lock when using the statement object
+    stmt_lock.synchronize do
+      stmt.execute(Thread.current.inspect).to_a
+    end
+  }
+}
+
+10.times { latch << nil }
+
+p ts.map(&:value)
+
+stmt.close
+```
+
+It is generally recommended that if applications want to share a database among
+threads, they _only_ share the database instance object.  Other objects are
+fine to share, but may require manual locking for thread safety.
+
+## Support
+
+### Installation or database extensions
+
+If you're having trouble with installation, please first read [`INSTALLATION.md`](./INSTALLATION.md).
+
+### General help requests
+
+You can ask for help or support:
+
+* by emailing the [sqlite3-ruby mailing list](http://groups.google.com/group/sqlite3-ruby)
+* by opening a [discussion thread](https://github.com/sparklemotion/sqlite3-ruby/discussions/categories/q-a) on Github
+
+### Bug reports
+
+You can file the bug at the [github issues page](https://github.com/sparklemotion/sqlite3-ruby/issues).
+
+
+## Contributing
+
+See [`CONTRIBUTING.md`](./CONTRIBUTING.md).
+
+
+## License
+
+This library is licensed under `BSD-3-Clause`, see [`LICENSE`](./LICENSE).
+
+### Dependencies
+
+The source code of `sqlite` is distributed in the "ruby platform" gem. This code is public domain,
+see https://www.sqlite.org/copyright.html for details.

data/dependencies.yml

@@ -0,0 +1,13 @@
+sqlite3:
+  # checksum verified by first checking the published sha3(256) checksum against https://sqlite.org/download.html:
+  # cc1050780e0266de4d91b31c8deaf4638336908c12c21898e9f1fcae1e2ac303
+  #
+  # $ sha3sum -a 256 ports/archives/sqlite-autoconf-3450300.tar.gz
+  # cc1050780e0266de4d91b31c8deaf4638336908c12c21898e9f1fcae1e2ac303  ports/archives/sqlite-autoconf-3450300.tar.gz
+  #
+  # $ sha256sum ports/archives/sqlite-autoconf-3450300.tar.gz
+  # b2809ca53124c19c60f42bf627736eae011afdcc205bb48270a5ee9a38191531  ports/archives/sqlite-autoconf-3450300.tar.gz
+  version: "3.45.3"
+  files:
+    - url: "https://sqlite.org/2024/sqlite-autoconf-3450300.tar.gz"
+      sha256: "b2809ca53124c19c60f42bf627736eae011afdcc205bb48270a5ee9a38191531"

data/ext/sqlite3/aggregator.c

@@ -0,0 +1,270 @@
+#include <aggregator.h>
+#include <database.h>
+
+/* wraps a factory "handler" class. The "-aggregators" instance variable of
+ * the SQLite3::Database holds an array of all AggrogatorWrappers.
+ *
+ * An AggregatorWrapper holds the following instance variables:
+ * -handler_klass: the handler that creates the instances.
+ * -instances:     array of all the cAggregatorInstance objects currently
+ *                 in-flight for this aggregator. */
+static VALUE cAggregatorWrapper;
+
+/* wraps a instance of the "handler" class. Loses its reference at the end of
+ * the xFinal callback.
+ *
+ * An AggregatorInstance holds the following instance variables:
+ * -handler_instance: the instance to call `step` and `finalize` on.
+ * -exc_status:       status returned by rb_protect.
+ *                    != 0 if an exception occurred. If an exception occurred
+ *                    `step` and `finalize` won't be called any more. */
+static VALUE cAggregatorInstance;
+
+typedef struct rb_sqlite3_protected_funcall_args {
+    VALUE self;
+    ID method;
+    int argc;
+    VALUE *params;
+} protected_funcall_args_t;
+
+/* why isn't there something like this in the ruby API? */
+static VALUE
+rb_sqlite3_protected_funcall_body(VALUE protected_funcall_args_ptr)
+{
+    protected_funcall_args_t *args =
+        (protected_funcall_args_t *)protected_funcall_args_ptr;
+
+    return rb_funcall2(args->self, args->method, args->argc, args->params);
+}
+
+static VALUE
+rb_sqlite3_protected_funcall(VALUE self, ID method, int argc, VALUE *params,
+                             int *exc_status)
+{
+    protected_funcall_args_t args = {
+        .self = self, .method = method, .argc = argc, .params = params
+    };
+    return rb_protect(rb_sqlite3_protected_funcall_body, (VALUE)(&args), exc_status);
+}
+
+/* called in rb_sqlite3_aggregator_step and rb_sqlite3_aggregator_final. It
+ * checks if the execution context already has an associated instance. If it
+ * has one, it returns it. If there is no instance yet, it creates one and
+ * associates it with the context. */
+static VALUE
+rb_sqlite3_aggregate_instance(sqlite3_context *ctx)
+{
+    VALUE aw = (VALUE) sqlite3_user_data(ctx);
+    VALUE handler_klass = rb_iv_get(aw, "-handler_klass");
+    VALUE inst;
+    VALUE *inst_ptr = sqlite3_aggregate_context(ctx, (int)sizeof(VALUE));
+
+    if (!inst_ptr) {
+        rb_fatal("SQLite is out-of-merory");
+    }
+
+    inst = *inst_ptr;
+
+    if (inst == Qfalse) { /* Qfalse == 0 */
+        VALUE instances = rb_iv_get(aw, "-instances");
+        int exc_status;
+
+        inst = rb_class_new_instance(0, NULL, cAggregatorInstance);
+        rb_iv_set(inst, "-handler_instance", rb_sqlite3_protected_funcall(
+                      handler_klass, rb_intern("new"), 0, NULL, &exc_status));
+        rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
+
+        rb_ary_push(instances, inst);
+
+        *inst_ptr = inst;
+    }
+
+    if (inst == Qnil) {
+        rb_fatal("SQLite called us back on an already destroyed aggregate instance");
+    }
+
+    return inst;
+}
+
+/* called by rb_sqlite3_aggregator_final. Unlinks and frees the
+ * aggregator_instance_t, so the handler_instance won't be marked any more
+ * and Ruby's GC may free it. */
+static void
+rb_sqlite3_aggregate_instance_destroy(sqlite3_context *ctx)
+{
+    VALUE aw = (VALUE) sqlite3_user_data(ctx);
+    VALUE instances = rb_iv_get(aw, "-instances");
+    VALUE *inst_ptr = sqlite3_aggregate_context(ctx, 0);
+    VALUE inst;
+
+    if (!inst_ptr || (inst = *inst_ptr)) {
+        return;
+    }
+
+    if (inst == Qnil) {
+        rb_fatal("attempt to destroy aggregate instance twice");
+    }
+
+    rb_iv_set(inst, "-handler_instance", Qnil); // may catch use-after-free
+    if (rb_ary_delete(instances, inst) == Qnil) {
+        rb_fatal("must be in instances at that point");
+    }
+
+    *inst_ptr = Qnil;
+}
+
+static void
+rb_sqlite3_aggregator_step(sqlite3_context *ctx, int argc, sqlite3_value **argv)
+{
+    VALUE inst = rb_sqlite3_aggregate_instance(ctx);
+    VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
+    VALUE *params = NULL;
+    VALUE one_param;
+    int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
+    int i;
+
+    if (exc_status) {
+        return;
+    }
+
+    if (argc == 1) {
+        one_param = sqlite3val2rb(argv[0]);
+        params = &one_param;
+    }
+    if (argc > 1) {
+        params = xcalloc((size_t)argc, sizeof(VALUE));
+        for (i = 0; i < argc; i++) {
+            params[i] = sqlite3val2rb(argv[i]);
+        }
+    }
+    rb_sqlite3_protected_funcall(
+        handler_instance, rb_intern("step"), argc, params, &exc_status);
+    if (argc > 1) {
+        xfree(params);
+    }
+
+    rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
+}
+
+/* we assume that this function is only called once per execution context */
+static void
+rb_sqlite3_aggregator_final(sqlite3_context *ctx)
+{
+    VALUE inst = rb_sqlite3_aggregate_instance(ctx);
+    VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
+    int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
+
+    if (!exc_status) {
+        VALUE result = rb_sqlite3_protected_funcall(
+                           handler_instance, rb_intern("finalize"), 0, NULL, &exc_status);
+        if (!exc_status) {
+            set_sqlite3_func_result(ctx, result);
+        }
+    }
+
+    if (exc_status) {
+        /* the user should never see this, as Statement.step() will pick up the
+         * outstanding exception and raise it instead of generating a new one
+         * for SQLITE_ERROR with message "Ruby Exception occurred" */
+        sqlite3_result_error(ctx, "Ruby Exception occurred", -1);
+    }
+
+    rb_sqlite3_aggregate_instance_destroy(ctx);
+}
+
+/* call-seq: define_aggregator2(aggregator)
+ *
+ * Define an aggregrate function according to a factory object (the "handler")
+ * that knows how to obtain to all the information. The handler must provide
+ * the following class methods:
+ *
+ * +arity+:: corresponds to the +arity+ parameter of #create_aggregate. This
+ *           message is optional, and if the handler does not respond to it,
+ *           the function will have an arity of -1.
+ * +name+:: this is the name of the function. The handler _must_ implement
+ *          this message.
+ * +new+:: this must be implemented by the handler. It should return a new
+ *         instance of the object that will handle a specific invocation of
+ *         the function.
+ *
+ * The handler instance (the object returned by the +new+ message, described
+ * above), must respond to the following messages:
+ *
+ * +step+:: this is the method that will be called for each step of the
+ *          aggregate function's evaluation. It should take parameters according
+ *          to the *arity* definition.
+ * +finalize+:: this is the method that will be called to finalize the
+ *              aggregate function's evaluation. It should not take arguments.
+ *
+ * Note the difference between this function and #create_aggregate_handler
+ * is that no FunctionProxy ("ctx") object is involved. This manifests in two
+ * ways: The return value of the aggregate function is the return value of
+ * +finalize+ and neither +step+ nor +finalize+ take an additional "ctx"
+ * parameter.
+ */
+VALUE
+rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name)
+{
+    /* define_aggregator is added as a method to SQLite3::Database in database.c */
+    sqlite3RubyPtr ctx = sqlite3_database_unwrap(self);
+    int arity, status;
+    VALUE aw;
+    VALUE aggregators;
+
+    if (!ctx->db) {
+        rb_raise(rb_path2class("SQLite3::Exception"), "cannot use a closed database");
+    }
+
+    if (rb_respond_to(aggregator, rb_intern("arity"))) {
+        VALUE ruby_arity = rb_funcall(aggregator, rb_intern("arity"), 0);
+        arity = NUM2INT(ruby_arity);
+    } else {
+        arity = -1;
+    }
+
+    if (arity < -1 || arity > 127) {
+#ifdef PRIsVALUE
+        rb_raise(rb_eArgError, "%"PRIsVALUE" arity=%d out of range -1..127",
+                 self, arity);
+#else
+        rb_raise(rb_eArgError, "Aggregator arity=%d out of range -1..127", arity);
+#endif
+    }
+
+    if (!rb_ivar_defined(self, rb_intern("-aggregators"))) {
+        rb_iv_set(self, "-aggregators", rb_ary_new());
+    }
+    aggregators = rb_iv_get(self, "-aggregators");
+
+    aw = rb_class_new_instance(0, NULL, cAggregatorWrapper);
+    rb_iv_set(aw, "-handler_klass", aggregator);
+    rb_iv_set(aw, "-instances", rb_ary_new());
+
+    status = sqlite3_create_function(
+                 ctx->db,
+                 StringValueCStr(ruby_name),
+                 arity,
+                 SQLITE_UTF8,
+                 (void *)aw,
+                 NULL,
+                 rb_sqlite3_aggregator_step,
+                 rb_sqlite3_aggregator_final
+             );
+
+    CHECK(ctx->db, status);
+
+    rb_ary_push(aggregators, aw);
+
+    return self;
+}
+
+void
+rb_sqlite3_aggregator_init(void)
+{
+    /* rb_class_new generatos class with undefined allocator in ruby 1.9 */
+    cAggregatorWrapper = rb_funcall(rb_cClass, rb_intern("new"), 0);
+    rb_gc_register_mark_object(cAggregatorWrapper);
+
+    cAggregatorInstance = rb_funcall(rb_cClass, rb_intern("new"), 0);
+    rb_gc_register_mark_object(cAggregatorInstance);
+}

data/ext/sqlite3/aggregator.h

@@ -0,0 +1,10 @@
+#ifndef SQLITE3_AGGREGATOR_RUBY
+#define SQLITE3_AGGREGATOR_RUBY
+
+#include <sqlite3_ruby.h>
+
+VALUE rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name);
+
+void rb_sqlite3_aggregator_init(void);
+
+#endif

data/ext/sqlite3/backup.c

@@ -0,0 +1,190 @@
+#ifdef HAVE_SQLITE3_BACKUP_INIT
+
+#include <sqlite3_ruby.h>
+
+#define REQUIRE_OPEN_BACKUP(_ctxt) \
+  if(!_ctxt->p) \
+    rb_raise(rb_path2class("SQLite3::Exception"), "cannot use a closed backup");
+
+VALUE cSqlite3Backup;
+
+static size_t
+backup_memsize(const void *data)
+{
+    sqlite3BackupRubyPtr ctx = (sqlite3BackupRubyPtr)data;
+    // NB: can't account for ctx->p because the type is incomplete.
+    return sizeof(*ctx);
+}
+
+static const rb_data_type_t backup_type = {
+    "SQLite3::Backup",
+    {
+        NULL,
+        RUBY_TYPED_DEFAULT_FREE,
+        backup_memsize,
+    },
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static VALUE
+allocate(VALUE klass)
+{
+    sqlite3BackupRubyPtr ctx;
+    return TypedData_Make_Struct(klass, sqlite3BackupRuby, &backup_type, ctx);
+}
+
+/* call-seq: SQLite3::Backup.new(dstdb, dstname, srcdb, srcname)
+ *
+ * Initialize backup the backup.
+ *
+ * dstdb:
+ *   the destination SQLite3::Database object.
+ * dstname:
+ *   the destination's database name.
+ * srcdb:
+ *   the source SQLite3::Database object.
+ * srcname:
+ *   the source's database name.
+ *
+ * The database name is "main", "temp", or the name specified in an
+ * ATTACH statement.
+ *
+ * This feature requires SQLite 3.6.11 or later.
+ *
+ *   require 'sqlite3'
+ *   sdb = SQLite3::Database.new('src.sqlite3')
+ *
+ *   ddb = SQLite3::Database.new(':memory:')
+ *   b = SQLite3::Backup.new(ddb, 'main', sdb, 'main')
+ *   p [b.remaining, b.pagecount] # invalid value; for example [0, 0]
+ *   begin
+ *     p b.step(1) #=> OK or DONE
+ *     p [b.remaining, b.pagecount]
+ *   end while b.remaining > 0
+ *   b.finish
+ *
+ *   ddb = SQLite3::Database.new(':memory:')
+ *   b = SQLite3::Backup.new(ddb, 'main', sdb, 'main')
+ *   b.step(-1) #=> DONE
+ *   b.finish
+ *
+ */
+static VALUE
+initialize(VALUE self, VALUE dstdb, VALUE dstname, VALUE srcdb, VALUE srcname)
+{
+    sqlite3BackupRubyPtr ctx;
+    sqlite3RubyPtr ddb_ctx, sdb_ctx;
+    sqlite3_backup *pBackup;
+
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    ddb_ctx = sqlite3_database_unwrap(dstdb);
+    sdb_ctx = sqlite3_database_unwrap(srcdb);
+
+    if (!sdb_ctx->db) {
+        rb_raise(rb_eArgError, "cannot backup from a closed database");
+    }
+    if (!ddb_ctx->db) {
+        rb_raise(rb_eArgError, "cannot backup to a closed database");
+    }
+
+    pBackup = sqlite3_backup_init(ddb_ctx->db, StringValuePtr(dstname),
+                                  sdb_ctx->db, StringValuePtr(srcname));
+    if (pBackup) {
+        ctx->p = pBackup;
+    } else {
+        CHECK(ddb_ctx->db, sqlite3_errcode(ddb_ctx->db));
+    }
+
+    return self;
+}
+
+/* call-seq: SQLite3::Backup#step(nPage)
+ *
+ * Copy database pages up to +nPage+.
+ * If negative, copy all remaining source pages.
+ *
+ * If all pages are copied, it returns SQLite3::Constants::ErrorCode::DONE.
+ * When coping is not done, it returns SQLite3::Constants::ErrorCode::OK.
+ * When some errors occur, it returns the error code.
+ */
+static VALUE
+step(VALUE self, VALUE nPage)
+{
+    sqlite3BackupRubyPtr ctx;
+    int status;
+
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    REQUIRE_OPEN_BACKUP(ctx);
+    status = sqlite3_backup_step(ctx->p, NUM2INT(nPage));
+    return INT2NUM(status);
+}
+
+/* call-seq: SQLite3::Backup#finish
+ *
+ * Destroy the backup object.
+ */
+static VALUE
+finish(VALUE self)
+{
+    sqlite3BackupRubyPtr ctx;
+
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    REQUIRE_OPEN_BACKUP(ctx);
+    (void)sqlite3_backup_finish(ctx->p);
+    ctx->p = NULL;
+    return Qnil;
+}
+
+/* call-seq: SQLite3::Backup#remaining
+ *
+ * Returns the number of pages still to be backed up.
+ *
+ * Note that the value is only updated after step() is called,
+ * so before calling step() returned value is invalid.
+ */
+static VALUE
+remaining(VALUE self)
+{
+    sqlite3BackupRubyPtr ctx;
+
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    REQUIRE_OPEN_BACKUP(ctx);
+    return INT2NUM(sqlite3_backup_remaining(ctx->p));
+}
+
+/* call-seq: SQLite3::Backup#pagecount
+ *
+ * Returns the total number of pages in the source database file.
+ *
+ * Note that the value is only updated after step() is called,
+ * so before calling step() returned value is invalid.
+ */
+static VALUE
+pagecount(VALUE self)
+{
+    sqlite3BackupRubyPtr ctx;
+
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    REQUIRE_OPEN_BACKUP(ctx);
+    return INT2NUM(sqlite3_backup_pagecount(ctx->p));
+}
+
+void
+init_sqlite3_backup(void)
+{
+#if 0
+    VALUE mSqlite3 = rb_define_module("SQLite3");
+#endif
+    cSqlite3Backup = rb_define_class_under(mSqlite3, "Backup", rb_cObject);
+
+    rb_define_alloc_func(cSqlite3Backup, allocate);
+    rb_define_method(cSqlite3Backup, "initialize", initialize, 4);
+    rb_define_method(cSqlite3Backup, "step", step, 1);
+    rb_define_method(cSqlite3Backup, "finish", finish, 0);
+    rb_define_method(cSqlite3Backup, "remaining", remaining, 0);
+    rb_define_method(cSqlite3Backup, "pagecount", pagecount, 0);
+}
+
+#endif

data/ext/sqlite3/backup.h

@@ -0,0 +1,15 @@
+#if !defined(SQLITE3_BACKUP_RUBY) && defined(HAVE_SQLITE3_BACKUP_INIT)
+#define SQLITE3_BACKUP_RUBY
+
+#include <sqlite3_ruby.h>
+
+struct _sqlite3BackupRuby {
+    sqlite3_backup *p;
+};
+
+typedef struct _sqlite3BackupRuby sqlite3BackupRuby;
+typedef sqlite3BackupRuby *sqlite3BackupRubyPtr;
+
+void init_sqlite3_backup();
+
+#endif