extralite-bundle 1.17 → 1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 962fb4dc86efd1082438fa17a2ac74248c6a23b46e943d25b8e9c04ae257acc0
-  data.tar.gz: bc8a41fdc0b3765b5a3c9cf99761e13443b8c3dbb661059190df615189026f6d
+  metadata.gz: 6f614b88b731209821d211b3e54481829e60a374881d0e33bdd29e4510654719
+  data.tar.gz: 4c1ba63f851ac3a757e7cd3b72af4be2fc95855c3d6529d9f39f4613ae8b72f2
 SHA512:
-  metadata.gz: 7d9646dc86984688d99b515c75ee5c42bb1eed87ef97502b82abf2cbe14a8c766d1f95ca7696d8a5a563a36109a2e6f4a85e05bb8fc4552c7b2f316ac23ce183
-  data.tar.gz: a17dac12d74d7894a708758a4334ccf45fecb59d541745a196e62553c8f2bbafba7dc3f21f5d77c5d161e5dd4ebba69e9e65e8e55f365dce564f3a3d0fbf57ec
+  metadata.gz: 368d16a06c4e60a6c27568bd428848e94fa12bd0eb33204d81c9f0ac7c3e9cf6387300afb9a9be758c916500ccc50a3e83564239e7e7bd88af44eafdc3158071
+  data.tar.gz: 81ed36fc318dcd971044054638bebb14bb506de7d26326620a9548b1f3616c31c8c97c1e77cbd20cf55c86b2773ac1cc7f9cc772b238e6af3f779a627dc070fc

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.19 2022-12-01
+
+- Add `Database#execute_multi`
+- Add `PreparedStatement#execute_multi`
+
+## 1.18 2022-12-01
+
+- Fix usage with system sqlite3 lib where `load_extension` is disabled
+
 ## 1.17 2022-10-31
 
 - Fix `Database#tables` to work on older version of sqlite (pre 3.33.0)

data/Gemfile.lock

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

data/README.md

@@ -51,6 +51,7 @@ latest features and enhancements.
   queries (handy for creating/modifying schemas).
 - Get last insert rowid.
 - Get number of rows changed by last query.
+- Execute the same query with multiple parameter lists (useful for inserting records).
 - Load extensions (loading of extensions is autmatically enabled. You can find
   some useful extensions here: https://github.com/nalgeon/sqlean.)
 - Includes a [Sequel adapter](#usage-with-sequel).
@@ -123,6 +124,10 @@ db.query('select * from foo where bar = :bar', bar: 42)
 db.query('select * from foo where bar = :bar', 'bar' => 42)
 db.query('select * from foo where bar = :bar', ':bar' => 42)
 
+# insert multiple rows
+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 }]

data/ext/extralite/common.c

@@ -81,6 +81,16 @@ void bind_all_parameters(sqlite3_stmt *stmt, int argc, VALUE *argv) {
   }
 }
 
+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++)
+      bind_parameter_value(stmt, i + 1, RARRAY_AREF(obj, i));
+  }
+  else
+    bind_parameter_value(stmt, 1, obj);
+}
+
 static inline VALUE get_column_names(sqlite3_stmt *stmt, int column_count) {
   VALUE arr = rb_ary_new2(column_count);
   for (int i = 0; i < column_count; i++) {
@@ -223,7 +233,7 @@ void *stmt_iterate_without_gvl(void *ptr) {
   return NULL;
 }
 
-static inline int stmt_iterate(sqlite3_stmt *stmt, sqlite3 *db) {
+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) {
@@ -262,7 +272,8 @@ VALUE safe_query_hash(query_ctx *ctx) {
 
   while (stmt_iterate(ctx->stmt, ctx->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);
+    if (yield_to_block) rb_yield(row);
+    else                rb_ary_push(result, row);
   }
 
   RB_GC_GUARD(column_names);
@@ -284,7 +295,8 @@ VALUE safe_query_ary(query_ctx *ctx) {
 
   while (stmt_iterate(ctx->stmt, ctx->sqlite3_db)) {
     row = row_to_ary(ctx->stmt, column_count);
-    if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
+    if (yield_to_block) rb_yield(row);
+    else                rb_ary_push(result, row);
   }
 
   RB_GC_GUARD(row);
@@ -346,6 +358,22 @@ VALUE safe_query_single_value(query_ctx *ctx) {
   return value;
 }
 
+VALUE safe_execute_multi(query_ctx *ctx) {
+  int count = RARRAY_LEN(ctx->params);
+  int changes = 0;
+
+  for (int i = 0; i < count; i++) {
+    sqlite3_reset(ctx->stmt);
+    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));
+    changes += sqlite3_changes(ctx->sqlite3_db);
+  }
+
+  return INT2FIX(changes);
+}
+
 VALUE safe_query_columns(query_ctx *ctx) {
   return get_column_names(ctx->stmt, sqlite3_column_count(ctx->stmt));
 }

data/ext/extralite/database.c

@@ -77,11 +77,13 @@ VALUE Database_initialize(VALUE self, VALUE path) {
     rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
   }
 
+#ifdef HAVE_SQLITE3_ENABLE_LOAD_EXTENSION
   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));
   }
