sqlite3-ruby 1.2.5-x86-mswin32 → 1.3.0.beta.1-x86-mswin32

data/API_CHANGES.rdoc

@@ -0,0 +1,48 @@
+= API Changes
+
+* SQLite3::ResultSet used to query the database for the first row, regardless
+  of whether the user asked for it or not.  I have removed that so that rows
+  will not be returned until the user asks for them.  This is a subtle but
+  sometimes important change in behavior.
+
+  83882d2208ed189361617d5ab8532a325aaf729d
+  
+* SQLite3::Database#trace now takes either a block or an object that responds
+  to "call".  The previous implementation passed around a VALUE that was cast
+  to a void *.  This is dangerous because the value could get garbage collected
+  before the proc was called.  If the user wants data passed around with the
+  block, they should use variables available to the closure or create an
+  object.
+
+* SQLite3::Statement#step automatically converts to ruby types, where before
+  all values were automatically yielded as strings.  This will only be a
+  problem for people who were accessing information about the database that
+  wasn't previously passed through the pure ruby conversion code.
+
+* SQLite3::Database#errmsg no longer takes a parameter to return error
+  messages as UTF-16.  Do people even use that?  I opt for staying UTF-8 when
+  possible.  See test_integration.rb test_errmsg_utf16
+
+* SQLite3::Database#authorize same changes as trace
+
+* test/test_tc_database.rb was removed because we no longer use the Driver
+  design pattern.
+
+= Garbage Collection Strategy
+
+All statements keep pointers back to their respective database connections.
+The @connection instance variable on the Statement handle keeps the database
+connection alive.  Memory allocated for a statement handler will be freed in
+two cases:
+
+* close is called on the statement
+* The SQLite3::Database object gets garbage collected
+
+We can't free the memory for the statement in the garbage collection function
+for the statement handler.  The reason is because there exists a race
+condition.  We cannot guarantee the order in which objects will be garbage
+collected.  So, it is possible that a connection and a statement are up for
+garbage collection.  If the database connection were to be free'd before the
+statement, then boom.  Instead we'll be conservative and free unclosed
+statements when the connection is terminated.
+

data/{History.txt → CHANGELOG.rdoc}

@@ -1,3 +1,26 @@
+=== 1.3.0.beta.1 / 2010-05-10
+
+* Enhancements
+  * Complete rewrite of C-based adapter from SWIG to hand-crafted one [tenderlove]
+    See API_CHANGES document for details.
+    This closes: Bug #27300, Bug #27241, Patch #16020
+  * Improved UTF, Unicode, M17N, all that handling and proper BLOB handling [tenderlove, nurse]
+
+* Experimental
+  * Added API to access and load extensions. [kashif]
+    These functions maps directly into SQLite3 own enable_load_extension()
+    and load_extension() C-API functions. See SQLite3::Database API documentation for details.
+    This closes: Patches #9178
+
+* Bugfixes
+  * Corrected gem dependencies (runtime and development)
+  * Fixed threaded tests [Alexey Borzenkov]
+  * Removed GitHub gemspec
+  * Fixed "No definition for" warnings from RDoc
+  * Generate zip and tgz files for releases
+  * Added Luis Lavena as gem Author (maintainer)
+  * Prevent mkmf interfere with Mighty Snow Leopard
+
 === 1.2.5 / 25 Jul 2009
 
 * Check for illegal nil before executing SQL [Erik Veenstra]
@@ -6,6 +29,7 @@
 * Build gem binaries for Windows.
 * Improved Ruby 1.9 support compatibility.
 * Taint returned values. Patch #20325.
+* Database.open and Database.new now take an optional block [Gerrit Kaiser]
 
 
 === 1.2.4.1 (internal) / 5 Jul 2009

data/Manifest.txt

@@ -1,20 +1,24 @@
+API_CHANGES.rdoc
+CHANGELOG.rdoc
 ChangeLog.cvs
-History.txt
 LICENSE
 Manifest.txt
-README.txt
+README.rdoc
 Rakefile
