extralite 0.3 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8063960fd539fc0384882cf017572baefe79b9e29591d03c790951c6fad4fac0
-  data.tar.gz: 9f1c5be233721502dd0b97ffef2d195912ec029eccee977b16ca67b567299f04
+  metadata.gz: bcad0681ac1ee598acef1989d7320f4215242dcfb3dad8857e791e313b2e673b
+  data.tar.gz: c26b4ed323da3ccd965a026b7d1c738723293412d226bda3c7c6795881b73239
 SHA512:
-  metadata.gz: b674b89217ff2231d7c48f7d93917c29e84bbcb8b240216854a87b85d0c4ca5588fe821d0e6db406df04adc5c0b29aca4e24335349084e45a7d98449119a981f
-  data.tar.gz: 3f33b7ef708052e51033e2ca38f2323c8b78f95eecda2c328fba506762831e260ae03a66ff5944e4b961b22906aa42740ebdeaad1ff233f1141daded682a6d47
+  metadata.gz: f1d5ab7ba821785f24a75cfe2e0d9d9fac0dbf6f2504321e24a89a89fc783fc3a30bc10f9ee4a97340202db04a8351e730c701d11e53643b065dee5fc009014b
+  data.tar.gz: 31a6ad671bb88f74ae2ba02d0da1e8c23275816ce41f630e82bcb7003b7e3f06a5cd9a53abeeb215bbedee54aeac763445809d4add0906cfbce087ce2acbc5b9

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 1.1 2021-06-02
+
+- Add `#close`, `#closed?` methods
+
+## 1.0 2021-05-27
+
+- Refactor C code
+- Use `rb_ensure` to finalize stmt
+- Remove bundled `sqlite3.h`, use system-wide header file instead
+
+## 0.6 2021-05-25
+
+- Add more specific errors: `SQLError`, `BusyError`
+
+## 0.5 2021-05-25
+
+- Implement `Database#query_single_row`
+
+## 0.4 2021-05-24
+
+- Add support for loading extensions
+
 ## 0.3 2021-05-24
 
 - Add support for running multiple statements

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    extralite (0.3)
+    extralite (1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,24 +1,35 @@
-## Extralite
+# Extralite - a Ruby gem for working with SQLite3 databases
 
-Extralite is an extra-lightweight SQLite3 wrapper for Ruby. It provides a single
-class with a minimal set of methods to interact with an SQLite3 database.
+[![Gem Version](https://badge.fury.io/rb/extralite.svg)](http://rubygems.org/gems/extralite)
+[![Modulation Test](https://github.com/digital-fabric/extralite/workflows/Tests/badge.svg)](https://github.com/digital-fabric/extralite/actions?query=workflow%3ATests)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/digital-fabric/extralite/blob/master/LICENSE)
 
-### Features
+## What is Extralite?
 
-- A variety of ways to get back query results: row as hash, row as array, single
-  column, single value.
+Extralite is an extra-lightweight (~365 lines of C-code) SQLite3 wrapper for
+Ruby. It provides a single class with a minimal set of methods to interact with
+an SQLite3 database.
+
+## Features
+
+- A variety of methods for different data access patterns: row as hash, row as
+  array, single single row, single column, single value.
 - Iterate over records with a block, or collect records into an array.
 - Parameter binding.
+- Correctly execute strings with multiple semicolon-separated queries (handy for
+  creating/modifying schemas).
 - Get last insert rowid.
 - Get number of rows changed by last query.
+- Load extensions (loading of extensions is autmatically enabled. You can find
+  some useful extensions here: https://github.com/nalgeon/sqlean.)
 
-### Usage
+## Usage
 
 ```ruby
 require 'extralite'
 
 # open a database
-db = Extralite::Database.new('mydb')
+db = Extralite::Database.new('/tmp/my.db')
 
 # get query results as array of hashes
 db.query('select 1 as foo') #=> [{ :foo => 1 }]
@@ -34,6 +45,9 @@ db.query_ary('select 1, 2, 3') #=> [[1, 2, 3]]
 db.query_ary('select 1, 2, 3') { |r| p r }
 # [1, 2, 3]
 
+# get a single row as a hash
+db.query_single_row("select 1 as foo") #=> { :foo => 1 }
+
 # get single column query results as array of values
 db.query_single_column('select 42') #=> [42]
 # or iterate over results
@@ -49,9 +63,33 @@ db.query_hash('select ? as foo, ? as bar', 1, 2) #=> [{ :foo => 1, :bar => 2 }]
 # get last insert rowid
 rowid = db.last_insert_id
 
-# get rows changed in last query
-rows_changed = db.changes
+# get number of rows changed in last query
+number_of_rows_affected = db.changes
 
 # get db filename
-Extralite::Database.new('/tmp/my.db').filename #=> "/tmp/my.db"
+db.filename #=> "/tmp/my.db"
+
+# load an extension
+db.load_extension('/path/to/extension.so')
 ```
+
+## Why not just use the sqlite3 gem?
+
+The sqlite3-ruby gem is a popular, solid, well-maintained project, used by
+thousands of developers. I've been doing a lot of work with SQLite3 lately, and
+wanted to have a simpler API that gives me query results in a variety of ways.
+Thus extralite was born.
+
+## What about concurrency?
+
+Extralite currently does not release the GVL. This means that even if queries
+are executed on a separate thread, no other Ruby threads will be scheduled while
+SQLite3 is busy fetching the next record.
+
+In the future Extralite might be changed to release the GVL each time
+`sqlite3_step` is called.
+
+## Can I use it with an ORM like ActiveRecord or Sequel?
+
+Not yet, but you are welcome to contribute adapters for those projects. I will
+be releasing my own not-an-ORM tool in the near future.

data/ext/extralite/extralite.c

@@ -1,8 +1,11 @@
 #include <stdio.h>
 #include "ruby.h"
-#include "../sqlite3/sqlite3.h"
+#include <sqlite3.h>
 
 VALUE cError;
+VALUE cSQLError;
+VALUE cBusyError;
+ID ID_STRIP;
 
 typedef struct Database_t {
   sqlite3 *sqlite3_db;
@@ -36,6 +39,14 @@ static VALUE Database_allocate(VALUE klass) {
 #define GetDatabase(obj, database) \
   TypedData_Get_Struct((obj), Database_t, &Database_type, (database))
 
+// make sure the database is open
+#define GetOpenDatabase(obj, database) { \
+  TypedData_Get_Struct((obj), Database_t, &Database_type, (database)); \
+  if (!(database)->sqlite3_db) { \
+    rb_raise(cError, "Database is closed"); \
+  } \
+}
+
 
 VALUE Database_initialize(VALUE self, VALUE path) {
   int rc;
@@ -44,15 +55,40 @@ VALUE Database_initialize(VALUE self, VALUE path) {
 
   rc = sqlite3_open(StringValueCStr(path), &db->sqlite3_db);
   if (rc) {
-    fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db->sqlite3_db));
     sqlite3_close(db->sqlite3_db);
-    // TODO: raise error
-    return Qfalse;
+    rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
+  }
+
+  rc = sqlite3_enable_load_extension(db->sqlite3_db, 1);
+  if (rc) {
+    sqlite3_close(db->sqlite3_db);
+    rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
   }
 
   return Qnil;
 }
 
+VALUE Database_close(VALUE self) {
+  int rc;
+  Database_t *db;
+  GetDatabase(self, db);
+
+  rc = sqlite3_close(db->sqlite3_db);
+  if (rc) {
+    rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
+  }
+
+  db->sqlite3_db = 0;
+  return self;
+}
+
+VALUE Database_closed_p(VALUE self) {
+  Database_t *db;
+  GetDatabase(self, db);
+
+  return db->sqlite3_db ? Qfalse : Qtrue;
+}
+
 inline VALUE get_column_value(sqlite3_stmt *stmt, int col, int type) {
   switch (type) {
     case SQLITE_NULL:
@@ -123,6 +159,15 @@ static inline VALUE row_to_hash(sqlite3_stmt *stmt, int column_count, VALUE colu
   return row;
 }
 
+static inline VALUE row_to_ary(sqlite3_stmt *stmt, int column_count) {
+  VALUE row = rb_ary_new2(column_count);
+  for (int i = 0; i < column_count; i++) {
+    VALUE value = get_column_value(stmt, i, sqlite3_column_type(stmt, i));
+    rb_ary_push(row, value);
+  }
+  return row;
+}
+
 inline void prepare_multi_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql) {
   const char *rest = 0;
   const char *ptr = RSTRING_PTR(sql);
@@ -131,7 +176,7 @@ inline void prepare_multi_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql) {
     int rc = sqlite3_prepare(db, ptr, end - ptr, stmt, &rest);
     if (rc) {
       sqlite3_finalize(*stmt);
-      rb_raise(cError, "%s", sqlite3_errmsg(db));
+      rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
     }
 
     if (rest == end) return;
@@ -141,213 +186,227 @@ inline void prepare_multi_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql) {
     sqlite3_finalize(*stmt);
     switch (rc) {
     case SQLITE_BUSY:
-      rb_raise(cError, "Database is busy");
+      rb_raise(cBusyError, "Database is busy");
     case SQLITE_ERROR:
-      rb_raise(cError, "%s", sqlite3_errmsg(db));
+      rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
     }
     ptr = rest;
   }
 }
 
-VALUE Database_query_hash(int argc, VALUE *argv, VALUE self) {
+inline int stmt_iterate(sqlite3_stmt *stmt, sqlite3 *db) {
   int rc;
-  sqlite3_stmt* stmt;
-  int column_count;
-  Database_t *db;
-  VALUE result = self;
-  int yield_to_block = rb_block_given_p();
-  VALUE row;
-  VALUE column_names;
-  VALUE sql;
-  
-  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
-  sql = argv[0];
-  GetDatabase(self, db);
-
-  prepare_multi_stmt(db->sqlite3_db, &stmt, sql);
-  bind_all_parameters(stmt, argc, argv);
-  column_count = sqlite3_column_count(stmt);
-  column_names = get_column_names(stmt, column_count);
-
-  // block not given, so prepare the array of records to be returned
-  if (!yield_to_block) result = rb_ary_new();
-    
-step:
   rc = sqlite3_step(stmt);
   switch (rc) {
     case SQLITE_ROW:
-      row = row_to_hash(stmt, column_count, column_names);
-      if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
-      goto step;
+      return 1;
     case SQLITE_DONE:
-      break;
+      return 0;
     case SQLITE_BUSY:
-      sqlite3_finalize(stmt);
-      rb_raise(cError, "Database is busy");
+      rb_raise(cBusyError, "Database is busy");
     case SQLITE_ERROR:
-      sqlite3_finalize(stmt);
-      rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
+      rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
     default:
-      sqlite3_finalize(stmt);
       rb_raise(cError, "Invalid return code for sqlite3_step: %d", rc);
   }
-  // TODO, use ensure to finalize statement
-  sqlite3_finalize(stmt);
+
+  return 0;
+}
+
+typedef struct query_ctx {
+  VALUE self;
+  int argc;
+  VALUE *argv;
+  sqlite3_stmt *stmt;
+} query_ctx;
+
+VALUE cleanup_stmt(VALUE arg) {
+  query_ctx *ctx = (query_ctx *)arg;
+  sqlite3_finalize(ctx->stmt);
+  return Qnil;
+}
+
+#define check_arity_and_prepare_sql(argc, argv, sql) { \
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); \
+  sql = rb_funcall(argv[0], ID_STRIP, 0); \
+  if (RSTRING_LEN(sql) == 0) return Qnil; \
+}
+
+VALUE safe_query_hash(VALUE arg) {
+  query_ctx *ctx = (query_ctx *)arg;
+  Database_t *db;
+  VALUE result = ctx->self;
+  int yield_to_block = rb_block_given_p();
+  VALUE row;
+  VALUE sql;
+  int column_count;
+  VALUE column_names;
+
+  check_arity_and_prepare_sql(ctx->argc, ctx->argv, sql);
+  GetOpenDatabase(ctx->self, db);
+
+  prepare_multi_stmt(db->sqlite3_db, &ctx->stmt, sql);
+  bind_all_parameters(ctx->stmt, ctx->argc, ctx->argv);
+  column_count = sqlite3_column_count(ctx->stmt);
+  column_names = get_column_names(ctx->stmt, column_count);
+
+  // block not given, so prepare the array of records to be returned
+  if (!yield_to_block) result = rb_ary_new();
+
+  while (stmt_iterate(ctx->stmt, db->sqlite3_db)) {
+    row = row_to_hash(ctx->stmt, column_count, column_names);
+    if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
+  }
+
   RB_GC_GUARD(column_names);
   RB_GC_GUARD(row);
   RB_GC_GUARD(result);
   return result;
 }
 
-static inline VALUE row_to_ary(sqlite3_stmt *stmt, int column_count) {
-  VALUE row = rb_ary_new2(column_count);
-  for (int i = 0; i < column_count; i++) {
-    VALUE value = get_column_value(stmt, i, sqlite3_column_type(stmt, i));
-    rb_ary_push(row, value);
-  }
-  return row;
+VALUE Database_query_hash(int argc, VALUE *argv, VALUE self) {
+  query_ctx ctx = { self, argc, argv, 0 };
+  return rb_ensure(safe_query_hash, (VALUE)&ctx, cleanup_stmt, (VALUE)&ctx);
 }
 
-VALUE Database_query_ary(int argc, VALUE *argv, VALUE self) {
-  int rc;
-  sqlite3_stmt* stmt;
-  int column_count;
+VALUE safe_query_ary(VALUE arg) {
+  query_ctx *ctx = (query_ctx *)arg;
   Database_t *db;
-  VALUE result = self;
+  int column_count;
+  VALUE result = ctx->self;
   int yield_to_block = rb_block_given_p();
   VALUE row;
   VALUE sql;
 
-  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
-  sql = argv[0];
-  GetDatabase(self, db);
+  check_arity_and_prepare_sql(ctx->argc, ctx->argv, sql);
+  GetOpenDatabase(ctx->self, db);
 
-  prepare_multi_stmt(db->sqlite3_db, &stmt, sql);
-  bind_all_parameters(stmt, argc, argv);
-  column_count = sqlite3_column_count(stmt);
+  prepare_multi_stmt(db->sqlite3_db, &ctx->stmt, sql);
+  bind_all_parameters(ctx->stmt, ctx->argc, ctx->argv);
+  column_count = sqlite3_column_count(ctx->stmt);
 
   // block not given, so prepare the array of records to be returned
   if (!yield_to_block) result = rb_ary_new();
-step:
-  rc = sqlite3_step(stmt);
-  switch (rc) {
-    case SQLITE_ROW:
-      row = row_to_ary(stmt, column_count);
-      if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
-      goto step;
-    case SQLITE_DONE:
-      break;
-    case SQLITE_BUSY:
-      sqlite3_finalize(stmt);
-      rb_raise(cError, "Database is busy");
-    case SQLITE_ERROR:
-      sqlite3_finalize(stmt);
-      rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
-    default:
-      sqlite3_finalize(stmt);
-      rb_raise(cError, "Invalid return code for sqlite3_step: %d", rc);
+
+  while (stmt_iterate(ctx->stmt, db->sqlite3_db)) {
+    row = row_to_ary(ctx->stmt, column_count);
+    if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
   }
-  sqlite3_finalize(stmt);
+  
   RB_GC_GUARD(row);
   RB_GC_GUARD(result);
   return result;
 }
 
-VALUE Database_query_single_column(int argc, VALUE *argv, VALUE self) {
-  int rc;
-  sqlite3_stmt* stmt;
+VALUE Database_query_ary(int argc, VALUE *argv, VALUE self) {
+  query_ctx ctx = { self, argc, argv, 0 };
+  return rb_ensure(safe_query_ary, (VALUE)&ctx, cleanup_stmt, (VALUE)&ctx);
+}
+
+VALUE safe_query_single_row(VALUE arg) {
+  query_ctx *ctx = (query_ctx *)arg;
+  Database_t *db;
+  int column_count;
+  VALUE sql;
+  VALUE row = Qnil;
+  VALUE column_names;
+
+  check_arity_and_prepare_sql(ctx->argc, ctx->argv, sql);
+  GetOpenDatabase(ctx->self, db);
+
+  prepare_multi_stmt(db->sqlite3_db, &ctx->stmt, sql);
+  bind_all_parameters(ctx->stmt, ctx->argc, ctx->argv);
+  column_count = sqlite3_column_count(ctx->stmt);
+  column_names = get_column_names(ctx->stmt, column_count);
+
+  if (stmt_iterate(ctx->stmt, db->sqlite3_db))
+    row = row_to_hash(ctx->stmt, column_count, column_names);
+
+  RB_GC_GUARD(row);
+  RB_GC_GUARD(column_names);
+  return row;
+}
+
+VALUE Database_query_single_row(int argc, VALUE *argv, VALUE self) {
+  query_ctx ctx = { self, argc, argv, 0 };
+  return rb_ensure(safe_query_single_row, (VALUE)&ctx, cleanup_stmt, (VALUE)&ctx);
+}
+
+VALUE safe_query_single_column(VALUE arg) {
+  query_ctx *ctx = (query_ctx *)arg;
+
   int column_count;
   Database_t *db;
-  VALUE result = self;
+  VALUE result = ctx->self;
   int yield_to_block = rb_block_given_p();
   VALUE sql;
   VALUE value;
 
-  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
-  sql = argv[0];
-  GetDatabase(self, db);
+  check_arity_and_prepare_sql(ctx->argc, ctx->argv, sql);
+  GetOpenDatabase(ctx->self, db);
 
-  prepare_multi_stmt(db->sqlite3_db, &stmt, sql);
-  bind_all_parameters(stmt, argc, argv);
-  column_count = sqlite3_column_count(stmt);
+  prepare_multi_stmt(db->sqlite3_db, &ctx->stmt, sql);
+  bind_all_parameters(ctx->stmt, ctx->argc, ctx->argv);
+  column_count = sqlite3_column_count(ctx->stmt);
   if (column_count != 1)
     rb_raise(cError, "Expected query result to have 1 column");
 
   // block not given, so prepare the array of records to be returned
   if (!yield_to_block) result = rb_ary_new();
-step:
-  rc = sqlite3_step(stmt);
-  printf("rc=%d\n", rc);
-  switch (rc) {
-    case SQLITE_ROW:
-      value = get_column_value(stmt, 0, sqlite3_column_type(stmt, 0));
-      if (yield_to_block) rb_yield(value); else rb_ary_push(result, value);
-      goto step;
-    case SQLITE_DONE:
-      break;
-    case SQLITE_BUSY:
-      sqlite3_finalize(stmt);
-      rb_raise(cError, "Database is busy");
-    case SQLITE_ERROR:
-      sqlite3_finalize(stmt);
-      rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
-    default:
-      sqlite3_finalize(stmt);
-      rb_raise(cError, "Invalid return code for sqlite3_step: %d", rc);
+
+  while (stmt_iterate(ctx->stmt, db->sqlite3_db)) {
+    value = get_column_value(ctx->stmt, 0, sqlite3_column_type(ctx->stmt, 0));
+    if (yield_to_block) rb_yield(value); else rb_ary_push(result, value);
   }
 
-  sqlite3_finalize(stmt);
   RB_GC_GUARD(value);
   RB_GC_GUARD(result);
   return result;
 }
 
-VALUE Database_query_single_value(int argc, VALUE *argv, VALUE self) {
-  int rc;
-  sqlite3_stmt* stmt;
+VALUE Database_query_single_column(int argc, VALUE *argv, VALUE self) {
+  query_ctx ctx = { self, argc, argv, 0 };
+  return rb_ensure(safe_query_single_column, (VALUE)&ctx, cleanup_stmt, (VALUE)&ctx);
+}
+
+VALUE safe_query_single_value(VALUE arg) {
+  query_ctx *ctx = (query_ctx *)arg;
   int column_count;
   Database_t *db;
   VALUE sql;
   VALUE value = Qnil;
 
-  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
-  sql = argv[0];
-  GetDatabase(self, db);
+  check_arity_and_prepare_sql(ctx->argc, ctx->argv, sql);
+  GetOpenDatabase(ctx->self, db);
 
-  prepare_multi_stmt(db->sqlite3_db, &stmt, sql);
-  bind_all_parameters(stmt, argc, argv);
-  column_count = sqlite3_column_count(stmt);
+  prepare_multi_stmt(db->sqlite3_db, &ctx->stmt, sql);
+  bind_all_parameters(ctx->stmt, ctx->argc, ctx->argv);
+  column_count = sqlite3_column_count(ctx->stmt);
   if (column_count != 1)
     rb_raise(cError, "Expected query result to have 1 column");
 
-  rc = sqlite3_step(stmt);
-  switch (rc) {
-    case SQLITE_ROW:
-      value = get_column_value(stmt, 0, sqlite3_column_type(stmt, 0));
-      break;
-    case SQLITE_BUSY:
-      rb_raise(cError, "Database is busy");
-    case SQLITE_ERROR:
-      rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
-    default:
-      rb_raise(cError, "Invalid return code for sqlite3_step: %d", rc);
-  }
+  if (stmt_iterate(ctx->stmt, db->sqlite3_db))
+    value = get_column_value(ctx->stmt, 0, sqlite3_column_type(ctx->stmt, 0));
 
-  sqlite3_finalize(stmt);
   RB_GC_GUARD(value);
   return value;
 }
 
+VALUE Database_query_single_value(int argc, VALUE *argv, VALUE self) {
+  query_ctx ctx = { self, argc, argv, 0 };
+  return rb_ensure(safe_query_single_value, (VALUE)&ctx, cleanup_stmt, (VALUE)&ctx);
+}
+
 VALUE Database_last_insert_rowid(VALUE self) {
   Database_t *db;
-  GetDatabase(self, db);
+  GetOpenDatabase(self, db);
 
   return INT2NUM(sqlite3_last_insert_rowid(db->sqlite3_db));
 }
 
 VALUE Database_changes(VALUE self) {
   Database_t *db;
-  GetDatabase(self, db);
+  GetOpenDatabase(self, db);
 
   return INT2NUM(sqlite3_changes(db->sqlite3_db));
 }
@@ -356,7 +415,7 @@ VALUE Database_filename(int argc, VALUE *argv, VALUE self) {
   const char *db_name;
   const char *filename;
   Database_t *db;
-  GetDatabase(self, db);
+  GetOpenDatabase(self, db);
 
   rb_check_arity(argc, 0, 1);
   db_name = (argc == 1) ? StringValueCStr(argv[0]) : "main";
@@ -366,21 +425,39 @@ VALUE Database_filename(int argc, VALUE *argv, VALUE self) {
 
 VALUE Database_transaction_active_p(VALUE self) {
   Database_t *db;
-  GetDatabase(self, db);
+  GetOpenDatabase(self, db);
 
   return sqlite3_get_autocommit(db->sqlite3_db) ? Qfalse : Qtrue;
 }
 
+VALUE Database_load_extension(VALUE self, VALUE path) {
+  Database_t *db;
+  GetOpenDatabase(self, db);
+  char *err_msg;
+
+  int rc = sqlite3_load_extension(db->sqlite3_db, RSTRING_PTR(path), 0, &err_msg);
+  if (rc != SQLITE_OK) {
+    VALUE error = rb_exc_new2(cError, err_msg);
+    sqlite3_free(err_msg);
+    rb_exc_raise(error);
+  }
+
+  return self;
+}
+
 void Init_Extralite() {
   VALUE mExtralite = rb_define_module("Extralite");
   VALUE cDatabase = rb_define_class_under(mExtralite, "Database", rb_cObject);
   rb_define_alloc_func(cDatabase, Database_allocate);
 
   rb_define_method(cDatabase, "initialize", Database_initialize, 1);
+  rb_define_method(cDatabase, "close", Database_close, 0);
+  rb_define_method(cDatabase, "closed?", Database_closed_p, 0);
   
   rb_define_method(cDatabase, "query", Database_query_hash, -1);
   rb_define_method(cDatabase, "query_hash", Database_query_hash, -1);
   rb_define_method(cDatabase, "query_ary", Database_query_ary, -1);
+  rb_define_method(cDatabase, "query_single_row", Database_query_single_row, -1);
   rb_define_method(cDatabase, "query_single_column", Database_query_single_column, -1);
   rb_define_method(cDatabase, "query_single_value", Database_query_single_value, -1);
   
@@ -388,6 +465,11 @@ void Init_Extralite() {
   rb_define_method(cDatabase, "changes", Database_changes, 0);
   rb_define_method(cDatabase, "filename", Database_filename, -1);
   rb_define_method(cDatabase, "transaction_active?", Database_transaction_active_p, 0);
+  rb_define_method(cDatabase, "load_extension", Database_load_extension, 1);
 
   cError = rb_define_class_under(mExtralite, "Error", rb_eRuntimeError);
+  cSQLError = rb_define_class_under(mExtralite, "SQLError", cError);
+  cBusyError = rb_define_class_under(mExtralite, "BusyError", cError);
+
+  ID_STRIP = rb_intern("strip");
 }