extralite 2.7 → 2.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -22,12 +22,16 @@ ID ID_to_s;
22
22
  ID ID_track;
23
23
 
24
24
  VALUE SYM_at_least_once;
25
+ VALUE SYM_full;
25
26
  VALUE SYM_gvl_release_threshold;
26
27
  VALUE SYM_once;
27
28
  VALUE SYM_none;
28
29
  VALUE SYM_normal;
30
+ VALUE SYM_passive;
29
31
  VALUE SYM_pragma;
30
32
  VALUE SYM_read_only;
33
+ VALUE SYM_restart;
34
+ VALUE SYM_truncate;
31
35
  VALUE SYM_wal;
32
36
 
33
37
  struct progress_handler global_progress_handler = {
@@ -342,18 +346,18 @@ VALUE Database_query(int argc, VALUE *argv, VALUE self) {
342
346
  * splatted:
343
347
  *
344
348
  * transform = ->(a, b, c) { a * 100 + b * 10 + c }
345
- * db.query_argv(transform, 'select a, b, c from foo where c = ?', 42)
349
+ * db.query_splat(transform, 'select a, b, c from foo where c = ?', 42)
346
350
  *
347
- * @overload query_argv(sql, ...)
351
+ * @overload query_splat(sql, ...)
348
352
  * @param sql [String] SQL statement
349
353
  * @return [Array<Array, any>, Integer] rows or total changes
350
- * @overload query_argv(transform, sql, ...)
354
+ * @overload query_splat(transform, sql, ...)
351
355
  * @param transform [Proc] transform proc
352
356
  * @param sql [String] SQL statement
353
357
  * @return [Array<Array, any>, Integer] rows or total changes
354
358
  */
355
- VALUE Database_query_argv(int argc, VALUE *argv, VALUE self) {
356
- return Database_perform_query(argc, argv, self, safe_query_argv, QUERY_ARGV);
359
+ VALUE Database_query_splat(int argc, VALUE *argv, VALUE self) {
360
+ return Database_perform_query(argc, argv, self, safe_query_splat, QUERY_SPLAT);
357
361
  }
358
362
 
359
363
  /* Runs a query returning rows as arrays. If a block is given, it will be called
@@ -364,26 +368,26 @@ VALUE Database_query_argv(int argc, VALUE *argv, VALUE self) {
364
368
  * parameters are given as an array, the query should specify parameters using
365
369
  * `?`:
366
370
  *
367
- * db.query_ary('select * from foo where x = ?', 42)
371
+ * db.query_array('select * from foo where x = ?', 42)
368
372
  *
369
373
  * Named placeholders are specified using `:`. The placeholder values are
370
374
  * specified using a hash, where keys are either strings are symbols. String
371
375
  * keys can include or omit the `:` prefix. The following are equivalent:
372
376
  *
373
- * db.query_ary('select * from foo where x = :bar', bar: 42)
374
- * db.query_ary('select * from foo where x = :bar', 'bar' => 42)
375
- * db.query_ary('select * from foo where x = :bar', ':bar' => 42)
377
+ * db.query_array('select * from foo where x = :bar', bar: 42)
378
+ * db.query_array('select * from foo where x = :bar', 'bar' => 42)
379
+ * db.query_array('select * from foo where x = :bar', ':bar' => 42)
376
380
  *
377
- * @overload query_ary(sql, ...)
381
+ * @overload query_array(sql, ...)
378
382
  * @param sql [String] SQL statement
379
383
  * @return [Array<Array>, Integer] rows or total changes
380
- * @overload query_ary(transform, sql, ...)
384
+ * @overload query_array(transform, sql, ...)
381
385
  * @param transform [Proc] transform proc
382
386
  * @param sql [String] SQL statement
383
387
  * @return [Array<Array>, Integer] rows or total changes
384
388
  */
385
- VALUE Database_query_ary(int argc, VALUE *argv, VALUE self) {
386
- return Database_perform_query(argc, argv, self, safe_query_ary, QUERY_ARY);
389
+ VALUE Database_query_array(int argc, VALUE *argv, VALUE self) {
390
+ return Database_perform_query(argc, argv, self, safe_query_array, QUERY_ARRAY);
387
391
  }
388
392
 
389
393
  /* Runs a query returning a single row as a hash.
@@ -419,23 +423,23 @@ VALUE Database_query_single(int argc, VALUE *argv, VALUE self) {
419
423
  * parameters are given as an array, the query should specify parameters using
420
424
  * `?`:
421
425
  *
422
- * db.query_single_argv('select * from foo where x = ?', 42)
426
+ * db.query_single_splat('select * from foo where x = ?', 42)
423
427
  *
424
428
  * Named placeholders are specified using `:`. The placeholder values are
425
429
  * specified using keyword arguments:
426
430
  *
427
- * db.query_single_argv('select * from foo where x = :bar', bar: 42)
431
+ * db.query_single_splat('select * from foo where x = :bar', bar: 42)
428
432
  *
429
- * @overload query_single_argv(sql, ...) -> row
433
+ * @overload query_single_splat(sql, ...) -> row
430
434
  * @param sql [String] SQL statement
431
435
  * @return [Array, any] row
432
- * @overload query_single_argv(transform, sql, ...) -> row
436
+ * @overload query_single_splat(transform, sql, ...) -> row
433
437
  * @param transform [Proc] transform proc
434
438
  * @param sql [String] SQL statement
435
439
  * @return [Array, any] row
436
440
  */
437
- VALUE Database_query_single_argv(int argc, VALUE *argv, VALUE self) {
438
- return Database_perform_query(argc, argv, self, safe_query_single_row_argv, QUERY_ARGV);
441
+ VALUE Database_query_single_splat(int argc, VALUE *argv, VALUE self) {
442
+ return Database_perform_query(argc, argv, self, safe_query_single_row_splat, QUERY_SPLAT);
439
443
  }
440
444
 
441
445
  /* Runs a query returning a single row as an array.
@@ -445,23 +449,23 @@ VALUE Database_query_single_argv(int argc, VALUE *argv, VALUE self) {
445
449
  * parameters are given as an array, the query should specify parameters using
446
450
  * `?`:
447
451
  *
448
- * db.query_single_ary('select * from foo where x = ?', 42)
452
+ * db.query_single_array('select * from foo where x = ?', 42)
449
453
  *
450
454
  * Named placeholders are specified using `:`. The placeholder values are
451
455
  * specified using keyword arguments:
452
456
  *
453
- * db.query_single_ary('select * from foo where x = :bar', bar: 42)
457
+ * db.query_single_array('select * from foo where x = :bar', bar: 42)
454
458
  *
455
- * @overload query_single_ary(sql, ...) -> row
459
+ * @overload query_single_array(sql, ...) -> row
456
460
  * @param sql [String] SQL statement
457
461
  * @return [Array, any] row
458
- * @overload query_single_ary(transform, sql, ...) -> row
462
+ * @overload query_single_array(transform, sql, ...) -> row
459
463
  * @param transform [Proc] transform proc
460
464
  * @param sql [String] SQL statement
461
465
  * @return [Array, any] row
462
466
  */
463
- VALUE Database_query_single_ary(int argc, VALUE *argv, VALUE self) {
464
- return Database_perform_query(argc, argv, self, safe_query_single_row_ary, QUERY_ARY);
467
+ VALUE Database_query_single_array(int argc, VALUE *argv, VALUE self) {
468
+ return Database_perform_query(argc, argv, self, safe_query_single_row_array, QUERY_ARRAY);
465
469
  }
466
470
 
467
471
  /* call-seq:
@@ -532,6 +536,8 @@ VALUE Database_batch_execute(VALUE self, VALUE sql, VALUE parameters) {
532
536
  /* call-seq:
533
537
  * db.batch_query(sql, params_source) -> rows
534
538
  * db.batch_query(sql, params_source) { |rows| ... } -> changes
539
+ * db.batch_query_hash(sql, params_source) -> rows
540
+ * db.batch_query_hash(sql, params_source) { |rows| ... } -> changes
535
541
  *
536
542
  * Executes the given query for each list of parameters in the given paramter
537
543
  * source. If a block is given, it is called with the resulting rows for each
@@ -564,8 +570,8 @@ VALUE Database_batch_query(VALUE self, VALUE sql, VALUE parameters) {
564
570
  }
565
571
 
566
572
  /* call-seq:
567
- * db.batch_query_ary(sql, params_source) -> rows
568
- * db.batch_query_ary(sql, params_source) { |rows| ... } -> changes
573
+ * db.batch_query_array(sql, params_source) -> rows
574
+ * db.batch_query_array(sql, params_source) { |rows| ... } -> changes
569
575
  *
570
576
  * Executes the given query for each list of parameters in the given paramter
571
577
  * source. If a block is given, it is called with the resulting rows for each
@@ -577,29 +583,29 @@ VALUE Database_batch_query(VALUE self, VALUE sql, VALUE parameters) {
577
583
  * [1, 2],
578
584
  * [3, 4]
579
585
  * ]
580
- * db.batch_query_ary('insert into foo values (?, ?) returning bar, baz', records)
586
+ * db.batch_query_array('insert into foo values (?, ?) returning bar, baz', records)
581
587
  * #=> [[1, 2], [3, 4]]
582
588
  * *
583
589
  * @param sql [String] query SQL
584
590
  * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
585
591
  * @return [Array<Array>, Integer] Total number of changes effected
586
592
  */
587
- VALUE Database_batch_query_ary(VALUE self, VALUE sql, VALUE parameters) {
593
+ VALUE Database_batch_query_array(VALUE self, VALUE sql, VALUE parameters) {
588
594
  Database_t *db = self_to_open_database(self);
589
595
  sqlite3_stmt *stmt;
590
596
 
591
597
  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
592
598
  query_ctx ctx = QUERY_CTX(
593
599
  self, sql, db, stmt, parameters,
594
- Qnil, QUERY_ARY, ROW_MULTI, ALL_ROWS
600
+ Qnil, QUERY_ARRAY, ROW_MULTI, ALL_ROWS
595
601
  );
596
602
 
597
- return rb_ensure(SAFE(safe_batch_query_ary), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
603
+ return rb_ensure(SAFE(safe_batch_query_array), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
598
604
  }
599
605
 
600
606
  /* call-seq:
601
- * db.batch_query_argv(sql, params_source) -> rows
602
- * db.batch_query_argv(sql, params_source) { |rows| ... } -> changes
607
+ * db.batch_query_splat(sql, params_source) -> rows
608
+ * db.batch_query_splat(sql, params_source) { |rows| ... } -> changes
603
609
  *
604
610
  * Executes the given query for each list of parameters in the given paramter
605
611
  * source. If a block is given, it is called with the resulting rows for each
@@ -611,24 +617,24 @@ VALUE Database_batch_query_ary(VALUE self, VALUE sql, VALUE parameters) {
611
617
  * [1, 2],
612
618
  * [3, 4]
613
619
  * ]
614
- * db.batch_query_argv('insert into foo values (?, ?) returning baz', records)
620
+ * db.batch_query_splat('insert into foo values (?, ?) returning baz', records)
615
621
  * #=> [2, 4]
616
622
  * *
617
623
  * @param sql [String] query SQL
618
624
  * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
619
625
  * @return [Array<any>, Integer] Total number of changes effected
620
626
  */
621
- VALUE Database_batch_query_argv(VALUE self, VALUE sql, VALUE parameters) {
627
+ VALUE Database_batch_query_splat(VALUE self, VALUE sql, VALUE parameters) {
622
628
  Database_t *db = self_to_open_database(self);
623
629
  sqlite3_stmt *stmt;
624
630
 
625
631
  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
626
632
  query_ctx ctx = QUERY_CTX(
627
633
  self, sql, db, stmt, parameters,
628
- Qnil, QUERY_ARGV, ROW_MULTI, ALL_ROWS
634
+ Qnil, QUERY_SPLAT, ROW_MULTI, ALL_ROWS
629
635
  );
630
636
 
631
- return rb_ensure(SAFE(safe_batch_query_argv), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
637
+ return rb_ensure(SAFE(safe_batch_query_splat), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
632
638
  }
633
639
 
634
640
  /* Returns the column names for the given query, without running it.
@@ -721,15 +727,16 @@ static inline VALUE Database_prepare(int argc, VALUE *argv, VALUE self, VALUE mo
721
727
  }
722
728
 
723
729
  /* call-seq:
724
- * db.prepare(sql) -> Extralite::Query
725
- * db.prepare(sql, ...) -> Extralite::Query
726
- * db.prepare(sql, ...) { ... } -> Extralite::Query
730
+ * db.prepare(sql) -> query
731
+ * db.prepare(sql, *params) -> query
732
+ * db.prepare(sql, *params) { ... } -> query
727
733
  *
728
734
  * Creates a prepared query with the given SQL query in hash mode. If query
729
735
  * parameters are given, they are bound to the query. If a block is given, it is
730
736
  * used as a transform proc.
731
737
  *
732
738
  * @param sql [String] SQL statement
739
+ * @param *params [Array<any>] parameters to bind
733
740
  * @return [Extralite::Query] prepared query
734
741
  */
735
742
  VALUE Database_prepare_hash(int argc, VALUE *argv, VALUE self) {
@@ -737,35 +744,37 @@ VALUE Database_prepare_hash(int argc, VALUE *argv, VALUE self) {
737
744
  }
738
745
 
739
746
  /* call-seq:
740
- * db.prepare_argv(sql) -> Extralite::Query
741
- * db.prepare_argv(sql, ...) -> Extralite::Query
742
- * db.prepare_argv(sql, ...) { ... } -> Extralite::Query
747
+ * db.prepare_splat(sql) -> Extralite::Query
748
+ * db.prepare_splat(sql, *params) -> Extralite::Query
749
+ * db.prepare_splat(sql, *params) { ... } -> Extralite::Query
743
750
  *
744
751
  * Creates a prepared query with the given SQL query in argv mode. If query
745
752
  * parameters are given, they are bound to the query. If a block is given, it is
746
753
  * used as a transform proc.
747
754
  *
748
755
  * @param sql [String] SQL statement
756
+ * @param *params [Array<any>] parameters to bind
749
757
  * @return [Extralite::Query] prepared query
750
758
  */
751
- VALUE Database_prepare_argv(int argc, VALUE *argv, VALUE self) {
752
- return Database_prepare(argc, argv, self, SYM_argv);
759
+ VALUE Database_prepare_splat(int argc, VALUE *argv, VALUE self) {
760
+ return Database_prepare(argc, argv, self, SYM_splat);
753
761
  }
754
762
 
755
763
  /* call-seq:
756
- * db.prepare_ary(sql) -> Extralite::Query
757
- * db.prepare_ary(sql, ...) -> Extralite::Query
758
- * db.prepare_ary(sql, ...) { ... } -> Extralite::Query
764
+ * db.prepare_array(sql) -> Extralite::Query
765
+ * db.prepare_array(sql, *params) -> Extralite::Query
766
+ * db.prepare_array(sql, *params) { ... } -> Extralite::Query
759
767
  *
760
- * Creates a prepared query with the given SQL query in ary mode. If query
768
+ * Creates a prepared query with the given SQL query in array mode. If query
761
769
  * parameters are given, they are bound to the query. If a block is given, it is
762
770
  * used as a transform proc.
763
771
  *
764
772
  * @param sql [String] SQL statement
773
+ * @param *params [Array<any>] parameters to bind
765
774
  * @return [Extralite::Query] prepared query
766
775
  */
767
- VALUE Database_prepare_ary(int argc, VALUE *argv, VALUE self) {
768
- return Database_prepare(argc, argv, self, SYM_ary);
776
+ VALUE Database_prepare_array(int argc, VALUE *argv, VALUE self) {
777
+ return Database_prepare(argc, argv, self, SYM_array);
769
778
  }
770
779
 
771
780
  /* Interrupts a long running query. This method is to be called from a different
@@ -862,6 +871,10 @@ VALUE backup_cleanup(VALUE ptr) {
862
871
  * end
863
872
  *
864
873
  * @param dest [String, Extralite::Database] backup destination
874
+ * @param src_db_name [String] source database name (default: "main")
875
+ * @param dst_db_name [String] Destination database name (default: "main")
876
+ * @yieldparam remaining [Integer] remaining page count
877
+ * @yieldparam total [Integer] total page count
865
878
  * @return [Extralite::Database] source database
866
879
  */
867
880
  VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
@@ -911,6 +924,13 @@ VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
911
924
  /* Returns runtime status values for the given op as an array containing the
912
925
  * current value and the high water mark value. To reset the high water mark,
913
926
  * pass true as reset.
927
+ *
928
+ * You can use the various `Extralite::SQLITE_STATUS_xxx` constants with this
929
+ * method:
930
+ *
931
+ * Extralite.runtime_status(Extralite::SQLITE_STATUS_MEMORY_USED)
932
+ *
933
+ * For more information see the SQLite docs: https://sqlite.org/c3ref/c_status_malloc_count.html
914
934
  *
915
935
  * @overload runtime_status(op)
916
936
  * @param op [Integer] op
@@ -1030,7 +1050,10 @@ VALUE Database_trace(VALUE self) {
1030
1050
  }
1031
1051
 
1032
1052
  #ifdef EXTRALITE_ENABLE_CHANGESET
1033
- /* Tracks changes to the database and returns a changeset. The changeset can
1053
+ /* call-seq:
1054
+ * db.track_changes(*tables) { ... } -> changeset
1055
+ *
1056
+ * Tracks changes to the database and returns a changeset. The changeset can
1034
1057
  * then be used to store the changes to a file, apply them to another database,
1035
1058
  * or undo the changes. The given table names specify which tables should be
1036
1059
  * tracked for changes. Passing a value of nil causes all tables to be tracked.
@@ -1041,7 +1064,7 @@ VALUE Database_trace(VALUE self) {
1041
1064
  *
1042
1065
  * File.open('my.changes', 'w+') { |f| f << changeset.to_blob }
1043
1066
  *
1044
- * @param table [String, Symbol] table to track
1067
+ * @param *tables [Array<String, Symbol>] table(s) to track
1045
1068
  * @return [Extralite::Changeset] changeset
1046
1069
  */
1047
1070
  VALUE Database_track_changes(int argc, VALUE *argv, VALUE self) {
@@ -1185,7 +1208,7 @@ struct progress_handler parse_progress_handler_opts(VALUE opts) {
1185
1208
  * @option opts [Integer] :period period value (`1000` by default)
1186
1209
  * @option opts [Integer] :tick tick value (`10` by default)
1187
1210
  * @option opts [Symbol] :mode progress handler mode (`:normal` by default)
1188
- * @returns [Extralite::Database] database
1211
+ * @return [Extralite::Database] database
1189
1212
  */
1190
1213
  VALUE Database_on_progress(int argc, VALUE *argv, VALUE self) {
1191
1214
  Database_t *db = self_to_open_database(self);
@@ -1220,7 +1243,10 @@ VALUE Database_on_progress(int argc, VALUE *argv, VALUE self) {
1220
1243
  return self;
1221
1244
  }
1222
1245
 
1223
- /* Installs or removes a global progress handler that will be executed
1246
+ /* call-seq:
1247
+ * Extralite.on_progress(**opts) { ... }
1248
+ *
1249
+ * Installs or removes a global progress handler that will be executed
1224
1250
  * periodically while a query is running. This method can be used to support
1225
1251
  * switching between fibers and threads or implementing timeouts for running
1226
1252
  * queries.
@@ -1275,7 +1301,7 @@ VALUE Database_on_progress(int argc, VALUE *argv, VALUE self) {
1275
1301
  * @option opts [Integer] :period period value (`1000` by default)
1276
1302
  * @option opts [Integer] :tick tick value (`10` by default)
1277
1303
  * @option opts [Symbol] :mode progress handler mode (`:normal` by default)
1278
- * @returns [Extralite::Database] database
1304
+ * @return [Extralite::Database] database
1279
1305
  */
1280
1306
  VALUE Extralite_on_progress(int argc, VALUE *argv, VALUE self) {
1281
1307
  VALUE opts;
@@ -1361,7 +1387,7 @@ VALUE Database_gvl_release_threshold_get(VALUE self) {
1361
1387
  * A value of nil sets the threshold to the default value, which is
1362
1388
  * currently 1000.
1363
1389
  *
1364
- * @param [Integer, nil] GVL release threshold
1390
+ * @param threshold [Integer, nil] GVL release threshold
1365
1391
  * @return [Integer] GVL release threshold
1366
1392
  */
1367
1393
  VALUE Database_gvl_release_threshold_set(VALUE self, VALUE value) {
@@ -1389,6 +1415,53 @@ VALUE Database_gvl_release_threshold_set(VALUE self, VALUE value) {
1389
1415
  return INT2NUM(db->gvl_release_threshold);
1390
1416
  }
1391
1417
 
1418
+ int checkpoint_mode_symbol_to_int(VALUE mode) {
1419
+ if (mode == SYM_passive) return SQLITE_CHECKPOINT_PASSIVE;
1420
+ if (mode == SYM_full) return SQLITE_CHECKPOINT_FULL;
1421
+ if (mode == SYM_restart) return SQLITE_CHECKPOINT_RESTART;
1422
+ if (mode == SYM_truncate) return SQLITE_CHECKPOINT_TRUNCATE;
1423
+
1424
+ rb_raise(eArgumentError, "Invalid WAL checkpoint mode specified");
1425
+ }
1426
+
1427
+ /* Runs a WAL checkpoint operation with the given mode. If a database name is
1428
+ * given, the checkpoint operation is ran on the corresponding attached
1429
+ * database, otherwise it is run on the main database. Returns an array
1430
+ * containing the total number of frames in the WAL file, and the number of
1431
+ * frames checkpointed. For more information see:
1432
+ * https://sqlite.org/c3ref/wal_checkpoint_v2.html
1433
+ *
1434
+ * @overload wal_checkpoint(mode)
1435
+ * @param mode [Symbol] checkpoint mode (`:passive`, `:full`, `:restart`, `:truncate`)
1436
+ * @return [Array<int>] total and checkpointed frame count
1437
+ * @overload wal_checkpoint(mode, db_name)
1438
+ * @param mode [Symbol] checkpoint mode (`:passive`, `:full`, `:restart`, `:truncate`)
1439
+ * @param db_name [String] attached database name
1440
+ * @return [Array<int>] total and checkpointed frame count
1441
+ */
1442
+ VALUE Database_wal_checkpoint(int argc, VALUE *argv, VALUE self) {
1443
+ Database_t *db = self_to_open_database(self);
1444
+ VALUE mode = Qnil;
1445
+ VALUE db_name = Qnil;
1446
+ int total_frames;
1447
+ int checkpointed_frames;
1448
+
1449
+ rb_scan_args(argc, argv, "11", &mode, &db_name);
1450
+
1451
+ int mode_int = checkpoint_mode_symbol_to_int(mode);
1452
+ int rc = sqlite3_wal_checkpoint_v2(
1453
+ db->sqlite3_db,
1454
+ NIL_P(db_name) ? NULL : StringValueCStr(db_name),
1455
+ mode_int,
1456
+ &total_frames,
1457
+ &checkpointed_frames
1458
+ );
1459
+ if (rc != SQLITE_OK)
1460
+ rb_raise(cError, "Failed to perform WAL checkpoint: %s", sqlite3_errstr(rc));
1461
+
1462
+ return rb_ary_new3(2, INT2NUM(total_frames), INT2NUM(checkpointed_frames));
1463
+ }
1464
+
1392
1465
  void Init_ExtraliteDatabase(void) {
1393
1466
  VALUE mExtralite = rb_define_module("Extralite");
1394
1467
  rb_define_singleton_method(mExtralite, "runtime_status", Extralite_runtime_status, -1);
@@ -1398,63 +1471,62 @@ void Init_ExtraliteDatabase(void) {
1398
1471
  cDatabase = rb_define_class_under(mExtralite, "Database", rb_cObject);
1399
1472
  rb_define_alloc_func(cDatabase, Database_allocate);
1400
1473
 
1401
- #define DEF(s, f, a) rb_define_method(cDatabase, s, f, a)
1402
-
1403
- DEF("backup", Database_backup, -1);
1404
- DEF("batch_execute", Database_batch_execute, 2);
1405
- DEF("batch_query", Database_batch_query, 2);
1406
- DEF("batch_query_ary", Database_batch_query_ary, 2);
1407
- DEF("batch_query_argv", Database_batch_query_argv, 2);
1408
- DEF("batch_query_hash", Database_batch_query, 2);
1409
- DEF("busy_timeout=", Database_busy_timeout_set, 1);
1410
- DEF("changes", Database_changes, 0);
1411
- DEF("close", Database_close, 0);
1412
- DEF("closed?", Database_closed_p, 0);
1413
- DEF("columns", Database_columns, 1);
1414
- DEF("errcode", Database_errcode, 0);
1415
- DEF("errmsg", Database_errmsg, 0);
1474
+ rb_define_method(cDatabase, "backup", Database_backup, -1);
1475
+ rb_define_method(cDatabase, "batch_execute", Database_batch_execute, 2);
1476
+ rb_define_method(cDatabase, "batch_query", Database_batch_query, 2);
1477
+ rb_define_method(cDatabase, "batch_query_array", Database_batch_query_array, 2);
1478
+ rb_define_method(cDatabase, "batch_query_splat", Database_batch_query_splat, 2);
1479
+ rb_define_method(cDatabase, "batch_query_hash", Database_batch_query, 2);
1480
+ rb_define_method(cDatabase, "busy_timeout=", Database_busy_timeout_set, 1);
1481
+ rb_define_method(cDatabase, "changes", Database_changes, 0);
1482
+ rb_define_method(cDatabase, "close", Database_close, 0);
1483
+ rb_define_method(cDatabase, "closed?", Database_closed_p, 0);
1484
+ rb_define_method(cDatabase, "columns", Database_columns, 1);
1485
+ rb_define_method(cDatabase, "errcode", Database_errcode, 0);
1486
+ rb_define_method(cDatabase, "errmsg", Database_errmsg, 0);
1416
1487
 
1417
1488
  #ifdef HAVE_SQLITE3_ERROR_OFFSET
1418
- DEF("error_offset", Database_error_offset, 0);
1489
+ rb_define_method(cDatabase, "error_offset", Database_error_offset, 0);
1419
1490
  #endif
1420
1491
 
1421
- DEF("execute", Database_execute, -1);
1422
- DEF("filename", Database_filename, -1);
1423
- DEF("gvl_release_threshold", Database_gvl_release_threshold_get, 0);
1424
- DEF("gvl_release_threshold=", Database_gvl_release_threshold_set, 1);
1425
- DEF("initialize", Database_initialize, -1);
1426
- DEF("inspect", Database_inspect, 0);
1427
- DEF("interrupt", Database_interrupt, 0);
1428
- DEF("last_insert_rowid", Database_last_insert_rowid, 0);
1429
- DEF("limit", Database_limit, -1);
1492
+ rb_define_method(cDatabase, "execute", Database_execute, -1);
1493
+ rb_define_method(cDatabase, "filename", Database_filename, -1);
1494
+ rb_define_method(cDatabase, "gvl_release_threshold", Database_gvl_release_threshold_get, 0);
1495
+ rb_define_method(cDatabase, "gvl_release_threshold=", Database_gvl_release_threshold_set, 1);
1496
+ rb_define_method(cDatabase, "initialize", Database_initialize, -1);
1497
+ rb_define_method(cDatabase, "inspect", Database_inspect, 0);
1498
+ rb_define_method(cDatabase, "interrupt", Database_interrupt, 0);
1499
+ rb_define_method(cDatabase, "last_insert_rowid", Database_last_insert_rowid, 0);
1500
+ rb_define_method(cDatabase, "limit", Database_limit, -1);
1430
1501
 
1431
1502
  #ifdef HAVE_SQLITE3_LOAD_EXTENSION
1432
- DEF("load_extension", Database_load_extension, 1);
1503
+ rb_define_method(cDatabase, "load_extension", Database_load_extension, 1);
1433
1504
  #endif
1434
1505
 
1435
- DEF("on_progress", Database_on_progress, -1);
1436
- DEF("prepare", Database_prepare_hash, -1);
1437
- DEF("prepare_argv", Database_prepare_argv, -1);
1438
- DEF("prepare_ary", Database_prepare_ary, -1);
1439
- DEF("prepare_hash", Database_prepare_hash, -1);
1440
- DEF("query", Database_query, -1);
1441
- DEF("query_argv", Database_query_argv, -1);
1442
- DEF("query_ary", Database_query_ary, -1);
1443
- DEF("query_hash", Database_query, -1);
1444
- DEF("query_single", Database_query_single, -1);
1445
- DEF("query_single_ary", Database_query_single_ary, -1);
1446
- DEF("query_single_argv", Database_query_single_argv, -1);
1447
- DEF("query_single_hash", Database_query_single, -1);
1448
- DEF("read_only?", Database_read_only_p, 0);
1449
- DEF("status", Database_status, -1);
1450
- DEF("total_changes", Database_total_changes, 0);
1451
- DEF("trace", Database_trace, 0);
1506
+ rb_define_method(cDatabase, "on_progress", Database_on_progress, -1);
1507
+ rb_define_method(cDatabase, "prepare", Database_prepare_hash, -1);
1508
+ rb_define_method(cDatabase, "prepare_splat", Database_prepare_splat, -1);
1509
+ rb_define_method(cDatabase, "prepare_array", Database_prepare_array, -1);
1510
+ rb_define_method(cDatabase, "prepare_hash", Database_prepare_hash, -1);
1511
+ rb_define_method(cDatabase, "query", Database_query, -1);
1512
+ rb_define_method(cDatabase, "query_splat", Database_query_splat, -1);
1513
+ rb_define_method(cDatabase, "query_array", Database_query_array, -1);
1514
+ rb_define_method(cDatabase, "query_hash", Database_query, -1);
1515
+ rb_define_method(cDatabase, "query_single", Database_query_single, -1);
1516
+ rb_define_method(cDatabase, "query_single_array", Database_query_single_array, -1);
1517
+ rb_define_method(cDatabase, "query_single_splat", Database_query_single_splat, -1);
1518
+ rb_define_method(cDatabase, "query_single_hash", Database_query_single, -1);
1519
+ rb_define_method(cDatabase, "read_only?", Database_read_only_p, 0);
1520
+ rb_define_method(cDatabase, "status", Database_status, -1);
1521
+ rb_define_method(cDatabase, "total_changes", Database_total_changes, 0);
1522
+ rb_define_method(cDatabase, "trace", Database_trace, 0);
1523
+ rb_define_method(cDatabase, "wal_checkpoint", Database_wal_checkpoint, -1);
1452
1524
 
1453
1525
  #ifdef EXTRALITE_ENABLE_CHANGESET
1454
- DEF("track_changes", Database_track_changes, -1);
1526
+ rb_define_method(cDatabase, "track_changes", Database_track_changes, -1);
1455
1527
  #endif
1456
1528
 
1457
- DEF("transaction_active?", Database_transaction_active_p, 0);
1529
+ rb_define_method(cDatabase, "transaction_active?", Database_transaction_active_p, 0);
1458
1530
 
1459
1531
  cBlob = rb_define_class_under(mExtralite, "Blob", rb_cString);
1460
1532
  cError = rb_define_class_under(mExtralite, "Error", rb_eStandardError);
@@ -1475,21 +1547,29 @@ void Init_ExtraliteDatabase(void) {
1475
1547
  ID_track = rb_intern("track");
1476
1548
 
1477
1549
  SYM_at_least_once = ID2SYM(rb_intern("at_least_once"));
1550
+ SYM_full = ID2SYM(rb_intern("full"));
1478
1551
  SYM_gvl_release_threshold = ID2SYM(rb_intern("gvl_release_threshold"));
1479
1552
  SYM_once = ID2SYM(rb_intern("once"));
1480
1553
  SYM_none = ID2SYM(rb_intern("none"));
1481
1554
  SYM_normal = ID2SYM(rb_intern("normal"));
1555
+ SYM_passive = ID2SYM(rb_intern("passive"));
1482
1556
  SYM_pragma = ID2SYM(rb_intern("pragma"));
1483
1557
  SYM_read_only = ID2SYM(rb_intern("read_only"));
1558
+ SYM_restart = ID2SYM(rb_intern("restart"));
1559
+ SYM_truncate = ID2SYM(rb_intern("truncate"));
1484
1560
  SYM_wal = ID2SYM(rb_intern("wal"));
1485
1561
 
1486
1562
  rb_gc_register_mark_object(SYM_at_least_once);
1563
+ rb_gc_register_mark_object(SYM_full);
1487
1564
  rb_gc_register_mark_object(SYM_gvl_release_threshold);
1488
1565
  rb_gc_register_mark_object(SYM_once);
1489
1566
  rb_gc_register_mark_object(SYM_none);
1490
1567
  rb_gc_register_mark_object(SYM_normal);
1568
+ rb_gc_register_mark_object(SYM_passive);
1491
1569
  rb_gc_register_mark_object(SYM_pragma);
1492
1570
  rb_gc_register_mark_object(SYM_read_only);
1571
+ rb_gc_register_mark_object(SYM_restart);
1572
+ rb_gc_register_mark_object(SYM_truncate);
1493
1573
  rb_gc_register_mark_object(SYM_wal);
1494
1574
 
1495
1575
  rb_gc_register_mark_object(global_progress_handler.proc);
@@ -42,8 +42,8 @@ extern ID ID_strip;
42
42
  extern ID ID_to_s;
43
43
  extern ID ID_track;
44
44
 
45
- extern VALUE SYM_argv;
46
- extern VALUE SYM_ary;
45
+ extern VALUE SYM_splat;
46
+ extern VALUE SYM_array;
47
47
  extern VALUE SYM_hash;
48
48
 
49
49
  enum progress_handler_mode {
@@ -71,8 +71,8 @@ typedef struct {
71
71
 
72
72
  enum query_mode {
73
73
  QUERY_HASH,
74
- QUERY_ARGV,
75
- QUERY_ARY
74
+ QUERY_SPLAT,
75
+ QUERY_ARRAY
76
76
  };
77
77
 
78
78
  typedef struct {
@@ -87,13 +87,6 @@ typedef struct {
87
87
  enum query_mode query_mode;
88
88
  } Query_t;
89
89
 
90
- enum iterator_mode {
91
- ITERATOR_HASH,
92
- ITERATOR_ARGV,
93
- ITERATOR_ARY,
94
- ITERATOR_SINGLE_COLUMN
95
- };
96
-
97
90
  typedef struct {
98
91
  VALUE query;
99
92
  } Iterator_t;
@@ -165,16 +158,16 @@ typedef VALUE (*safe_query_impl)(query_ctx *);
165
158
 
166
159
  VALUE safe_batch_execute(query_ctx *ctx);
167
160
  VALUE safe_batch_query(query_ctx *ctx);
168
- VALUE safe_batch_query_argv(query_ctx *ctx);
169
- VALUE safe_batch_query_ary(query_ctx *ctx);
170
- VALUE safe_query_argv(query_ctx *ctx);
171
- VALUE safe_query_ary(query_ctx *ctx);
161
+ VALUE safe_batch_query_splat(query_ctx *ctx);
162
+ VALUE safe_batch_query_array(query_ctx *ctx);
163
+ VALUE safe_query_splat(query_ctx *ctx);
164
+ VALUE safe_query_array(query_ctx *ctx);
172
165
  VALUE safe_query_changes(query_ctx *ctx);
173
166
  VALUE safe_query_columns(query_ctx *ctx);
174
167
  VALUE safe_query_hash(query_ctx *ctx);
175
168
  VALUE safe_query_single_row_hash(query_ctx *ctx);
176
- VALUE safe_query_single_row_argv(query_ctx *ctx);
177
- VALUE safe_query_single_row_ary(query_ctx *ctx);
169
+ VALUE safe_query_single_row_splat(query_ctx *ctx);
170
+ VALUE safe_query_single_row_array(query_ctx *ctx);
178
171
 
179
172
  VALUE Query_each(VALUE self);
180
173
  VALUE Query_next(int argc, VALUE *argv, VALUE self);
@@ -50,7 +50,6 @@ static inline Iterator_t *self_to_iterator(VALUE obj) {
50
50
  * ...
51
51
  *
52
52
  * @param query [Extralite::Query] associated query
53
- * @param mode [Symbol] iteration mode
54
53
  * @return [void]
55
54
  */
56
55
  VALUE Iterator_initialize(VALUE self, VALUE query) {