-ext/sqlite3_api/extconf.rb
-ext/sqlite3_api/sqlite3_api.i
-ext/sqlite3_api/sqlite3_api_wrap.c
+ext/sqlite3/database.c
+ext/sqlite3/database.h
+ext/sqlite3/exception.c
+ext/sqlite3/exception.h
+ext/sqlite3/extconf.rb
+ext/sqlite3/sqlite3.c
+ext/sqlite3/sqlite3_ruby.h
+ext/sqlite3/statement.c
+ext/sqlite3/statement.h
 faq/faq.rb
 faq/faq.yml
 lib/sqlite3.rb
 lib/sqlite3/constants.rb
 lib/sqlite3/database.rb
-lib/sqlite3/driver/dl/api.rb
-lib/sqlite3/driver/dl/driver.rb
-lib/sqlite3/driver/native/driver.rb
 lib/sqlite3/errors.rb
 lib/sqlite3/pragmas.rb
 lib/sqlite3/resultset.rb
@@ -23,19 +27,15 @@ lib/sqlite3/translator.rb
 lib/sqlite3/value.rb
 lib/sqlite3/version.rb
 setup.rb
-tasks/benchmark.rake
 tasks/faq.rake
-tasks/gem.rake
 tasks/native.rake
 tasks/vendor_sqlite3.rake
-test/bm.rb
-test/driver/dl/tc_driver.rb
 test/helper.rb
-test/native-vs-dl.rb
 test/test_database.rb
-test/test_errors.rb
 test/test_integration.rb
 test/test_integration_open_close.rb
 test/test_integration_pending.rb
 test/test_integration_resultset.rb
 test/test_integration_statement.rb
+test/test_sqlite3.rb
+test/test_statement.rb

data/{README.txt → README.rdoc}

@@ -2,7 +2,7 @@
 
 * http://sqlite3-ruby.rubyforge.org
 * http://rubyforge.org/projects/sqlite3-ruby
-* http://github.com/jamis/sqlite3-ruby
+* http://github.com/luislavena/sqlite3-ruby
 
 == DESCRIPTION
 
@@ -30,11 +30,6 @@ If you have sqlite3 installed in a non-standard location, you can specify the lo
   gem install sqlite3-ruby -- --with-sqlite3-include=/opt/local/include \
      --with-sqlite3-lib=/opt/local/lib
 
-Also, the gem ships with the C source-code pre-built, so (as of version 1.1.1)
-you no longer need to have SWIG installed. However, if you have SWIG installed
-and you want to generate the C file yourself, you can specify the
-<code>--with-swig</code> option.
-
 == Usage
 
 For help figuring out the SQLite3/Ruby interface, check out the

data/Rakefile

@@ -1,5 +1,10 @@
-require 'rubygems'
-require 'rake'
+#
+# NOTE: Keep this file clean.
+# Add your customizations inside tasks directory.
+# Thank You.
+#
 
 # load rakefile extensions (tasks)
-Dir['tasks/*.rake'].each { |f| import f }
+Dir['tasks/*.rake'].sort.each { |f| load f }
+
+# vim: syntax=ruby

data/ext/sqlite3/database.c