+#endif
 
   return Qnil;
 }
@@ -263,6 +265,34 @@ VALUE Database_query_single_value(int argc, VALUE *argv, VALUE self) {
   return Database_perform_query(argc, argv, self, safe_query_single_value);
 }
 
+/* call-seq:
+ *   db.execute_multi(sql, params_array) -> changes
+ *
+ * Executes the given query for each list of parameters in params_array. Returns
+ * the number of changes effected. This method is designed for inserting
+ * multiple records.
+ *
+ *     records = [
+ *       [1, 2, 3],
+ *       [4, 5, 6]
+ *     ]
+ *     db.execute_multi_query('insert into foo values (?, ?, ?)', records)
+ *
+ */
+VALUE Database_execute_multi(VALUE self, VALUE sql, VALUE params_array) {
+  Database_t *db;
+  sqlite3_stmt *stmt;
+
+  if (RSTRING_LEN(sql) == 0) return Qnil;
+
+  // prepare query ctx
+  GetOpenDatabase(self, db);
+  prepare_single_stmt(db->sqlite3_db, &stmt, sql);
+  query_ctx ctx = { self, db->sqlite3_db, stmt, params_array };
+
+  return rb_ensure(SAFE(safe_execute_multi), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+}
+
 /* call-seq:
  *   db.columns(sql) -> columns
  *
@@ -325,6 +355,7 @@ VALUE Database_transaction_active_p(VALUE self) {
   return sqlite3_get_autocommit(db->sqlite3_db) ? Qfalse : Qtrue;
 }
 
+#ifdef HAVE_SQLITE3_LOAD_EXTENSION
 /* call-seq:
  *   db.load_extension(path) -> db
  *
@@ -344,6 +375,7 @@ VALUE Database_load_extension(VALUE self, VALUE path) {
 
   return self;
 }
+#endif
 
 /* call-seq:
  *   db.prepare(sql) -> Extralite::PreparedStatement
@@ -371,13 +403,17 @@ void Init_ExtraliteDatabase() {
   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);
+  rb_define_method(cDatabase, "execute_multi", Database_execute_multi, 2);
   rb_define_method(cDatabase, "columns", Database_columns, 1);
 
   rb_define_method(cDatabase, "last_insert_rowid", Database_last_insert_rowid, 0);
   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);
+
+#ifdef HAVE_SQLITE3_LOAD_EXTENSION
   rb_define_method(cDatabase, "load_extension", Database_load_extension, 1);
+#endif
 
   rb_define_method(cDatabase, "prepare", Database_prepare, 1);
 

data/ext/extralite/extconf.rb

@@ -102,7 +102,7 @@ have_func('sqlite3_enable_load_extension')
 have_func('sqlite3_load_extension')
 
 unless have_func('sqlite3_open_v2')
-  abort "Please use a newer version of SQLite3"
+  abort 'Please use a newer version of SQLite3'
 end
 
 have_func('sqlite3_prepare_v2')

data/ext/extralite/extralite.h

@@ -46,6 +46,7 @@ typedef struct {
   VALUE self;
   sqlite3 *sqlite3_db;
   sqlite3_stmt *stmt;
+  VALUE params;
 } query_ctx;
 
 VALUE safe_query_ary(query_ctx *ctx);
@@ -53,11 +54,14 @@ VALUE safe_query_hash(query_ctx *ctx);
 VALUE safe_query_single_column(query_ctx *ctx);
 VALUE safe_query_single_row(query_ctx *ctx);
 VALUE safe_query_single_value(query_ctx *ctx);
+VALUE safe_execute_multi(query_ctx *ctx);
 VALUE safe_query_columns(query_ctx *ctx);
 
 void prepare_single_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
 void prepare_multi_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
 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(sqlite3_stmt *stmt, sqlite3 *db);
 VALUE cleanup_stmt(query_ctx *ctx);
 
 sqlite3 *Database_sqlite3_db(VALUE self);

data/ext/extralite/prepared_statement.c

@@ -53,7 +53,6 @@ VALUE PreparedStatement_initialize(VALUE self, VALUE db, VALUE sql) {
   stmt->sqlite3_db = Database_sqlite3_db(db);
   stmt->sql = sql;
 
-  // TODO: setup stmt
   prepare_single_stmt(stmt->sqlite3_db, &stmt->stmt, sql);
 
   return Qnil;
@@ -198,6 +197,32 @@ VALUE PreparedStatement_query_single_value(int argc, VALUE *argv, VALUE self) {
   return PreparedStatement_perform_query(argc, argv, self, safe_query_single_value);
 }
 
+/* call-seq:
+ *   stmt.execute_multi(params_array) -> changes
+ *
+ * Executes the prepared statment for each list of parameters in params_array.
+ * Returns the number of changes effected. This method is designed for inserting
+ * multiple records.
+ *
+ *     stmt = db.prepare('insert into foo values (?, ?, ?)')
+ *     records = [
+ *       [1, 2, 3],
+ *       [4, 5, 6]
+ *     ]
+ *     stmt.execute_multi_query(records)
+ *
+ */
+VALUE PreparedStatement_execute_multi(VALUE self, VALUE params_array) {
+  PreparedStatement_t *stmt;
+  GetPreparedStatement(self, stmt);
+
+  if (!stmt->stmt)
+    rb_raise(cError, "Prepared statement is closed");
+
+  query_ctx ctx = { self, stmt->sqlite3_db, stmt->stmt, params_array };
+  return safe_execute_multi(&ctx);
+}
+
 /* call-seq:
  *   stmt.database -> database
  *   stmt.db -> database
@@ -275,6 +300,7 @@ void Init_ExtralitePreparedStatement() {
   rb_define_method(cPreparedStatement, "query_single_row", PreparedStatement_query_single_row, -1);
   rb_define_method(cPreparedStatement, "query_single_column", PreparedStatement_query_single_column, -1);
   rb_define_method(cPreparedStatement, "query_single_value", PreparedStatement_query_single_value, -1);
+  rb_define_method(cPreparedStatement, "execute_multi", PreparedStatement_execute_multi, 1);
 
   rb_define_method(cPreparedStatement, "columns", PreparedStatement_columns, 0);
 

data/lib/extralite/version.rb

@@ -1,3 +1,3 @@
 module Extralite
-  VERSION = '1.17'
+  VERSION = '1.19'
 end

data/test/test_database.rb

@@ -207,6 +207,42 @@ end
     assert_equal [{schema_version: 33}], @db.pragma(:schema_version)
     assert_equal [{recursive_triggers: 1}], @db.pragma(:recursive_triggers)
   end
+
+  def test_execute_multi
+    @db.query('create table foo (a, b, c)')
+    assert_equal [], @db.query('select * from foo')
+
+    records = [
+      [1, '2', 3],
+      ['4', 5, 6]
+    ]
+
+    changes = @db.execute_multi('insert into foo values (?, ?, ?)', records)
+
+    assert_equal 2, changes
+    assert_equal [
+      { a: 1, b: '2', c: 3 },
+      { a: '4', b: 5, c: 6 }
+    ], @db.query('select * from foo')
+  end
+
+  def test_execute_multi_single_values
+    @db.query('create table foo (bar)')
+    assert_equal [], @db.query('select * from foo')
+
+    records = [
+      'hi',
+      'bye'
+    ]
+
+    changes = @db.execute_multi('insert into foo values (?)', records)
+
+    assert_equal 2, changes
+    assert_equal [
+      { bar: 'hi' },
+      { bar: 'bye' }
+    ], @db.query('select * from foo')
+  end
 end
 
 class ScenarioTest < MiniTest::Test

data/test/test_prepared_statement.rb

@@ -181,4 +181,23 @@ end
 
     assert_raises { p.query_single_value }
   end
+
+  def test_prepared_statement_execute_multi
+    @db.query('create table foo (a, b, c)')
+    assert_equal [], @db.query('select * from foo')
+
+    records = [
+      [1, '2', 3],
+      ['4', 5, 6]
+    ]
+
+    p = @db.prepare('insert into foo values (?, ?, ?)')
+    changes = p.execute_multi(records)
+
+    assert_equal 2, changes
+    assert_equal [
+      { a: 1, b: '2', c: 3 },
+      { a: '4', b: 5, c: 6 }
+    ], @db.query('select * from foo')
+  end  
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extralite-bundle
 version: !ruby/object:Gem::Version
-  version: '1.17'
+  version: '1.19'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-31 00:00:00.000000000 Z
+date: 2022-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler