extralite 1.18 → 1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a40752d79cd5d28d8c9367c973f86b7e6a80d05e3878b5c70a6a98e0a70f3838
-  data.tar.gz: d72e040c85a2e34a07ea513fd7b28cc558a0b8c71a8b4f211b21aa3a9f492387
+  metadata.gz: f2fbd9028327105949e5f4fcc225ccb4ec89cdb2f324d949c17c4690f8b4653f
+  data.tar.gz: 226c07bfa8e8848dc322399ee386e8f15e6bd9e41c6912850709b1cc8fd24ad3
 SHA512:
-  metadata.gz: 4bc536fb4a5590fbae92abb1f99189f57812f5440addb49964908fcb6c45f1bfea575fc2421bfd4ddddcaaf7d00e9285ea3db4db9162afe4df71c27349dd1342
-  data.tar.gz: a1a158d144c3f97f3bd281ba050419d42c95566408cb168f35f3a0fe8d328705f662fbc1c9ac22e788a44f1120ff90db7e237e8ad1f2505b29a643c05589b331
+  metadata.gz: ca3c24e4be2cedee6d20101ce56018ed9f037cbe29d4e5c6fb63116a77c988390992b770586a1973acc0c42a521389369ed79cf1553464e5f775fe420c9bf421
+  data.tar.gz: f9ffb7dbe2a5d00ea2c15cca1407462897590f299acecf88de6a040f463f4f28715ae98ae34a6a0539f97b1cf2f12902803217517014661208b6238618013287

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    extralite (1.18)
+    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

@@ -265,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
  *
@@ -375,6 +403,7 @@ 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);

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

@@ -197,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
@@ -274,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.18'
+  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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: extralite
 version: !ruby/object:Gem::Version
-  version: '1.18'
+  version: '1.19'
 platform: ruby
 authors:
 - Sharon Rosner