@@ -0,0 +1,687 @@
+#include <sqlite3_ruby.h>
+
+#define REQUIRE_OPEN_DB(_ctxt) \
+  if(!_ctxt->db) \
+    rb_raise(rb_path2class("SQLite3::Exception"), "cannot use a closed database");
+
+VALUE cSqlite3Database;
+static VALUE sym_utf16, sym_results_as_hash, sym_type_translation;
+
+static void deallocate(void * ctx)
+{
+  sqlite3RubyPtr c = (sqlite3RubyPtr)ctx;
+  sqlite3 * db     = c->db;
+  sqlite3_stmt * stmt;
+
+  if(db) {
+    while((stmt = sqlite3_next_stmt(db, NULL)) != NULL) {
+      sqlite3_finalize(stmt);
+    }
+    sqlite3_close(db);
+  }
+  xfree(c);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  sqlite3RubyPtr ctx = xcalloc((size_t)1, sizeof(sqlite3Ruby));
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+}
+
+static char *
+utf16_string_value_ptr(VALUE str)
+{
+  StringValue(str);
+  rb_str_buf_cat(str, "\x00", 1L);
+  return RSTRING_PTR(str);
+}
+
+/* call-seq: SQLite3::Database.new(file, options = {})
+ *
+ * Create a new Database object that opens the given file. If utf16
+ * is +true+, the filename is interpreted as a UTF-16 encoded string.
+ *
+ * By default, the new database will return result rows as arrays
+ * (#results_as_hash) and has type translation disabled (#type_translation=).
+ */
+static VALUE initialize(int argc, VALUE *argv, VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  VALUE file;
+  VALUE opts;
+  VALUE zvfs;
+  int status;
+
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+
+  rb_scan_args(argc, argv, "12", &file, &opts, &zvfs);
+  if(NIL_P(opts)) opts = rb_hash_new();
+
+#ifdef HAVE_RUBY_ENCODING_H
+  if(UTF16_LE_P(file)) {
+    status = sqlite3_open16(utf16_string_value_ptr(file), &ctx->db);
+  } else {
+#endif
+
+    if(Qtrue == rb_hash_aref(opts, sym_utf16)) {
+      status = sqlite3_open16(utf16_string_value_ptr(file), &ctx->db);
+    } else {
+
+#ifdef HAVE_RUBY_ENCODING_H
+      if(!UTF8_P(file)) {
+        file = rb_str_export_to_enc(file, rb_utf8_encoding());
+      }
+#endif
+
+      status = sqlite3_open_v2(
+          StringValuePtr(file),
+          &ctx->db,
+          SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+          NIL_P(zvfs) ? NULL : StringValuePtr(zvfs)
+      );
+    }
+
+#ifdef HAVE_RUBY_ENCODING_H
+  }
+#endif
+
+  CHECK(ctx->db, status)
+
+  rb_iv_set(self, "@tracefunc", Qnil);
+  rb_iv_set(self, "@authorizer", Qnil);
+  rb_iv_set(self, "@encoding", Qnil);
+  rb_iv_set(self, "@busy_handler", Qnil);
+  rb_iv_set(self, "@results_as_hash", rb_hash_aref(opts, sym_results_as_hash));
+  rb_iv_set(self, "@type_translation", rb_hash_aref(opts, sym_type_translation));
+
+  if(rb_block_given_p()) {
+    rb_yield(self);
+    rb_funcall(self, rb_intern("close"), 0);
+  }
+
+  return self;
+}
+
+/* call-seq: db.close
+ *
+ * Closes this database.
+ */
+static VALUE sqlite3_rb_close(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  sqlite3 * db;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+
+  db = ctx->db;
+  CHECK(db, sqlite3_close(ctx->db));
+
+  ctx->db = NULL;
+
+  return self;
+}
+
+/* call-seq: db.closed?
+ *
+ * Returns +true+ if this database instance has been closed (see #close).
+ */
+static VALUE closed_p(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+
+  if(!ctx->db) return Qtrue;
+
+  return Qfalse;
+}
+
+/* call-seq: total_changes
+ *
+ * Returns the total number of changes made to this database instance
+ * since it was opened.
+ */
+static VALUE total_changes(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  return INT2NUM((long)sqlite3_total_changes(ctx->db));
+}
+
+static void tracefunc(void * data, const char *sql)
+{
+  VALUE self = (VALUE)data;
+  VALUE thing = rb_iv_get(self, "@tracefunc");
+  rb_funcall(thing, rb_intern("call"), 1, rb_str_new2(sql));
+}
+
+/* call-seq:
+ *    trace { |sql| ... }
+ *    trace(Class.new { def call sql; end }.new)
+ *
+ * Installs (or removes) a block that will be invoked for every SQL
+ * statement executed. The block receives one parameter: the SQL statement
+ * executed. If the block is +nil+, any existing tracer will be uninstalled.
+ */
+static VALUE trace(int argc, VALUE *argv, VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  VALUE block;
+
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  rb_scan_args(argc, argv, "01", &block);
+
+  if(NIL_P(block) && rb_block_given_p()) block = rb_block_proc();
+
+  rb_iv_set(self, "@tracefunc", block);
+
+  sqlite3_trace(ctx->db, NIL_P(block) ? NULL : tracefunc, (void *)self);
+
+  return self;
+}
+
+static int rb_sqlite3_busy_handler(void * ctx, int count)
+{
+  VALUE self = (VALUE)(ctx);
+  VALUE handle = rb_iv_get(self, "@busy_handler");
+  VALUE result = rb_funcall(handle, rb_intern("call"), 1, INT2NUM((long)count));
+
+  if(Qfalse == result) return 0;
+
+  return 1;
+}
+
+/* call-seq:
+ *    busy_handler { |count| ... }
+ *    busy_handler(Class.new { def call count; end }.new)
+ *
+ * Register a busy handler with this database instance. When a requested
+ * resource is busy, this handler will be invoked. If the handler returns
+ * +false+, the operation will be aborted; otherwise, the resource will
+ * be requested again.
+ *
+ * The handler will be invoked with the name of the resource that was
+ * busy, and the number of times it has been retried.
+ *
+ * See also the mutually exclusive #busy_timeout.
+ */
+static VALUE busy_handler(int argc, VALUE *argv, VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  VALUE block;
+  int status;
+
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  rb_scan_args(argc, argv, "01", &block);
+
+  if(NIL_P(block) && rb_block_given_p()) block = rb_block_proc();
+
+  rb_iv_set(self, "@busy_handler", block);
+
+  status = sqlite3_busy_handler(
+      ctx->db, NIL_P(block) ? NULL : rb_sqlite3_busy_handler, (void *)self);
+
+  CHECK(ctx->db, status);
+
+  return self;
+}
+
+/* call-seq: last_insert_row_id
+ *
+ * Obtains the unique row ID of the last row to be inserted by this Database
+ * instance.
+ */
+static VALUE last_insert_row_id(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  return LL2NUM(sqlite3_last_insert_rowid(ctx->db));
+}
+
+static VALUE sqlite3val2rb(sqlite3_value * val)
+{
+  switch(sqlite3_value_type(val)) {
+    case SQLITE_INTEGER:
+      return LL2NUM(sqlite3_value_int64(val));
+      break;
+    case SQLITE_FLOAT:
+      return rb_float_new(sqlite3_value_double(val));
+      break;
+    case SQLITE_TEXT:
+      return rb_tainted_str_new2((const char *)sqlite3_value_text(val));
+      break;
+    case SQLITE_BLOB:
+      return rb_tainted_str_new2((const char *)sqlite3_value_blob(val));
+      break;
+    case SQLITE_NULL:
+      return Qnil;
+      break;
+    default:
+      rb_raise(rb_eRuntimeError, "bad type"); /* FIXME */
+  }
+}
+
+static void set_sqlite3_func_result(sqlite3_context * ctx, VALUE result)
+{
+  switch(TYPE(result)) {
+    case T_NIL:
+      sqlite3_result_null(ctx);
+      break;
+    case T_FIXNUM:
+      sqlite3_result_int64(ctx, (sqlite3_int64)FIX2LONG(result));
+      break;
+    case T_BIGNUM:
+#if SIZEOF_LONG < 8
+      if (RBIGNUM_LEN(result) * SIZEOF_BDIGITS <= 8) {
+          sqlite3_result_int64(ctx, NUM2LL(result));
+          break;
+      }
+#endif
+    case T_FLOAT:
+      sqlite3_result_double(ctx, NUM2DBL(result));
+      break;
+    case T_STRING:
+      sqlite3_result_text(
+          ctx,
+          (const char *)StringValuePtr(result),
+          (int)RSTRING_LEN(result),
+          SQLITE_TRANSIENT
+      );
+      break;
+    default:
+      rb_raise(rb_eRuntimeError, "can't return %s",
+          rb_class2name(CLASS_OF(result)));
+  }
+}
+
+static void rb_sqlite3_func(sqlite3_context * ctx, int argc, sqlite3_value **argv)
+{
+  VALUE callable = (VALUE)sqlite3_user_data(ctx);
+  VALUE * params = NULL;
+  VALUE result;
+  int i;
+
+  if (argc > 0) {
+    params = xcalloc((size_t)argc, sizeof(VALUE *));
+
+    for(i = 0; i < argc; i++) {
+      params[i] = sqlite3val2rb(argv[i]);
+    }
+  }
+
+  result = rb_funcall2(callable, rb_intern("call"), argc, params);
+  xfree(params);
+
+  set_sqlite3_func_result(ctx, result);
+}
+
+#ifndef HAVE_RB_PROC_ARITY
+int rb_proc_arity(VALUE self)
+{
+  return (int)NUM2INT(rb_funcall(self, rb_intern("arity"), 0));
+}
+#endif
+
+/* call-seq: define_function(name) { |args,...| }
+ *
+ * Define a function named +name+ with +args+.  The arity of the block
+ * will be used as the arity for the function defined.
+ */
+static VALUE define_function(VALUE self, VALUE name)
+{
+  sqlite3RubyPtr ctx;
+  VALUE block;
+  int status;
+
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  block = rb_block_proc();
+
+  status = sqlite3_create_function(
+    ctx->db,
+    StringValuePtr(name),
+    rb_proc_arity(block),
+    SQLITE_UTF8,
+    (void *)block,
+    rb_sqlite3_func,
+    NULL,
+    NULL
+  );
+
+  CHECK(ctx->db, status);
+
+  return self;
+}
+
+static int sqlite3_obj_method_arity(VALUE obj, ID id)
+{
+  VALUE method = rb_funcall(obj, rb_intern("method"), 1, ID2SYM(id));
+  VALUE arity  = rb_funcall(method, rb_intern("arity"), 0);
+
+  return (int)NUM2INT(arity);
+}
+
+static void rb_sqlite3_step(sqlite3_context * ctx, int argc, sqlite3_value **argv)
+{
+  VALUE callable = (VALUE)sqlite3_user_data(ctx);
+  VALUE * params = NULL;
+  int i;
+
+  if (argc > 0) {
+    params = xcalloc((size_t)argc, sizeof(VALUE *));
+    for(i = 0; i < argc; i++) {
+      params[i] = sqlite3val2rb(argv[i]);
+    }
+  }
+  rb_funcall2(callable, rb_intern("step"), argc, params);
+  xfree(params);
+}
+
+static void rb_sqlite3_final(sqlite3_context * ctx)
+{
+  VALUE callable = (VALUE)sqlite3_user_data(ctx);
+  VALUE result = rb_funcall(callable, rb_intern("finalize"), 0);
+  set_sqlite3_func_result(ctx, result);
+}
+
+/* call-seq: define_aggregator(name, aggregator)
+ *
+ * Define an aggregate function named +name+ using the object +aggregator+.
+ * +aggregator+ must respond to +step+ and +finalize+.  +step+ will be called
+ * with row information and +finalize+ must return the return value for the
+ * aggregator function.
+ */
+static VALUE define_aggregator(VALUE self, VALUE name, VALUE aggregator)
+{
+  sqlite3RubyPtr ctx;
+  int arity, status;
+
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  arity = sqlite3_obj_method_arity(aggregator, rb_intern("step"));
+
+  status = sqlite3_create_function(
+    ctx->db,
+    StringValuePtr(name),
+    arity,
+    SQLITE_UTF8,
+    (void *)aggregator,
+    NULL,
+    rb_sqlite3_step,
+    rb_sqlite3_final
+  );
+
+  rb_iv_set(self, "@agregator", aggregator);
+
+  CHECK(ctx->db, status);
+
+  return self;
+}
+
+/* call-seq: interrupt
+ *
+ * Interrupts the currently executing operation, causing it to abort.
+ */
+static VALUE interrupt(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  sqlite3_interrupt(ctx->db);
+
+  return self;
+}
+
+/* call-seq: errmsg
+ *
+ * Return a string describing the last error to have occurred with this
+ * database.
+ */
+static VALUE errmsg(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  return rb_str_new2(sqlite3_errmsg(ctx->db));
+}
+
+/* call-seq: errcode
+ *
+ * Return an integer representing the last error to have occurred with this
+ * database.
+ */
+static VALUE errcode(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  return INT2NUM((long)sqlite3_errcode(ctx->db));
+}
+
+/* call-seq: complete?(sql)
+ *
+ * Return +true+ if the string is a valid (ie, parsable) SQL statement, and
+ * +false+ otherwise.
+ */
+static VALUE complete_p(VALUE UNUSED(self), VALUE sql)
+{
+  if(sqlite3_complete(StringValuePtr(sql)))
+    return Qtrue;
+
+  return Qfalse;
+}
+
+/* call-seq: changes
+ *
+ * Returns the number of changes made to this database instance by the last
+ * operation performed. Note that a "delete from table" without a where
+ * clause will not affect this value.
+ */
+static VALUE changes(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  return INT2NUM(sqlite3_changes(ctx->db));
+}
+
+static int rb_sqlite3_auth(
+    void *ctx,
+    int _action,
+    const char * _a,
+    const char * _b,
+    const char * _c,
+    const char * _d)
+{
+  VALUE self   = (VALUE)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 callback = rb_iv_get(self, "@authorizer");
+  VALUE result = rb_funcall(callback, 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;
+}
+
+/* call-seq: set_authorizer = auth
+ *
+ * Set the authorizer for this database.  +auth+ must respond to +call+, and
+ * +call+ must take 5 arguments.
+ *
+ * Installs (or removes) a block that will be invoked for every access
+ * to the database. If the block returns 0 (or +true+), the statement
+ * is allowed to proceed. Returning 1 or false causes an authorization error to
+ * occur, and returning 2 or nil causes the access to be silently denied.
+ */
+static VALUE set_authorizer(VALUE self, VALUE authorizer)
+{
+  sqlite3RubyPtr ctx;
+  int status;
+
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  status = sqlite3_set_authorizer(
+      ctx->db, NIL_P(authorizer) ? NULL : rb_sqlite3_auth, (void *)self
+  );
+
+  CHECK(ctx->db, status);
+
+  rb_iv_set(self, "@authorizer", authorizer);
+
+  return self;
+}
+
+/* call-seq: db.busy_timeout = ms
+ *
+ * Indicates that if a request for a resource terminates because that
+ * resource is busy, SQLite should sleep and retry for up to the indicated
+ * number of milliseconds. By default, SQLite does not retry
+ * busy resources. To restore the default behavior, send 0 as the
+ * +ms+ parameter.
+ *
+ * See also the mutually exclusive #busy_handler.
+ */
+static VALUE set_busy_timeout(VALUE self, VALUE timeout)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  CHECK(ctx->db, sqlite3_busy_timeout(ctx->db, (int)NUM2INT(timeout)));
+
+  return self;
+}
+
+/* call-seq: db.load_extension(file)
+ *
+ * Loads an SQLite extension library from the named file. Extension
+ * loading must be enabled using db.enable_load_extension(1) prior
+ * to calling this API.
+ */
+static VALUE load_extension(VALUE self, VALUE file)
+{
+  sqlite3RubyPtr ctx;
+  int status;
+  char *errMsg;
+  VALUE errexp;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  status = sqlite3_load_extension(ctx->db, RSTRING_PTR(file), 0, &errMsg);
+  if (status != SQLITE_OK)
+  {
+    errexp = rb_exc_new2(rb_eRuntimeError, errMsg);
+    sqlite3_free(errMsg);
+    rb_exc_raise(errexp);
+  }
+
+  return self;
+}
+
+/* call-seq: db.enable_load_extension(onoff)
+ *
+ * Enable or disable extension loading.
+ */
+static VALUE enable_load_extension(VALUE self, VALUE onoff)
+{
+  sqlite3RubyPtr ctx;
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  CHECK(ctx->db, sqlite3_enable_load_extension(ctx->db, (int)NUM2INT(onoff)));
+
+  return self;
+}
+
+#ifdef HAVE_RUBY_ENCODING_H
+static int enc_cb(void * _self, int UNUSED(columns), char **data, char **UNUSED(names))
+{
+  VALUE self = (VALUE)_self;
+
+  int index = rb_enc_find_index(data[0]);
+  rb_encoding * e = rb_enc_from_index(index);
+  rb_iv_set(self, "@encoding", rb_enc_from_encoding(e));
+
+  return 0;
+}
+
+/* call-seq: db.encoding
+ *
+ * Fetch the encoding set on this database
+ */
+static VALUE db_encoding(VALUE self)
+{
+  sqlite3RubyPtr ctx;
+  VALUE enc;
+
+  Data_Get_Struct(self, sqlite3Ruby, ctx);
+  REQUIRE_OPEN_DB(ctx);
+
+  enc = rb_iv_get(self, "@encoding");
+
+  if(NIL_P(enc)) {
+    sqlite3_exec(ctx->db, "PRAGMA encoding", enc_cb, (void *)self, NULL);
+  }
+
+  return rb_iv_get(self, "@encoding");
+}
+#endif
+
+void init_sqlite3_database()
+{
+  ID id_utf16, id_results_as_hash, id_type_translation;
+#if 0
+  VALUE mSqlite3 = rb_define_module("SQLite3");
+#endif
+  cSqlite3Database = rb_define_class_under(mSqlite3, "Database", rb_cObject);
+
+  rb_define_alloc_func(cSqlite3Database, allocate);
+  rb_define_method(cSqlite3Database, "initialize", initialize, -1);
+  rb_define_method(cSqlite3Database, "close", sqlite3_rb_close, 0);
+  rb_define_method(cSqlite3Database, "closed?", closed_p, 0);
+  rb_define_method(cSqlite3Database, "total_changes", total_changes, 0);
+  rb_define_method(cSqlite3Database, "trace", trace, -1);
+  rb_define_method(cSqlite3Database, "last_insert_row_id", last_insert_row_id, 0);
+  rb_define_method(cSqlite3Database, "define_function", define_function, 1);
+  rb_define_method(cSqlite3Database, "define_aggregator", define_aggregator, 2);
+  rb_define_method(cSqlite3Database, "interrupt", interrupt, 0);
+  rb_define_method(cSqlite3Database, "errmsg", errmsg, 0);
+  rb_define_method(cSqlite3Database, "errcode", errcode, 0);
+  rb_define_method(cSqlite3Database, "complete?", complete_p, 1);
+  rb_define_method(cSqlite3Database, "changes", changes, 0);
+  rb_define_method(cSqlite3Database, "authorizer=", set_authorizer, 1);
+  rb_define_method(cSqlite3Database, "busy_handler", busy_handler, -1);
+  rb_define_method(cSqlite3Database, "busy_timeout=", set_busy_timeout, 1);
+  rb_define_method(cSqlite3Database, "load_extension", load_extension, 1);
+  rb_define_method(cSqlite3Database, "enable_load_extension", enable_load_extension, 1);
+
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_define_method(cSqlite3Database, "encoding", db_encoding, 0);
+#endif
+
+  id_utf16 = rb_intern("utf16");
+  sym_utf16 = ID2SYM(id_utf16);
+  id_results_as_hash = rb_intern("results_as_hash");
+  sym_results_as_hash = ID2SYM(id_results_as_hash);
+  id_type_translation = rb_intern("type_translation");
+  sym_type_translation = ID2SYM(id_type_translation);
+}