extralite 2.4 → 2.6

data/ext/extralite/extralite_ext.c

@@ -1,9 +1,19 @@
+#include "ruby.h"
+
 void Init_ExtraliteDatabase();
 void Init_ExtraliteQuery();
 void Init_ExtraliteIterator();
+#ifdef EXTRALITE_ENABLE_CHANGESET
+void Init_ExtraliteChangeset();
+#endif
 
 void Init_extralite_ext(void) {
+  rb_ext_ractor_safe(true);
+
   Init_ExtraliteDatabase();
   Init_ExtraliteQuery();
   Init_ExtraliteIterator();
+#ifdef EXTRALITE_ENABLE_CHANGESET
+  Init_ExtraliteChangeset();
+#endif
 }

data/ext/extralite/iterator.c

@@ -19,13 +19,18 @@ static size_t Iterator_size(const void *ptr) {
 
 static void Iterator_mark(void *ptr) {
   Iterator_t *iterator = ptr;
-  rb_gc_mark(iterator->query);
+  rb_gc_mark_movable(iterator->query);
+}
+
+static void Iterator_compact(void *ptr) {
+  Iterator_t *iterator = ptr;
+  iterator->query = rb_gc_location(iterator->query);
 }
 
 static const rb_data_type_t Iterator_type = {
     "Iterator",
-    {Iterator_mark, free, Iterator_size,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    {Iterator_mark, free, Iterator_size, Iterator_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static VALUE Iterator_allocate(VALUE klass) {

data/ext/extralite/query.c

@@ -14,14 +14,22 @@ VALUE cQuery;
 ID ID_inspect;
 ID ID_slice;
 
+#define DB_GVL_MODE(query) Database_prepare_gvl_mode(query->db_struct)
+
 static size_t Query_size(const void *ptr) {
   return sizeof(Query_t);
 }
 
 static void Query_mark(void *ptr) {
   Query_t *query = ptr;
-  rb_gc_mark(query->db);
-  rb_gc_mark(query->sql);
+  rb_gc_mark_movable(query->db);
+  rb_gc_mark_movable(query->sql);
+}
+
+static void Query_compact(void *ptr) {
+  Query_t *query = ptr;
+  query->db = rb_gc_location(query->db);
+  query->sql = rb_gc_location(query->sql);
 }
 
 static void Query_free(void *ptr) {
@@ -32,7 +40,7 @@ static void Query_free(void *ptr) {
 
 static const rb_data_type_t Query_type = {
     "Query",
-    {Query_mark, Query_free, Query_size,},
+    {Query_mark, Query_free, Query_size, Query_compact},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
@@ -82,19 +90,17 @@ VALUE Query_initialize(VALUE self, VALUE db, VALUE sql) {
 
 static inline void query_reset(Query_t *query) {
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
-  if (query->db_struct->trace_block != Qnil)
-    rb_funcall(query->db_struct->trace_block, ID_call, 1, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+  TRACE_SQL(query->db_struct, query->sql);
   sqlite3_reset(query->stmt);
   query->eof = 0;
 }
 
 static inline void query_reset_and_bind(Query_t *query, int argc, VALUE * argv) {
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
-  if (query->db_struct->trace_block != Qnil)
-    rb_funcall(query->db_struct->trace_block, ID_call, 1, query->sql);
+  TRACE_SQL(query->db_struct, query->sql);
 
   sqlite3_reset(query->stmt);
   query->eof = 0;
@@ -122,8 +128,7 @@ VALUE Query_reset(VALUE self) {
   if (query->closed) rb_raise(cError, "Query is closed");
 
   query_reset(query);
-  if (query->db_struct->trace_block != Qnil)
-    rb_funcall(query->db_struct->trace_block, ID_call, 1, query->sql);
+  TRACE_SQL(query->db_struct, query->sql);
 
   return self;
 }
@@ -367,27 +372,115 @@ VALUE Query_execute(int argc, VALUE *argv, VALUE self) {
   return Query_perform_next(self, ALL_ROWS, safe_query_changes);
 }
 
-/* Executes the query for each set of parameters in the given array. Parameters
- * can be specified as either an array (for unnamed parameters) or a hash (for
- * named parameters). Returns the number of changes effected. This method is
- * designed for inserting multiple records.
+/* call-seq:
+ *   query << [...] -> query
+ *   query << { ... } -> query
+ *
+ * Runs the with the given parameters, returning the total changes effected.
+ * This method should be used for data- or schema-manipulation queries.
+ *
+ * Query parameters to be bound to placeholders in the query can be specified as
+ * a list of values or as a hash mapping parameter names to values. When
+ * parameters are given as an array, the query should specify parameters using
+ * `?`:
+ *
+ *     query = db.prepare('update foo set x = ? where y = ?')
+ *     query << [42, 43]
+ *
+ * Named placeholders are specified using `:`. The placeholder values are
+ * specified using a hash, where keys are either strings are symbols. String
+ * keys can include or omit the `:` prefix. The following are equivalent:
+ *
+ *     query = db.prepare('update foo set x = :bar')
+ *     query << { bar: 42 }
+ *     query << { 'bar' => 42 }
+ *     query << { ':bar' => 42 }
+ */
+VALUE Query_execute_chevrons(VALUE self, VALUE params) {
+  Query_execute(1, &params, self);
+  return self;
+}
+
+/* call-seq:
+ *   query.batch_execute(params_array) -> changes
+ *   query.batch_execute(enumerable) -> changes
+ *   query.batch_execute(callable) -> changes
+ *
+ * Executes the query for each set of parameters in the paramter source. If an
+ * enumerable is given, it is iterated and each of its values is used as the
+ * parameters for running the query. If a callable is given, it is called
+ * repeatedly and each of its return values is used as the parameters, until nil
+ * is returned.
+ * 
+ * Returns the number of changes effected. This method is designed for inserting
+ * multiple records.
  *
  *     query = db.prepare('insert into foo values (?, ?, ?)')
  *     records = [
  *       [1, 2, 3],
  *       [4, 5, 6]
  *     ]
- *     query.execute_multi(records)
+ *     query.batch_execute(records)
+ * 
+ *     source = [
+ *       [1, 2, 3],
+ *       [4, 5, 6]
+ *     ]
+ *     query.batch_execute { records.shift }
  *
- * @param parameters [Array<Array, Hash>] array of parameters to run query with
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] array of parameters to run query with
  * @return [Integer] number of changes effected
  */
-VALUE Query_execute_multi(VALUE self, VALUE parameters) {
+VALUE Query_batch_execute(VALUE self, VALUE parameters) {
+  Query_t *query = self_to_query(self);
+  if (query->closed) rb_raise(cError, "Query is closed");
+
+  if (!query->stmt)
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+
+  query_ctx ctx = QUERY_CTX(
+    self,
+    query->db_struct,
+    query->stmt,
+    parameters,
+    QUERY_MODE(QUERY_MULTI_ROW),
+    ALL_ROWS
+  );
+  return safe_batch_execute(&ctx);
+}
+
+/* call-seq:
+ *   query.batch_query(sql, params_array) -> rows
+ *   query.batch_query(sql, enumerable) -> rows
+ *   query.batch_query(sql, callable) -> rows
+ *   query.batch_query(sql, params_array) { |rows| ... } -> changes
+ *   query.batch_query(sql, enumerable) { |rows| ... } -> changes
+ *   query.batch_query(sql, callable) { |rows| ... } -> changes
+ *
+ * Executes the prepared query for each list of parameters in the given paramter
+ * source. If a block is given, it is called with the resulting rows for each
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned.
+ *
+ *     q = db.prepare('insert into foo values (?, ?) returning bar, baz')
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     q.batch_query(records)
+ *     #=> [{ bar: 1, baz: 2 }, { bar: 3, baz: 4}]
+ * *
+ * @param sql [String] query SQL
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
+ * @return [Array<Hash>, Integer] Total number of changes effected
+ */
+VALUE Query_batch_query(VALUE self, VALUE parameters) {
   Query_t *query = self_to_query(self);
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -397,7 +490,95 @@ VALUE Query_execute_multi(VALUE self, VALUE parameters) {
     QUERY_MODE(QUERY_MULTI_ROW),
     ALL_ROWS
   );
-  return safe_execute_multi(&ctx);
+  return safe_batch_query(&ctx);
+}
+
+/* call-seq:
+ *   query.batch_query_ary(sql, params_array) -> rows
+ *   query.batch_query_ary(sql, enumerable) -> rows
+ *   query.batch_query_ary(sql, callable) -> rows
+ *   query.batch_query_ary(sql, params_array) { |rows| ... } -> changes
+ *   query.batch_query_ary(sql, enumerable) { |rows| ... } -> changes
+ *   query.batch_query_ary(sql, callable) { |rows| ... } -> changes
+ *
+ * Executes the prepared query for each list of parameters in the given paramter
+ * source. If a block is given, it is called with the resulting rows for each
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned. Rows are represented as arrays.
+ *
+ *     q = db.prepare('insert into foo values (?, ?) returning bar, baz')
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     q.batch_query_ary(records)
+ *     #=> [{ bar: 1, baz: 2 }, { bar: 3, baz: 4}]
+ * *
+ * @param sql [String] query SQL
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
+ * @return [Array<Hash>, Integer] Total number of changes effected
+ */
+VALUE Query_batch_query_ary(VALUE self, VALUE parameters) {
+  Query_t *query = self_to_query(self);
+  if (query->closed) rb_raise(cError, "Query is closed");
+
+  if (!query->stmt)
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+
+  query_ctx ctx = QUERY_CTX(
+    self,
+    query->db_struct,
+    query->stmt,
+    parameters,
+    QUERY_MODE(QUERY_MULTI_ROW),
+    ALL_ROWS
+  );
+  return safe_batch_query_ary(&ctx);
+}
+
+/* call-seq:
+ *   query.batch_query_single_column(sql, params_array) -> rows
+ *   query.batch_query_single_column(sql, enumerable) -> rows
+ *   query.batch_query_single_column(sql, callable) -> rows
+ *   query.batch_query_single_column(sql, params_array) { |rows| ... } -> changes
+ *   query.batch_query_single_column(sql, enumerable) { |rows| ... } -> changes
+ *   query.batch_query_single_column(sql, callable) { |rows| ... } -> changes
+ *
+ * Executes the prepared query for each list of parameters in the given paramter
+ * source. If a block is given, it is called with the resulting rows for each
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned. Rows are represented as single values.
+ *
+ *     q = db.prepare('insert into foo values (?, ?) returning bar, baz')
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     q.batch_query_single_column(records)
+ *     #=> [{ bar: 1, baz: 2 }, { bar: 3, baz: 4}]
+ * *
+ * @param sql [String] query SQL
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
+ * @return [Array<Hash>, Integer] Total number of changes effected
+ */
+VALUE Query_batch_query_single_column(VALUE self, VALUE parameters) {
+  Query_t *query = self_to_query(self);
+  if (query->closed) rb_raise(cError, "Query is closed");
+
+  if (!query->stmt)
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+
+  query_ctx ctx = QUERY_CTX(
+    self,
+    query->db_struct,
+    query->stmt,
+    parameters,
+    QUERY_MODE(QUERY_MULTI_ROW),
+    ALL_ROWS
+  );
+  return safe_batch_query_single_column(&ctx);
 }
 
 /* Returns the database associated with the query.
@@ -431,6 +612,19 @@ VALUE Query_columns(VALUE self) {
   return Query_perform_next(self, ALL_ROWS, safe_query_columns);
 }
 
+/* call-seq:
+ *   query.clone -> copy
+ *   query.dup -> copy
+ *
+ * Returns a new query instance for the same SQL as the original query.
+ *
+ * @return [Extralite::Query] copy of query
+ */
+VALUE Query_clone(VALUE self) {
+  Query_t *query = self_to_query(self);
+  return rb_funcall(cQuery, ID_new, 2, query->db, query->sql);
+}
+
 /* Closes the query. Attempting to run a closed query will raise an error.
  *
  * @return [Extralite::Query] self
@@ -475,7 +669,7 @@ VALUE Query_status(int argc, VALUE* argv, VALUE self) {
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
   int value = sqlite3_stmt_status(query->stmt, NUM2INT(op), RTEST(reset) ? 1 : 0);
   return INT2NUM(value);
@@ -509,8 +703,10 @@ void Init_ExtraliteQuery(void) {
   rb_define_method(cQuery, "close", Query_close, 0);
   rb_define_method(cQuery, "closed?", Query_closed_p, 0);
   rb_define_method(cQuery, "columns", Query_columns, 0);
+  rb_define_method(cQuery, "clone", Query_clone, 0);
   rb_define_method(cQuery, "database", Query_database, 0);
   rb_define_method(cQuery, "db", Query_database, 0);
+  rb_define_method(cQuery, "dup", Query_clone, 0);
 
   rb_define_method(cQuery, "each", Query_each_hash, 0);
   rb_define_method(cQuery, "each_ary", Query_each_ary, 0);
@@ -519,7 +715,11 @@ void Init_ExtraliteQuery(void) {
 
   rb_define_method(cQuery, "eof?", Query_eof_p, 0);
   rb_define_method(cQuery, "execute", Query_execute, -1);
-  rb_define_method(cQuery, "execute_multi", Query_execute_multi, 1);
+  rb_define_method(cQuery, "<<", Query_execute_chevrons, 1);
+  rb_define_method(cQuery, "batch_execute", Query_batch_execute, 1);
+  rb_define_method(cQuery, "batch_query", Query_batch_query, 1);
+  rb_define_method(cQuery, "batch_query_ary", Query_batch_query_ary, 1);
+  rb_define_method(cQuery, "batch_query_single_column", Query_batch_query_single_column, 1);
   rb_define_method(cQuery, "initialize", Query_initialize, 2);
   rb_define_method(cQuery, "inspect", Query_inspect, 0);
 

data/gemspec.rb

@@ -16,7 +16,7 @@ def common_spec(s)
   s.rdoc_options = ["--title", "extralite", "--main", "README.md"]
   s.extra_rdoc_files = ["README.md"]
   s.require_paths = ["lib"]
-  s.required_ruby_version = '>= 2.7'
+  s.required_ruby_version = '>= 3.0'
 
   s.add_development_dependency  'rake-compiler',        '1.1.6'
   s.add_development_dependency  'minitest',             '5.15.0'

data/lib/extralite/version.rb

@@ -1,4 +1,4 @@
 module Extralite
   # Extralite version
-  VERSION = '2.4'
+  VERSION = '2.6'
 end

data/lib/extralite.rb

@@ -33,16 +33,20 @@ module Extralite
   class Database
     # @!visibility private
     TABLES_SQL = <<~SQL
-      SELECT name FROM sqlite_master
+      SELECT name FROM %<db>s.sqlite_master
       WHERE type ='table'
-        AND name NOT LIKE 'sqlite_%';
+        AND name NOT LIKE 'sqlite_%%';
     SQL
 
-    # Returns the list of currently defined tables.
+    alias_method :execute_multi, :batch_execute
+
+    # Returns the list of currently defined tables. If a database name is given,
+    # returns the list of tables for the relevant attached database.
     #
+    # @param db [String] name of attached database
     # @return [Array] list of tables
-    def tables
-      query_single_column(TABLES_SQL)
+    def tables(db = 'main')
+      query_single_column(format(TABLES_SQL, db: db))
     end
 
     # Gets or sets one or more pragmas:
@@ -56,6 +60,11 @@ module Extralite
       value.is_a?(Hash) ? pragma_set(value) : pragma_get(value)
     end
 
+    # Error class used to roll back a transaction without propagating an
+    # exception.
+    class Rollback < Error
+    end
+
     # Starts a transaction and runs the given block. If an exception is raised
     # in the block, the transaction is rolled back. Otherwise, the transaction
     # is commited after running the block.
@@ -72,13 +81,56 @@ module Extralite
     
       abort = false
       yield self
-    rescue
+    rescue => e
       abort = true
-      raise
+      raise unless e.is_a?(Rollback)
     ensure
       execute(abort ? 'rollback' : 'commit')
     end
 
+    # Creates a savepoint with the given name.
+    #
+    # @param name [String, Symbol] savepoint name
+    # @return [Extralite::Database] database
+    def savepoint(name)
+      execute "savepoint #{name}"
+      self
+    end
+
+    # Release a savepoint with the given name.
+    #
+    # @param name [String, Symbol] savepoint name
+    # @return [Extralite::Database] database
+    def release(name)
+      execute "release #{name}"
+      self
+    end
+
+    # Rolls back changes to a savepoint with the given name.
+    #
+    # @param name [String, Symbol] savepoint name
+    # @return [Extralite::Database] database
+    def rollback_to(name)
+      execute "rollback to #{name}"
+      self
+    end
+
+    # Rolls back the currently active transaction. This method should only be
+    # called from within a block passed to Database#transaction. This method
+    # raises a Extralite::Rollback exception, which will stop execution of the
+    # transaction block without propagating the exception.
+    #
+    #   db.transaction do
+    #     db.execute('insert into foo (42)')
+    #     db.rollback!
+    #   end
+    #
+    # @param name [String, Symbol] savepoint name
+    # @return [Extralite::Database] database
+    def rollback!
+      raise Rollback
+    end
+
     private
 
     def pragma_set(values)
@@ -87,7 +139,11 @@ module Extralite
     end
 
     def pragma_get(key)
-      query("pragma #{key}")
+      query_single_value("pragma #{key}")
     end
   end
+
+  class Query
+    alias_method :execute_multi, :batch_execute
+  end
 end

data/test/helper.rb

@@ -7,3 +7,11 @@ require 'minitest/autorun'
 puts "sqlite3 version: #{Extralite.sqlite3_version}"
 
 IS_LINUX = RUBY_PLATFORM =~ /linux/
+SKIP_RACTOR_TESTS = !IS_LINUX || (RUBY_VERSION =~ /^3\.[01]/)
+
+module Minitest::Assertions
+  def assert_in_range exp_range, act
+    msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
+    assert exp_range.include?(act), msg
+  end
+end

data/test/issue-54.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "./lib/extralite"
+
+puts 'Connecting to database...'
+
+connection_1 = Extralite::Database.new("test.sqlite3")
+puts "#{connection_1} connected"
+connection_2 = Extralite::Database.new("test.sqlite3")
+connection_2.busy_timeout = 0
+puts "#{connection_2} connected"
+
+[connection_1, connection_2].each do |connection|
+  puts "#{connection} beginning transaction..."
+  connection.execute "begin immediate transaction"
+end
+
+[connection_1, connection_2].each do |connection|
+  puts "#{connection} rolling back transaction..."
+  connection.execute "rollback transaction"
+end

data/test/issue-59.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "./lib/extralite"
+require "benchmark"
+require "tempfile"
+require "fileutils"
+
+p sqlite_version: Extralite.sqlite3_version
+
+N = (ENV['N'] || 1000).to_i
+p N: N
+
+fn1 = '/tmp/db1'
+fn2 = '/tmp/db2'
+
+FileUtils.rm(fn1) rescue nil
+FileUtils.rm(fn2) rescue nil
+
+p fn1: fn1
+p fn2: fn2
+
+db1 = Extralite::Database.new fn1
+db1.execute "pragma journal_mode = wal;"
+db1.transaction do
+  db1.execute "create table t1 ( a integer primary key, b text );"
+  values = N.times.map { |i| "#{i}-#{rand(1000)}" }
+  db1.execute_multi "insert into t1 ( b ) values ( ? );", values
+
+  p count: db1.query_single_value("select count(*) from t1")
+  p some_rows: db1.query("select * from t1 limit 5")
+end
+
+db2 = Extralite::Database.new fn2
+db2.execute "pragma journal_mode = wal;"
+db2.execute "attach '#{fn1}' as db1;"
+db2.execute "create table t2 ( a integer primary key, b text );"
+
+p main_tables: db2.tables
+p db1_tables: db2.tables('db1')
+
+overall = Benchmark.realtime do
+  t1 = Thread.new do
+    time1 = Benchmark.realtime do
+      db2.execute "create unique index db1.t1_b_unique on t1 (b);"
+    end
+    p({ indexing: time1 })
+  end
+
+  t2 = Thread.new do
+    time2 = Benchmark.realtime do
+      (N / 10000).times do |i|
+        values = 10000.times.map { |i| "#{i}-#{rand(1000)}" }
+        db2.transaction do
+          db2.execute_multi "insert into main.t2 ( b ) values ( ? );", values
+        end
+      end
+    end
+    p({ inserting: time2 })
+    p count_t2: db2.query_single_value("select count(*) from main.t2")
+    p some_rows_t2: db2.query("select * from main.t2 limit 5")
+    end
+
+  t1.join
+  t2.join
+end
+
+p({ overall: overall })
+
+db1.close
+db2.close

data/test/perf_ary.rb

@@ -15,26 +15,25 @@ require 'fileutils'
 DB_PATH = "/tmp/extralite_sqlite3_perf-#{Time.now.to_i}-#{rand(10000)}.db"
 puts "DB_PATH = #{DB_PATH.inspect}"
 
+$sqlite3_db = SQLite3::Database.new(DB_PATH)
+$extralite_db = Extralite::Database.new(DB_PATH, gvl_release_threshold: -1)
 
 def prepare_database(count)
   db = Extralite::Database.new(DB_PATH)
-  db.query('create table if not exists foo ( a integer primary key, b text )')
-  db.query('delete from foo')
-  db.query('begin')
-  count.times { db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
-  db.query('commit')
-  db.close
+  $extralite_db.query('create table if not exists foo ( a integer primary key, b text )')
+  $extralite_db.query('delete from foo')
+  $extralite_db.query('begin')
+  count.times { $extralite_db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
+  $extralite_db.query('commit')
 end
 
 def sqlite3_run(count)
-  db = SQLite3::Database.new(DB_PATH)
-  results = db.execute('select * from foo')
+  results = $sqlite3_db.execute('select * from foo')
   raise unless results.size == count
 end
 
 def extralite_run(count)
-  db = Extralite::Database.new(DB_PATH)
-  results = db.query_ary('select * from foo')
+  results = $extralite_db.query('select * from foo')
   raise unless results.size == count
 end
 
@@ -43,12 +42,15 @@ end
 
   prepare_database(c)
 
-  Benchmark.ips do |x|
-    x.config(:time => 3, :warmup => 1)
+  bm = Benchmark.ips do |x|
+    x.config(:time => 5, :warmup => 2)
 
     x.report("sqlite3") { sqlite3_run(c) }
     x.report("extralite") { extralite_run(c) }
 
     x.compare!
   end
+  puts;
+  bm.entries.each { |e| puts "#{e.label}: #{(e.ips * c).round.to_i} rows/s" }
+  puts;
 end