extralite-bundle 1.26 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 566a896b52bee42cadd627b119dc198f7ee8b958acb7c2d73f8f5e77c4dc19e9
-  data.tar.gz: 7e95e8d41d675aea693e5f79442f1d8d484ea8b2fde52d1e8105bfd0241b9428
+  metadata.gz: '065380a4b010e7a2e34c7f79ac1e1b2aae0a999e73f8a1263f47332de7257190'
+  data.tar.gz: 8dcad5df68d791e4411e347ae55b88a61a4fef7f93e33200cdd144716f17e087
 SHA512:
-  metadata.gz: c4c392e07f2375665e2be172b3b0fafda12832bb49fd0e8bafa2aa99501640695847290aef6a13cdbd11077a69bba1708a5fb9532707510e00ca48cbcbefce6b
-  data.tar.gz: bb306af730a61fdb406881ad2f090b7b60223b81830e54ff7d682573162a1d6d9745608da0ba8fcb6b4aa17c8a547c884ace734981c058b79f68e9cd23bd028b
+  metadata.gz: 6e190b0418ad9a59b08039948ae69985b3264d177990eb4e1eb80b82514502e36cf33cddb60cecd5a780d5d47fd8db47d04f9f91c0a735fbc4032e2d4cdf3c77
+  data.tar.gz: 435ab81c615f2fcd3f7a6ed49d3ba28390ae8ed9f6c25f9ddeca51c26c32e5ccbf7ab7276a8ff9f8812d8f6c27d951bb47add5f4edbd5948b05bf68ebecb6663

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+# 2.0 2023-07-08
+
+- Fix Sequel migrations (#8)
+- Redesign prepared statement functionality (#24)
+  - Rewrite `Extralite::PreparedStatement` into `Extralite::Query` with breaking API changes
+  - Add `Extralite::Iterator` class for external iteration
+  - Add `Query#each_xxx`, `Query#to_a_xxx` method
+  - Add `Query#eof?` method
+
+# 1.27 2023-06-12
+
+- Fix execution of prepared statements in Sequel adapter (#23 @gschlager)
+- Update bundled sqlite code to version 3.42.0 (#22 @gschlager)
+
 # 1.26 2023-05-17
 
 - Improve documentation

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    extralite (1.26)
+    extralite (2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     docile (1.4.0)
-    json (2.6.1)
+    json (2.6.3)
     minitest (5.15.0)
     rake (13.0.6)
     rake-compiler (1.1.6)

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Sharon Rosner
+Copyright (c) 2023 Sharon Rosner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -9,12 +9,12 @@
 
 Extralite is a super fast, extra-lightweight (about 1300 lines of C-code)
 SQLite3 wrapper for Ruby. It provides a minimal set of methods for interacting
-with an SQLite3 database, as well as prepared statements.
+with an SQLite3 database, as well as prepared queries (prepared statements).
 
 Extralite comes in two flavors: the `extralite` gem which uses the
 system-installed sqlite3 library, and the `extralite-bundle` gem which bundles
 the latest version of SQLite
-([3.40.1](https://sqlite.org/releaselog/3_40_1.html)), offering access to the
+([3.42.0](https://sqlite.org/releaselog/3_42_0.html)), offering access to the
 latest features and enhancements.
 
 ## Features
@@ -26,11 +26,11 @@ latest features and enhancements.
   as arrays, single row, single column, single value.
 - Prepared statements.
 - Parameter binding.
+- External iteration - get single records or batches of records.
 - Use system-installed sqlite3, or the [bundled latest version of
   SQLite3](#installing-the-extralite-sqlite3-bundle).
 - Improved [concurrency](#concurrency) for multithreaded apps: the Ruby GVL is
   released while preparing SQL statements and while iterating over results.
-- Iterate over records with a block, or collect records into an array.
 - Automatically execute SQL strings containing multiple semicolon-separated
   queries (handy for creating/modifying schemas).
 - Execute the same query with multiple parameter lists (useful for inserting records).
@@ -111,11 +111,37 @@ db.query('select * from foo where bar = :bar', ':bar' => 42)
 db.execute_multi('insert into foo values (?)', ['bar', 'baz'])
 db.execute_multi('insert into foo values (?, ?)', [[1, 2], [3, 4]])
 
-# prepared statements
-stmt = db.prepare('select ? as foo, ? as bar') #=> Extralite::PreparedStatement
-stmt.query(1, 2) #=> [{ :foo => 1, :bar => 2 }]
-# PreparedStatement offers the same data access methods as the Database class,
-# but without the sql parameter.
+# prepared queries
+query = db.prepare('select ? as foo, ? as bar') #=> Extralite::Query
+query.bind(1, 2) #=> [{ :foo => 1, :bar => 2 }]
+
+query.next #=> next row in result_set (as hash)
+query.next_hash #=> next row in result_set (as hash)
+query.next_ary #=> next row in result_set (as array)
+query.next_single_column #=> next row in result_set (as single value)
+
+query.next(10) #=> next 10 rows in result_set (as hash)
+query.next_hash(10) #=> next 10 rows in result_set (as hash)
+query.next_ary(10) #=> next 10 rows in result_set (as array)
+query.next_single_column(10) #=> next 10 rows in result_set (as single value)
+
+query.to_a #=> all rows as array of hashes
+query.to_a_hash #=> all rows as array of hashes
+query.to_a_ary #=> all rows as array of arrays
+query.to_a_single_column #=> all rows as array of single values
+
+query.each { |r| ... } #=> iterate over all rows as hashes
+query.each_hash { |r| ... } #=> iterate over all rows as hashes
+query.each_ary { |r| ... } #=> iterate over all rows as arrays
+query.each_single_column { |r| ... } #=> iterate over all rows as single columns
+
+iterator = query.each #=> create enumerable iterator
+iterator.next #=> next row
+iterator.each { |r| ... } #=> iterate over all rows
+values = iterator.map { |r| r[:foo] * 10 } #=> map all rows
+
+iterator = query.each_ary #=> create enumerable iterator with rows as arrays
+iterator = query.each_single_column #=> create enumerable iterator with single values
 
 # get last insert rowid
 rowid = db.last_insert_rowid
@@ -195,10 +221,10 @@ end
 
 Extralite provides methods for retrieving status information about the sqlite
 runtime, database-specific status and prepared statement-specific status,
-`Extralite.runtime_status`, `Database#status` and `PreparedStatement#status`
-respectively. You can also reset the high water mark for the specific status
-code by providing true as the reset argument. The status codes mirror those
-defined by the SQLite API. Some examples:
+`Extralite.runtime_status`, `Database#status` and `Query#status` respectively.
+You can also reset the high water mark for the specific status code by providing
+true as the reset argument. The status codes mirror those defined by the SQLite
+API. Some examples:
 
 ```ruby
 # The Extralite.runtime_status returns a tuple consisting of the current value
@@ -212,9 +238,9 @@ current, high_watermark = Extralite.runtime_status(Extralite::SQLITE_STATUS_MEMO
 # argument in order to reset the high watermark):
 current, high_watermark = db.status(Extralite::SQLITE_DBSTATUS_CACHE_USED)
 
-# The PreparedStatement#status method returns a single value (pass true as a
+# The Query#status method returns a single value (pass true as a
 # second argument in order to reset the high watermark):
-value = stmt.status(Extralite::SQLITE_STMTSTATUS_RUN)
+value = query.status(Extralite::SQLITE_STMTSTATUS_RUN)
 ```
 
 ### Working with Database Limits
@@ -302,7 +328,7 @@ large number of rows.
 |1K|502.1K rows/s|2.065M rows/s|__4.11x__|
 |100K|455.7K rows/s|2.511M rows/s|__5.51x__|
 
-### Prepared Statements
+### Prepared Queries (Prepared Statements)
 
 [Benchmark source code](https://github.com/digital-fabric/extralite/blob/main/test/perf_prepared.rb)
 

data/TODO.md

@@ -0,0 +1,5 @@
+- Add option to open database in readonly mode, use sqlite3_open_v2
+  https://sqlite.org/c3ref/open.html
+
+- Improve tracing
+- Add `#inspect` method for `Database`, `Query`, `Iterator` classes

data/ext/extralite/common.c

@@ -75,13 +75,11 @@ inline void bind_parameter_value(sqlite3_stmt *stmt, int pos, VALUE value) {
   }
 }
 
-void bind_all_parameters(sqlite3_stmt *stmt, int argc, VALUE *argv) {
-  for (int i = 0; i < argc; i++) {
-    bind_parameter_value(stmt, i + 1, argv[i]);
-  }
+inline void bind_all_parameters(sqlite3_stmt *stmt, int argc, VALUE *argv) {
+  for (int i = 0; i < argc; i++) bind_parameter_value(stmt, i + 1, argv[i]);
 }
 
-void bind_all_parameters_from_object(sqlite3_stmt *stmt, VALUE obj) {
+inline void bind_all_parameters_from_object(sqlite3_stmt *stmt, VALUE obj) {
   if (TYPE(obj) == T_ARRAY) {
     int count = RARRAY_LEN(obj);
     for (int i = 0; i < count; i++)
@@ -233,22 +231,23 @@ void *stmt_iterate_without_gvl(void *ptr) {
   return NULL;
 }
 
-int stmt_iterate(sqlite3_stmt *stmt, sqlite3 *db) {
-  struct step_ctx ctx = {stmt, 0};
-  rb_thread_call_without_gvl(stmt_iterate_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
-  switch (ctx.rc) {
+inline int stmt_iterate(query_ctx *ctx) {
+  struct step_ctx step_ctx = {ctx->stmt, 0};
+  rb_thread_call_without_gvl(stmt_iterate_without_gvl, (void *)&step_ctx, RUBY_UBF_IO, 0);
+  switch (step_ctx.rc) {
     case SQLITE_ROW:
       return 1;
     case SQLITE_DONE:
+      ctx->eof = 1;
       return 0;
     case SQLITE_BUSY:
       rb_raise(cBusyError, "Database is busy");
     case SQLITE_INTERRUPT:
       rb_raise(cInterruptError, "Query was interrupted");
     case SQLITE_ERROR:
-      rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
+      rb_raise(cSQLError, "%s", sqlite3_errmsg(ctx->sqlite3_db));
     default:
-      rb_raise(cError, "%s", sqlite3_errmsg(db));
+      rb_raise(cError, "%s", sqlite3_errmsg(ctx->sqlite3_db));
   }
 
   return 0;
@@ -260,50 +259,61 @@ VALUE cleanup_stmt(query_ctx *ctx) {
 }
 
 VALUE safe_query_hash(query_ctx *ctx) {
-  VALUE result = ctx->self;
-  int yield_to_block = rb_block_given_p();
-  VALUE row;
-  int column_count;
-  VALUE column_names;
-
-  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();
+  VALUE array = MULTI_ROW_P(ctx->mode) ? rb_ary_new() : Qnil;
+  VALUE row = Qnil;
+  int column_count = sqlite3_column_count(ctx->stmt);
+  VALUE column_names = get_column_names(ctx->stmt, column_count);
+  int row_count = 0;
 
-  while (stmt_iterate(ctx->stmt, ctx->sqlite3_db)) {
+  while (stmt_iterate(ctx)) {
     row = row_to_hash(ctx->stmt, column_count, column_names);
-    if (yield_to_block) rb_yield(row);
-    else                rb_ary_push(result, row);
+    row_count++;
+    switch (ctx->mode) {
+      case QUERY_YIELD:
+        rb_yield(row);
+        break;
+      case QUERY_MULTI_ROW:
+        rb_ary_push(array, row);
+        break;
+      case QUERY_SINGLE_ROW:
+        return row;
+    }
+    if (ctx->max_rows != ALL_ROWS && row_count >= ctx->max_rows)
+      return MULTI_ROW_P(ctx->mode) ? array : ctx->self;
   }
 
   RB_GC_GUARD(column_names);
   RB_GC_GUARD(row);
-  RB_GC_GUARD(result);
-  return result;
+  RB_GC_GUARD(array);
+  return MULTI_ROW_P(ctx->mode) ? array : Qnil;
 }
 
 VALUE safe_query_ary(query_ctx *ctx) {
-  int column_count;
-  VALUE result = ctx->self;
-  int yield_to_block = rb_block_given_p();
-  VALUE row;
-
-  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();
+  VALUE array = MULTI_ROW_P(ctx->mode) ? rb_ary_new() : Qnil;
+  VALUE row = Qnil;
+  int column_count = sqlite3_column_count(ctx->stmt);
+  int row_count = 0;
 
-  while (stmt_iterate(ctx->stmt, ctx->sqlite3_db)) {
+  while (stmt_iterate(ctx)) {
     row = row_to_ary(ctx->stmt, column_count);
-    if (yield_to_block) rb_yield(row);
-    else                rb_ary_push(result, row);
+    row_count++;
+    switch (ctx->mode) {
+      case QUERY_YIELD:
+        rb_yield(row);
+        break;
+      case QUERY_MULTI_ROW:
+        rb_ary_push(array, row);
+        break;
+      case QUERY_SINGLE_ROW:
+        return row;
+    }
+    if (ctx->max_rows != ALL_ROWS && row_count >= ctx->max_rows)
+      return MULTI_ROW_P(ctx->mode) ? array : ctx->self;
   }
 
   RB_GC_GUARD(row);
-  RB_GC_GUARD(result);
-  return result;
+  RB_GC_GUARD(array);
+  return MULTI_ROW_P(ctx->mode) ? array : Qnil;
 }
 
 VALUE safe_query_single_row(query_ctx *ctx) {
@@ -314,7 +324,7 @@ VALUE safe_query_single_row(query_ctx *ctx) {
   column_count = sqlite3_column_count(ctx->stmt);
   column_names = get_column_names(ctx->stmt, column_count);
 
-  if (stmt_iterate(ctx->stmt, ctx->sqlite3_db))
+  if (stmt_iterate(ctx))
     row = row_to_hash(ctx->stmt, column_count, column_names);
 
   RB_GC_GUARD(row);
@@ -323,26 +333,33 @@ VALUE safe_query_single_row(query_ctx *ctx) {
 }
 
 VALUE safe_query_single_column(query_ctx *ctx) {
-  int column_count;
-  VALUE result = ctx->self;
-  int yield_to_block = rb_block_given_p();
-  VALUE value;
-
-  column_count = sqlite3_column_count(ctx->stmt);
-  if (column_count != 1)
-    rb_raise(cError, "Expected query result to have 1 column");
+  VALUE array = MULTI_ROW_P(ctx->mode) ? rb_ary_new() : Qnil;
+  VALUE value = Qnil;
+  int column_count = sqlite3_column_count(ctx->stmt);
+  int row_count = 0;
 
-  // block not given, so prepare the array of records to be returned
-  if (!yield_to_block) result = rb_ary_new();
+  if (column_count != 1) rb_raise(cError, "Expected query result to have 1 column");
 
-  while (stmt_iterate(ctx->stmt, ctx->sqlite3_db)) {
+  while (stmt_iterate(ctx)) {
     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);
+    row_count++;
+    switch (ctx->mode) {
+      case QUERY_YIELD:
+        rb_yield(value);
+        break;
+      case QUERY_MULTI_ROW:
+        rb_ary_push(array, value);
+        break;
+      case QUERY_SINGLE_ROW:
+        return value;
+    }
+    if (ctx->max_rows != ALL_ROWS && row_count >= ctx->max_rows)
+      return MULTI_ROW_P(ctx->mode) ? array : ctx->self;
   }
 
   RB_GC_GUARD(value);
-  RB_GC_GUARD(result);
-  return result;
+  RB_GC_GUARD(array);
+  return MULTI_ROW_P(ctx->mode) ? array : Qnil;
 }
 
 VALUE safe_query_single_value(query_ctx *ctx) {
@@ -353,7 +370,7 @@ VALUE safe_query_single_value(query_ctx *ctx) {
   if (column_count != 1)
     rb_raise(cError, "Expected query result to have 1 column");
 
-  if (stmt_iterate(ctx->stmt, ctx->sqlite3_db))
+  if (stmt_iterate(ctx))
     value = get_column_value(ctx->stmt, 0, sqlite3_column_type(ctx->stmt, 0));
 
   RB_GC_GUARD(value);
@@ -369,7 +386,7 @@ VALUE safe_execute_multi(query_ctx *ctx) {
     sqlite3_clear_bindings(ctx->stmt);
     bind_all_parameters_from_object(ctx->stmt, RARRAY_AREF(ctx->params, i));
 
-    while (stmt_iterate(ctx->stmt, ctx->sqlite3_db));
+    while (stmt_iterate(ctx));
     changes += sqlite3_changes(ctx->sqlite3_db);
   }
 

data/ext/extralite/database.c

@@ -7,6 +7,7 @@ VALUE cSQLError;
 VALUE cBusyError;
 VALUE cInterruptError;
 
+ID ID_bind;
 ID ID_call;
 ID ID_keys;
 ID ID_new;
@@ -155,7 +156,7 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
   RB_GC_GUARD(sql);
 
   bind_all_parameters(stmt, argc - 1, argv + 1);
-  query_ctx ctx = { self, db->sqlite3_db, stmt };
+  query_ctx ctx = { self, db->sqlite3_db, stmt, Qnil, QUERY_MODE(QUERY_MULTI_ROW), ALL_ROWS };
 
   return rb_ensure(SAFE(call), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
@@ -170,7 +171,7 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
  * 
  * 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 a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  * 
  *     db.query('select * from foo where x = ?', 42)
@@ -195,7 +196,7 @@ VALUE Database_query_hash(int argc, VALUE *argv, VALUE self) {
  *
  * 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 a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
  *     db.query_ary('select * from foo where x = ?', 42)
@@ -219,7 +220,7 @@ VALUE Database_query_ary(int argc, VALUE *argv, VALUE self) {
  *
  * 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 a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
  *     db.query_single_row('select * from foo where x = ?', 42)
@@ -244,7 +245,7 @@ VALUE Database_query_single_row(int argc, VALUE *argv, VALUE self) {
  *
  * 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 a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
  *     db.query_single_column('select x from foo where x = ?', 42)
@@ -268,7 +269,7 @@ VALUE Database_query_single_column(int argc, VALUE *argv, VALUE self) {
  *
  * 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 a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
  *     db.query_single_value('select x from foo where x = ?', 42)
@@ -296,7 +297,7 @@ VALUE Database_query_single_value(int argc, VALUE *argv, VALUE self) {
  *       [1, 2, 3],
  *       [4, 5, 6]
  *     ]
- *     db.execute_multi_query('insert into foo values (?, ?, ?)', records)
+ *     db.execute_multi('insert into foo values (?, ?, ?)', records)
  *
  */
 VALUE Database_execute_multi(VALUE self, VALUE sql, VALUE params_array) {
@@ -308,7 +309,7 @@ VALUE Database_execute_multi(VALUE self, VALUE sql, VALUE params_array) {
   // prepare query ctx
   GetOpenDatabase(self, db);
   prepare_single_stmt(db->sqlite3_db, &stmt, sql);
-  query_ctx ctx = { self, db->sqlite3_db, stmt, params_array };
+  query_ctx ctx = { self, db->sqlite3_db, stmt, params_array, QUERY_MODE(QUERY_MULTI_ROW), ALL_ROWS };
 
   return rb_ensure(SAFE(safe_execute_multi), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
@@ -398,12 +399,16 @@ VALUE Database_load_extension(VALUE self, VALUE path) {
 #endif
 
 /* call-seq:
- *   db.prepare(sql) -> Extralite::PreparedStatement
+ *   db.prepare(sql) -> Extralite::Query
  *
  * Creates a prepared statement with the given SQL query.
  */
-VALUE Database_prepare(VALUE self, VALUE sql) {
-  return rb_funcall(cPreparedStatement, ID_new, 2, self, sql);
+VALUE Database_prepare(int argc, VALUE *argv, VALUE self) {
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  VALUE query = rb_funcall(cQuery, ID_new, 2, self, argv[0]);
+  if (argc > 1) rb_funcallv(query, ID_bind, argc - 1, argv + 1);
+  RB_GC_GUARD(query);
+  return query;
 }
 
 /* call-seq:
@@ -540,6 +545,9 @@ VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
   backup_ctx ctx = { dst_db, dst_is_fn, backup, rb_block_given_p(), 0 };
   rb_ensure(SAFE(backup_safe_iterate), (VALUE)&ctx, SAFE(backup_cleanup), (VALUE)&ctx);
 
+  RB_GC_GUARD(src_name);
+  RB_GC_GUARD(dst_name);
+
   return self;
 }
 
@@ -717,7 +725,7 @@ void Init_ExtraliteDatabase(void) {
   rb_define_method(cDatabase, "interrupt", Database_interrupt, 0);
   rb_define_method(cDatabase, "last_insert_rowid", Database_last_insert_rowid, 0);
   rb_define_method(cDatabase, "limit", Database_limit, -1);
-  rb_define_method(cDatabase, "prepare", Database_prepare, 1);
+  rb_define_method(cDatabase, "prepare", Database_prepare, -1);
   rb_define_method(cDatabase, "query", Database_query_hash, -1);
   rb_define_method(cDatabase, "query_ary", Database_query_ary, -1);
   rb_define_method(cDatabase, "query_hash", Database_query_hash, -1);
@@ -742,6 +750,7 @@ void Init_ExtraliteDatabase(void) {
   rb_gc_register_mark_object(cBusyError);
   rb_gc_register_mark_object(cInterruptError);
 
+  ID_bind   = rb_intern("bind");
   ID_call   = rb_intern("call");
   ID_keys   = rb_intern("keys");
   ID_new    = rb_intern("new");

data/ext/extralite/extconf.rb

@@ -4,13 +4,13 @@ if ENV['EXTRALITE_BUNDLE']
   require_relative('extconf-bundle')
 else
   ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
-  
+
   require 'mkmf'
-  
+
   # :stopdoc:
-  
+
   RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
-  
+
   ldflags = cppflags = nil
   if RbConfig::CONFIG["host_os"] =~ /darwin/
     begin
@@ -25,7 +25,7 @@ else
         cppflags  = "#{brew_prefix}/include"
         pkg_conf  = "#{brew_prefix}/lib/pkgconfig"
       end
-      
+
       # pkg_config should be less error prone than parsing compiler
       # commandline options, but we need to set default ldflags and cpp flags
       # in case the user doesn't have pkg-config installed
@@ -33,13 +33,13 @@ else
     rescue
     end
   end
-  
+
   if with_config('sqlcipher')
     pkg_config("sqlcipher")
   else
     pkg_config("sqlite3")
   end
-  
+
   # --with-sqlite3-{dir,include,lib}
   if with_config('sqlcipher')
     $CFLAGS << ' -DUSING_SQLCIPHER'
@@ -47,15 +47,15 @@ else
   else
     dir_config("sqlite3", cppflags, ldflags)
   end
-  
+
   if RbConfig::CONFIG["host_os"] =~ /mswin/
     $CFLAGS << ' -W3'
   end
-  
+
   if RUBY_VERSION < '2.7'
     $CFLAGS << ' -DTAINTING_SUPPORT'
   end
-  
+
   # @!visibility private
   def asplode missing
     if RUBY_PLATFORM =~ /mingw|mswin/
@@ -70,25 +70,25 @@ else
         error
       end
     end
-    
+
     asplode('sqlite3.h')  unless find_header  'sqlite3.h'
     find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
-    
+
     have_library 'dl' # for static builds
-    
+
     if with_config('sqlcipher')
       asplode('sqlcipher') unless find_library 'sqlcipher', 'sqlite3_libversion_number'
     else
       asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
     end
-    
+
     have_func('sqlite3_enable_load_extension')
     have_func('sqlite3_load_extension')
     have_func('sqlite3_prepare_v2')
     have_func('sqlite3_error_offset')
-    
+
     $defs << "-DEXTRALITE_NO_BUNDLE"
-    
+
     dir_config('extralite_ext')
     create_makefile('extralite_ext')
   end