extralite 3.0.1 → 3.1.0

data/ext/extralite/database.c

@@ -19,6 +19,7 @@ VALUE cParameterError;
 VALUE eArgumentError;
 
 ID ID_bind;
+ID ID_inspect;
 ID ID_call;
 ID ID_each;
 ID ID_keys;
@@ -38,6 +39,7 @@ VALUE SYM_normal;
 VALUE SYM_passive;
 VALUE SYM_read_only;
 VALUE SYM_restart;
+VALUE SYM_stmt_cache;
 VALUE SYM_truncate;
 VALUE SYM_wal;
 
@@ -58,12 +60,14 @@ static size_t Database_size(const void *ptr) {
 
 static void Database_mark(void *ptr) {
   Database_t *db = ptr;
+  rb_gc_mark_movable(db->stmt_cache);
   rb_gc_mark_movable(db->trace_proc);
   rb_gc_mark_movable(db->progress_handler.proc);
 }
 
 static void Database_compact(void *ptr) {
   Database_t *db = ptr;
+  db->stmt_cache            = rb_gc_location(db->stmt_cache);
   db->trace_proc            = rb_gc_location(db->trace_proc);
   db->progress_handler.proc = rb_gc_location(db->progress_handler.proc);
 }
@@ -83,6 +87,7 @@ static const rb_data_type_t Database_type = {
 static VALUE Database_allocate(VALUE klass) {
   Database_t *db = ALLOC(Database_t);
   db->sqlite3_db = NULL;
+  db->stmt_cache = Qnil;
   db->trace_proc = Qnil;
   db->progress_handler.proc = Qnil;
   db->progress_handler.mode = PROGRESS_NONE;
@@ -127,12 +132,17 @@ default_flags:
 }
 
 void Database_apply_opts(VALUE self, Database_t *db, VALUE opts) {
+  db->flags = DB_F_STMT_CACHE;
   if (NIL_P(opts)) goto modern_pragmas;
 
   // :gvl_release_threshold
   VALUE value = rb_hash_aref(opts, SYM_gvl_release_threshold);
   if (!NIL_P(value)) db->gvl_release_threshold = NUM2INT(value);
 
+  value = rb_hash_aref(opts, SYM_stmt_cache);
+  if (value == Qfalse)
+    db->flags &= !DB_F_STMT_CACHE;
+
   value = rb_hash_aref(opts, SYM_legacy);
   if (RTEST(value)) return;
 
@@ -175,9 +185,9 @@ int Database_busy_handler(void *ptr, int v) {
  *   `#gvl_release_threshold=`).
  * - `:read_only` (`true`/`false`): opens the database in read-only mode if true.
  * - `:legacy` (`true`/`false`): By default the database is set up for
- * concurrent access with [WAL journaling
- * mode](https://www.sqlite.org/wal.html). To prevent Extralite from setting up
- * WAL journaling, set this option to true.
+ *   concurrent access with [WAL journaling mode](https://www.sqlite.org/wal.html).
+ *   To prevent Extralite from setting up WAL journaling, set this option to true.
+ * - `:stmt_cache`: true by default, set to false to disable stmt caching
  *
  * @overload initialize(path)
  *   @param path [String] file path (or ':memory:' for memory database)
@@ -215,6 +225,7 @@ VALUE Database_initialize(int argc, VALUE *argv, VALUE self) {
   sqlite3_db_config(db->sqlite3_db ,SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, NULL);
 #endif
 
+  db->stmt_cache = rb_hash_new();
   db->trace_proc = Qnil;
   db->gvl_release_threshold = DEFAULT_GVL_RELEASE_THRESHOLD;
 
@@ -277,12 +288,13 @@ inline enum gvl_mode Database_prepare_gvl_mode(Database_t *db) {
 
 static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VALUE (*call)(query_ctx *), enum query_mode query_mode) {
   Database_t *db = self_to_open_database(self);
-  sqlite3_stmt *stmt;
+  sqlite3_stmt *stmt = NULL;
   VALUE sql = Qnil;
   VALUE transform = Qnil;
   // transform mode is set and the first parameter is not a string, so we expect
   // a transform.,
   int got_transform = (TYPE(argv[0]) != T_STRING);
+  int execute_mode = query_mode == QUERY_VOID;
 
   // extract query from args
   rb_check_arity(argc, got_transform ? 2 : 1, UNLIMITED_ARGUMENTS);
@@ -293,26 +305,38 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
     argv++;
   }
 
-  sql = rb_funcall(argv[0], ID_strip, 0);
-  if (RSTRING_LEN(sql) == 0) return Qnil;
-  // sql = argv[0];
+  sql = argv[0];
 
-  prepare_multi_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
-  RB_GC_GUARD(sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, argc - 1, argv + 1);
 
-  if (stmt == NULL) return Qnil;
-
-  bind_all_parameters(stmt, argc - 1, argv + 1);
   Database_pre_query_hook(db, stmt, sql, argc - 1, argv + 1);
-
-  query_ctx ctx = QUERY_CTX(
-    self, sql, db, stmt, Qnil, transform,
-    query_mode, ROW_YIELD_OR_MODE(ROW_MULTI), ALL_ROWS
-  );
-
-  VALUE result = rb_ensure(SAFE(call), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
-  RB_GC_GUARD(result);
-  return result;
+  if (execute_mode) {
+    exec_multi_stmt(&stmt_ctx);
+
+    query_ctx ctx = QUERY_CTX(
+      self, sql, db, NULL, Qnil, transform,
+      query_mode, ROW_YIELD_OR_MODE(ROW_MULTI), ALL_ROWS
+    );
+    ctx.flags = stmt_ctx.flags;
+    ctx.total_changes = stmt_ctx.total_changes;
+    VALUE result = (VALUE)call(&ctx);
+    return result;
+  }
+  else {
+    prep_single_stmt(&stmt_ctx);
+    query_ctx ctx = QUERY_CTX(
+      self, sql, db, stmt, Qnil, transform,
+      query_mode, ROW_YIELD_OR_MODE(ROW_MULTI), ALL_ROWS
+    );
+    ctx.flags = stmt_ctx.flags;
+    if (!stmt) return Qnil;
+
+    bind_all_parameters(stmt, argc - 1, argv + 1);
+    VALUE result = rb_ensure(SAFE(call), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+    RB_GC_GUARD(result);
+    return result;
+  }
 }
 
 /* call-seq:
@@ -490,7 +514,9 @@ VALUE Database_query_single_array(int argc, VALUE *argv, VALUE self) {
  *   db.execute(sql, *parameters) -> changes
  *
  * Runs a query returning the total changes effected. This method should be used
- * for data- or schema-manipulation queries.
+ * for data- or schema-manipulation queries. If the given SQL string contains
+ * multiple statements, they will be executed in the order given. If multiple
+ * statements are given along with query parameters, an error is raised.
  *
  * 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
@@ -506,10 +532,10 @@ VALUE Database_query_single_array(int argc, VALUE *argv, VALUE self) {
  *
  * @param sql [String] query SQL
  * @param parameters [Array, Hash] parameters to run query with
- * @return [Integer, nil] Total number of changes effected or `nil` if the query ends with a comment.
+ * @return [Integer] Total number of changes effected
  */
 VALUE Database_execute(int argc, VALUE *argv, VALUE self) {
-  return Database_perform_query(argc, argv, self, safe_query_changes, QUERY_HASH);
+  return Database_perform_query(argc, argv, self, safe_total_changes, QUERY_VOID);
 }
 
 /* call-seq:
@@ -546,7 +572,10 @@ VALUE Database_batch_execute(VALUE self, VALUE sql, VALUE parameters) {
 
   if (RSTRING_LEN(sql) == 0) return Qnil;
 
-  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, RARRAY_LEN(parameters), NULL);
+  prep_single_stmt(&stmt_ctx);
+  // prepare_xsingle_stmt(DB_GVL_MODE(db), db->stmt_cache, db->sqlite3_db, &stmt, sql, 0, NULL);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
     Qnil, QUERY_HASH, ROW_MULTI, ALL_ROWS
@@ -582,7 +611,10 @@ VALUE Database_batch_query(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
-  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, RARRAY_LEN(parameters), NULL);
+  prep_single_stmt(&stmt_ctx);
+  // prepare_xsingle_stmt(DB_GVL_MODE(db), db->stmt_cache, db->sqlite3_db, &stmt, sql, 0, NULL);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
     Qnil, QUERY_HASH, ROW_MULTI, ALL_ROWS
@@ -616,7 +648,10 @@ VALUE Database_batch_query_array(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
-  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, RARRAY_LEN(parameters), NULL);
+  prep_single_stmt(&stmt_ctx);
+  // prepare_xsingle_stmt(DB_GVL_MODE(db), db->stmt_cache, db->sqlite3_db, &stmt, sql, 0, NULL);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
     Qnil, QUERY_ARRAY, ROW_MULTI, ALL_ROWS
@@ -650,7 +685,10 @@ VALUE Database_batch_query_splat(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
-  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, RARRAY_LEN(parameters), NULL);
+  prep_single_stmt(&stmt_ctx);
+  // prepare_xsingle_stmt(DB_GVL_MODE(db), db->stmt_cache, db->sqlite3_db, &stmt, sql, 0, NULL);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
     Qnil, QUERY_SPLAT, ROW_MULTI, ALL_ROWS
@@ -1383,7 +1421,6 @@ VALUE Extralite_on_progress(int argc, VALUE *argv, VALUE self) {
  */
 VALUE Database_errcode(VALUE self) {
   Database_t *db = self_to_open_database(self);
-
   return INT2NUM(sqlite3_errcode(db->sqlite3_db));
 }
 
@@ -1393,10 +1430,19 @@ VALUE Database_errcode(VALUE self) {
  */
 VALUE Database_errmsg(VALUE self) {
   Database_t *db = self_to_open_database(self);
-
   return rb_str_new2(sqlite3_errmsg(db->sqlite3_db));
 }
 
+/* Returns the stmt cache for the database. If the database was setup with
+ * stmt_cache set to false, returns nil.
+ *
+ * @return [Hash, nil] stmt cache or nil if disabled
+ */
+VALUE Database_stmt_cache(VALUE self) {
+  Database_t *db = self_to_open_database(self);
+  return (db->flags & DB_F_STMT_CACHE) ? db->stmt_cache : Qnil;
+}
+
 #ifdef HAVE_SQLITE3_ERROR_OFFSET
 /* Returns the offset for the last error. This is useful for indicating where in
  * the SQL string an error was encountered.
@@ -1581,6 +1627,7 @@ void Init_ExtraliteDatabase(void) {
   rb_define_method(cDatabase, "columns",                Database_columns, 1);
   rb_define_method(cDatabase, "errcode",                Database_errcode, 0);
   rb_define_method(cDatabase, "errmsg",                 Database_errmsg, 0);
+  rb_define_method(cDatabase, "stmt_cache",             Database_stmt_cache, 0);
 
   #ifdef HAVE_SQLITE3_ERROR_OFFSET
   rb_define_method(cDatabase, "error_offset",           Database_error_offset, 0);
@@ -1644,6 +1691,8 @@ void Init_ExtraliteDatabase(void) {
   ID_to_s         = rb_intern_const("to_s");
   ID_track        = rb_intern_const("track");
 
+  ID_inspect  = rb_intern_const("inspect");
+
   SYM_at_least_once         = ID2SYM(rb_intern_const("at_least_once"));
   SYM_full                  = ID2SYM(rb_intern_const("full"));
   SYM_gvl_release_threshold = ID2SYM(rb_intern_const("gvl_release_threshold"));
@@ -1654,6 +1703,7 @@ void Init_ExtraliteDatabase(void) {
   SYM_passive               = ID2SYM(rb_intern_const("passive"));
   SYM_read_only             = ID2SYM(rb_intern_const("read_only"));
   SYM_restart               = ID2SYM(rb_intern_const("restart"));
+  SYM_stmt_cache            = ID2SYM(rb_intern_const("stmt_cache"));
   SYM_truncate              = ID2SYM(rb_intern_const("truncate"));
   SYM_wal                   = ID2SYM(rb_intern_const("wal"));
 
@@ -1667,6 +1717,7 @@ void Init_ExtraliteDatabase(void) {
   rb_gc_register_mark_object(SYM_passive);
   rb_gc_register_mark_object(SYM_read_only);
   rb_gc_register_mark_object(SYM_restart);
+  rb_gc_register_mark_object(SYM_stmt_cache);
   rb_gc_register_mark_object(SYM_truncate);
   rb_gc_register_mark_object(SYM_wal);
 

data/ext/extralite/extralite.h

@@ -31,6 +31,8 @@ extern VALUE cChangeset;
 extern VALUE cBlob;
 extern VALUE cTransform;
 
+extern ID ID_inspect;
+
 extern VALUE mJSON;
 
 extern VALUE cError;
@@ -68,9 +70,13 @@ struct progress_handler {
   int                         call_count;
 };
 
+#define DB_F_STMT_CACHE (1L << 0) // cache stmts
+
 typedef struct {
   sqlite3                 *sqlite3_db;
+  VALUE                   stmt_cache;
   VALUE                   trace_proc;
+  int                     flags;
   int                     gvl_release_threshold;
   struct progress_handler progress_handler;
 } Database_t;
@@ -78,7 +84,8 @@ typedef struct {
 enum query_mode {
   QUERY_HASH,
   QUERY_SPLAT,
-  QUERY_ARRAY
+  QUERY_ARRAY,
+  QUERY_VOID
 };
 
 typedef struct {
@@ -108,7 +115,6 @@ typedef struct {
 } Changeset_t;
 #endif
 
-// #define TRANSFORM_F_CONTAINER (1 << 0) // node is a container
 #define TRANSFORM_F_ARRAY     (1 << 0) // node is an array container
 #define TRANSFORM_F_IDENTITY  (1 << 1) // node is an identity column
 #define TRANSFORM_F_NAME      (1 << 2) // node has a name VALUE
@@ -159,6 +165,7 @@ typedef struct {
   Database_t          *db;
   sqlite3             *sqlite3_db;
   sqlite3_stmt        *stmt;
+  unsigned int        flags;
 
   int                 gvl_release_threshold;
   enum query_mode     query_mode;
@@ -167,6 +174,7 @@ typedef struct {
 
   int                 eof;
   int                 step_count;
+  int                 total_changes;
 } query_ctx;
 
 enum gvl_mode {
@@ -174,24 +182,36 @@ enum gvl_mode {
   GVL_HOLD
 };
 
+#define STMT_CTX_F_USE_CACHE (1L << 0)
+#define STMT_CTX_F_CACHE_HIT (1L << 1)
+
+typedef struct {
+  VALUE stmt_cache;
+  VALUE sql;
+
+  sqlite3 *db;
+  sqlite3_stmt **stmtptr;
+
+  const char *str;
+  size_t len;
+
+  enum gvl_mode gvl_mode;
+  unsigned int flags;
+  int rc;
+  int total_changes;
+  int argc;
+  VALUE *argv;
+} stmt_ctx;
+
 #define ALL_ROWS -1
 #define SINGLE_ROW -2
 #define ROW_YIELD_OR_MODE(default) (rb_block_given_p() ? ROW_YIELD : default)
 #define ROW_MULTI_P(mode) (mode == ROW_MULTI)
 #define QUERY_CTX(self, sql, db, stmt, params, transform, query_mode, row_mode, max_rows) { \
-  self, \
-  sql, \
-  params, \
-  transform, \
-  db, \
-  db->sqlite3_db, \
-  stmt, \
-  db->gvl_release_threshold, \
-  query_mode, \
-  row_mode, \
-  max_rows, \
-  0, \
-  0 \
+  self, sql, params, transform, \
+  db, db->sqlite3_db, stmt, 0, \
+  db->gvl_release_threshold, query_mode, row_mode, max_rows, \
+  0, 0, 0  \
 }
 
 #define DEFAULT_GVL_RELEASE_THRESHOLD 1000
@@ -209,6 +229,7 @@ VALUE safe_batch_query_array(query_ctx *ctx);
 VALUE safe_query_splat(query_ctx *ctx);
 VALUE safe_query_array(query_ctx *ctx);
 VALUE safe_query_changes(query_ctx *ctx);
+VALUE safe_total_changes(query_ctx *ctx);
 VALUE safe_query_columns(query_ctx *ctx);
 VALUE safe_query_hash(query_ctx *ctx);
 VALUE safe_query_transform(query_ctx *ctx);
@@ -222,8 +243,9 @@ VALUE Query_next(int argc, VALUE *argv, VALUE self);
 VALUE Query_to_a(VALUE self);
 VALUE Query_transform_set(VALUE self, VALUE transform);
 
-void prepare_single_stmt(enum gvl_mode mode, sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
-void prepare_multi_stmt(enum gvl_mode mode, sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
+void make_stmt_ctx(stmt_ctx *ctx, Database_t *db, sqlite3_stmt **stmt, VALUE sql, int argc, VALUE *argv);
+void prep_single_stmt(stmt_ctx *ctx);
+int exec_multi_stmt(stmt_ctx *ctx);
 void bind_all_parameters(sqlite3_stmt *stmt, int argc, VALUE *argv);
 void bind_all_parameters_from_object(sqlite3_stmt *stmt, VALUE obj);
 int stmt_iterate(query_ctx *ctx);

data/ext/extralite/iterator.c

@@ -25,7 +25,7 @@ static void Iterator_compact(void *ptr) {
 
 static const rb_data_type_t Iterator_type = {
     "Iterator",
-    {Iterator_mark, free, Iterator_size, Iterator_compact},
+    {Iterator_mark, xfree, Iterator_size, Iterator_compact},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 

data/ext/extralite/query.c

@@ -11,7 +11,6 @@
 
 VALUE cQuery;
 
-ID ID_inspect;
 ID ID_slice;
 
 VALUE SYM_hash;
@@ -132,9 +131,15 @@ VALUE Query_initialize(VALUE self, VALUE db, VALUE sql, VALUE mode) {
   return Qnil;
 }
 
+static inline void prep_query(Query_t *query) {
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, query->db_struct, &(query->stmt), query->sql, 0, NULL);
+  prep_single_stmt(&stmt_ctx);
+}
+
 static inline void query_reset(Query_t *query) {
   if (!query->stmt)
-    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+    prep_query(query);
   else
     sqlite3_reset(query->stmt);
 
@@ -146,7 +151,7 @@ static inline void query_reset(Query_t *query) {
 
 static inline void query_bind(Query_t *query, int argc, VALUE * argv) {
   if (!query->stmt)
-    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+    prep_query(query);
   else
     // we call sqlite3_reset because that's what the SQLite API expects before
     // changing the binding. See note at bottom of
@@ -406,8 +411,7 @@ VALUE Query_batch_execute(VALUE self, VALUE parameters) {
   Query_t *query = self_to_query_verify(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);
+  if (!query->stmt) prep_query(query);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -455,8 +459,7 @@ VALUE Query_batch_query(VALUE self, VALUE parameters) {
   Query_t *query = self_to_query_verify(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);
+  if (!query->stmt) prep_query(query);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -562,9 +565,7 @@ VALUE Query_status(int argc, VALUE* argv, VALUE self) {
   rb_scan_args(argc, argv, "11", &op, &reset);
 
   Query_t *query = self_to_query_verify(self);
-
-  if (!query->stmt)
-    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+  if (!query->stmt) prep_query(query);
 
   int value = sqlite3_stmt_status(query->stmt, NUM2INT(op), RTEST(reset) ? 1 : 0);
   return INT2NUM(value);
@@ -685,7 +686,6 @@ void Init_ExtraliteQuery(void) {
   rb_define_method(cQuery, "transform",      Query_transform_get, 0);
   rb_define_method(cQuery, "transform=",     Query_transform_set, 1);
 
-  ID_inspect  = rb_intern_const("inspect");
   ID_slice    = rb_intern_const("slice");
 
   SYM_hash    = ID2SYM(rb_intern_const("hash"));

data/lib/extralite/version.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 module Extralite
-  # Extralite version
-  VERSION = '3.0.1'
+  VERSION = '3.1.0'
 end

data/lib/extralite.rb

@@ -304,7 +304,8 @@ module Extralite
 
     def pragma_set(values)
       sql = values.inject(+'') { |s, (k, v)| s += "pragma #{k}=#{v}; " }
-      query(sql)
+      execute(sql)
+      self
     end
 
     def pragma_get(key)

data/lib/sequel/adapters/extralite.rb

@@ -86,15 +86,15 @@ module Sequel
 
     class Database < Sequel::Database
       include ::Sequel::SQLite::DatabaseMethods
-      
+
       set_adapter_scheme :extralite
-      
+
       # Mimic the file:// uri, by having 2 preceding slashes specify a relative
       # path, and 3 preceding slashes specify an absolute path.
       def self.uri_to_options(uri) # :nodoc:
         { :database => (uri.host.nil? && uri.path == '/') ? nil : "#{uri.host}#{uri.path}" }
       end
-      
+
       private_class_method :uri_to_options
 
       # The conversion procs to use for this database
@@ -129,12 +129,12 @@ module Sequel
             func.result = Regexp.new(regexp_str).match(string) ? 1 : 0
           end
         end
-        
+
         class << db
           attr_reader :prepared_statements
         end
         db.instance_variable_set(:@prepared_statements, {})
-        
+
         db
       end
 
@@ -148,7 +148,7 @@ module Sequel
       def disconnect_connection(c)
         c.close
       end
-      
+
       # Run the given SQL with the given arguments and yield each row.
       def execute(sql, opts=OPTS, &block)
         _execute(:select, sql, opts, &block)
@@ -158,7 +158,7 @@ module Sequel
       def execute_dui(sql, opts=OPTS)
         _execute(:update, sql, opts)
       end
-      
+
       # Drop any prepared statements on the connection when executing DDL.  This is because
       # prepared statements lock the table in such a way that you can't drop or alter the
       # table while a prepared statement that references it still exists.
@@ -169,11 +169,11 @@ module Sequel
           super
         end
       end
-      
+
       def execute_insert(sql, opts=OPTS)
         _execute(:insert, sql, opts)
       end
-      
+
       def freeze
         @conversion_procs.freeze
         super
@@ -194,13 +194,13 @@ module Sequel
       end
 
       private
-      
+
       def adapter_initialize
         @conversion_procs = SQLITE_TYPES.dup
         @conversion_procs['datetime'] = @conversion_procs['timestamp'] = method(:to_application_timestamp)
         set_integer_booleans
       end
-      
+
       # Yield an available connection.  Rescue
       # any Extralite::Errors and turn them into DatabaseErrors.
       def _execute(type, sql, opts, &block)
@@ -228,7 +228,7 @@ module Sequel
       rescue ::Extralite::Error => e
         raise_error(e)
       end
-      
+
       # The Extralite adapter does not need the pool to convert exceptions.
       # Also, force the max connections to 1 if a memory database is being
       # used, as otherwise each connection gets a separate database.
@@ -239,7 +239,7 @@ module Sequel
         o[:max_connections] = 1 if @opts[:database] == ':memory:' || blank_object?(@opts[:database])
         o
       end
-      
+
       def prepared_statement_argument(arg)
         case arg
         when Date, DateTime, Time
@@ -295,7 +295,7 @@ module Sequel
           end
         end
       end
-      
+
       def database_error_classes
         [::Extralite::Error]
       end
@@ -308,15 +308,15 @@ module Sequel
         exception.code if exception.respond_to?(:code)
       end
     end
-    
+
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
 
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
-        
+
         protected
-        
+
         # Return a hash with the same values as the given hash,
         # but with the keys converted to strings.
         def map_to_prepared_args(hash)
@@ -324,16 +324,16 @@ module Sequel
           hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
           args
         end
-        
+
         private
-        
+
         # Extralite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
           LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
         end
       end
-      
+
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
       PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
@@ -371,9 +371,9 @@ module Sequel
       def supports_regexp?
         db.allow_regexp?
       end
-      
+
       private
-      
+
       # The base type name for a given type, without any parenthetical part.
       def base_type_name(t)
         (t =~ /^(.*?)\(/ ? $1 : t).downcase if t