sqlite3 1.5.4 → 2.9.6

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.
Files changed (62) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +594 -1
  3. data/CONTRIBUTING.md +112 -6
  4. data/{faq/faq.md → FAQ.md} +52 -84
  5. data/INSTALLATION.md +267 -0
  6. data/LICENSE +18 -22
  7. data/README.md +87 -124
  8. data/dependencies.yml +10 -11
  9. data/ext/sqlite3/aggregator.c +153 -147
  10. data/ext/sqlite3/aggregator.h +6 -4
  11. data/ext/sqlite3/backup.c +86 -64
  12. data/ext/sqlite3/backup.h +2 -2
  13. data/ext/sqlite3/database.c +744 -484
  14. data/ext/sqlite3/database.h +23 -4
  15. data/ext/sqlite3/exception.c +116 -92
  16. data/ext/sqlite3/exception.h +5 -1
  17. data/ext/sqlite3/extconf.rb +68 -33
  18. data/ext/sqlite3/sqlite3.c +177 -115
  19. data/ext/sqlite3/sqlite3_ruby.h +2 -2
  20. data/ext/sqlite3/statement.c +590 -293
  21. data/ext/sqlite3/statement.h +4 -3
  22. data/ext/sqlite3/timespec.h +20 -0
  23. data/lib/sqlite3/constants.rb +195 -47
  24. data/lib/sqlite3/database.rb +252 -195
  25. data/lib/sqlite3/errors.rb +54 -1
  26. data/lib/sqlite3/fork_safety.rb +66 -0
  27. data/lib/sqlite3/pragmas.rb +196 -143
  28. data/lib/sqlite3/resultset.rb +14 -105
  29. data/lib/sqlite3/statement.rb +58 -13
  30. data/lib/sqlite3/value.rb +17 -20
  31. data/lib/sqlite3/version.rb +2 -21
  32. data/lib/sqlite3/version_info.rb +17 -0
  33. data/lib/sqlite3.rb +8 -4
  34. data/ports/archives/sqlite-autoconf-3530200.tar.gz +0 -0
  35. metadata +16 -108
  36. data/API_CHANGES.md +0 -49
  37. data/ChangeLog.cvs +0 -88
  38. data/Gemfile +0 -3
  39. data/LICENSE-DEPENDENCIES +0 -20
  40. data/faq/faq.rb +0 -145
  41. data/faq/faq.yml +0 -426
  42. data/lib/sqlite3/translator.rb +0 -118
  43. data/ports/archives/sqlite-autoconf-3400000.tar.gz +0 -0
  44. data/test/helper.rb +0 -27
  45. data/test/test_backup.rb +0 -33
  46. data/test/test_collation.rb +0 -82
  47. data/test/test_database.rb +0 -545
  48. data/test/test_database_flags.rb +0 -95
  49. data/test/test_database_readonly.rb +0 -36
  50. data/test/test_database_readwrite.rb +0 -41
  51. data/test/test_deprecated.rb +0 -44
  52. data/test/test_encoding.rb +0 -155
  53. data/test/test_integration.rb +0 -507
  54. data/test/test_integration_aggregate.rb +0 -336
  55. data/test/test_integration_open_close.rb +0 -30
  56. data/test/test_integration_pending.rb +0 -115
  57. data/test/test_integration_resultset.rb +0 -142
  58. data/test/test_integration_statement.rb +0 -194
  59. data/test/test_result_set.rb +0 -37
  60. data/test/test_sqlite3.rb +0 -30
  61. data/test/test_statement.rb +0 -263
  62. data/test/test_statement_execute.rb +0 -35
@@ -31,20 +31,20 @@ typedef struct rb_sqlite3_protected_funcall_args {
31
31
  static VALUE
32
32
  rb_sqlite3_protected_funcall_body(VALUE protected_funcall_args_ptr)
33
33
  {
34
- protected_funcall_args_t *args =
35
- (protected_funcall_args_t*)protected_funcall_args_ptr;
34
+ protected_funcall_args_t *args =
35
+ (protected_funcall_args_t *)protected_funcall_args_ptr;
36
36
 
37
- return rb_funcall2(args->self, args->method, args->argc, args->params);
37
+ return rb_funcall2(args->self, args->method, args->argc, args->params);
38
38
  }
39
39
 
40
40
  static VALUE
41
41
  rb_sqlite3_protected_funcall(VALUE self, ID method, int argc, VALUE *params,
42
- int* exc_status)
42
+ int *exc_status)
43
43
  {
44
- protected_funcall_args_t args = {
45
- .self = self, .method = method, .argc = argc, .params = params
46
- };
47
- return rb_protect(rb_sqlite3_protected_funcall_body, (VALUE)(&args), exc_status);
44
+ protected_funcall_args_t args = {
45
+ .self = self, .method = method, .argc = argc, .params = params
46
+ };
47
+ return rb_protect(rb_sqlite3_protected_funcall_body, (VALUE)(&args), exc_status);
48
48
  }
49
49
 
50
50
  /* called in rb_sqlite3_aggregator_step and rb_sqlite3_aggregator_final. It
@@ -54,36 +54,36 @@ rb_sqlite3_protected_funcall(VALUE self, ID method, int argc, VALUE *params,
54
54
  static VALUE
55
55
  rb_sqlite3_aggregate_instance(sqlite3_context *ctx)
56
56
  {
57
- VALUE aw = (VALUE) sqlite3_user_data(ctx);
58
- VALUE handler_klass = rb_iv_get(aw, "-handler_klass");
59
- VALUE inst;
60
- VALUE *inst_ptr = sqlite3_aggregate_context(ctx, (int)sizeof(VALUE));
57
+ VALUE aw = (VALUE) sqlite3_user_data(ctx);
58
+ VALUE handler_klass = rb_iv_get(aw, "-handler_klass");
59
+ VALUE inst;
60
+ VALUE *inst_ptr = sqlite3_aggregate_context(ctx, (int)sizeof(VALUE));
61
61
 
62
- if (!inst_ptr) {
63
- rb_fatal("SQLite is out-of-merory");
64
- }
62
+ if (!inst_ptr) {
63
+ rb_fatal("SQLite is out-of-memory");
64
+ }
65
65
 
66
- inst = *inst_ptr;
66
+ inst = *inst_ptr;
67
67
 
68
- if (inst == Qfalse) { /* Qfalse == 0 */
69
- VALUE instances = rb_iv_get(aw, "-instances");
70
- int exc_status;
68
+ if (inst == Qfalse) { /* Qfalse == 0 */
69
+ VALUE instances = rb_iv_get(aw, "-instances");
70
+ int exc_status;
71
71
 
72
- inst = rb_class_new_instance(0, NULL, cAggregatorInstance);
73
- rb_iv_set(inst, "-handler_instance", rb_sqlite3_protected_funcall(
74
- handler_klass, rb_intern("new"), 0, NULL, &exc_status));
75
- rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
72
+ inst = rb_class_new_instance(0, NULL, cAggregatorInstance);
73
+ rb_iv_set(inst, "-handler_instance", rb_sqlite3_protected_funcall(
74
+ handler_klass, rb_intern("new"), 0, NULL, &exc_status));
75
+ rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
76
76
 
77
- rb_ary_push(instances, inst);
77
+ rb_ary_push(instances, inst);
78
78
 
79
- *inst_ptr = inst;
80
- }
79
+ *inst_ptr = inst;
80
+ }
81
81
 
82
- if (inst == Qnil) {
83
- rb_fatal("SQLite called us back on an already destroyed aggregate instance");
84
- }
82
+ if (inst == Qnil) {
83
+ rb_fatal("SQLite called us back on an already destroyed aggregate instance");
84
+ }
85
85
 
86
- return inst;
86
+ return inst;
87
87
  }
88
88
 
89
89
  /* called by rb_sqlite3_aggregator_final. Unlinks and frees the
@@ -92,89 +92,92 @@ rb_sqlite3_aggregate_instance(sqlite3_context *ctx)
92
92
  static void
93
93
  rb_sqlite3_aggregate_instance_destroy(sqlite3_context *ctx)
94
94
  {
95
- VALUE aw = (VALUE) sqlite3_user_data(ctx);
96
- VALUE instances = rb_iv_get(aw, "-instances");
97
- VALUE *inst_ptr = sqlite3_aggregate_context(ctx, 0);
98
- VALUE inst;
95
+ VALUE aw = (VALUE) sqlite3_user_data(ctx);
96
+ VALUE instances = rb_iv_get(aw, "-instances");
97
+ VALUE *inst_ptr = sqlite3_aggregate_context(ctx, 0);
98
+ VALUE inst;
99
99
 
100
- if (!inst_ptr || (inst = *inst_ptr)) {
101
- return;
102
- }
100
+ if (!inst_ptr || !(inst = *inst_ptr)) {
101
+ return;
102
+ }
103
103
 
104
- if (inst == Qnil) {
105
- rb_fatal("attempt to destroy aggregate instance twice");
106
- }
104
+ if (inst == Qnil) {
105
+ rb_fatal("attempt to destroy aggregate instance twice");
106
+ }
107
107
 
108
- rb_iv_set(inst, "-handler_instance", Qnil); // may catch use-after-free
109
- if (rb_ary_delete(instances, inst) == Qnil) {
110
- rb_fatal("must be in instances at that point");
111
- }
108
+ rb_iv_set(inst, "-handler_instance", Qnil); // may catch use-after-free
109
+ if (rb_ary_delete(instances, inst) == Qnil) {
110
+ rb_fatal("must be in instances at that point");
111
+ }
112
112
 
113
- *inst_ptr = Qnil;
113
+ *inst_ptr = Qnil;
114
114
  }
115
115
 
116
116
  static void
117
- rb_sqlite3_aggregator_step(sqlite3_context * ctx, int argc, sqlite3_value **argv)
117
+ rb_sqlite3_aggregator_step(sqlite3_context *ctx, int argc, sqlite3_value **argv)
118
118
  {
119
- VALUE inst = rb_sqlite3_aggregate_instance(ctx);
120
- VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
121
- VALUE * params = NULL;
122
- VALUE one_param;
123
- int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
124
- int i;
125
-
126
- if (exc_status) {
127
- return;
128
- }
129
-
130
- if (argc == 1) {
131
- one_param = sqlite3val2rb(argv[0]);
132
- params = &one_param;
133
- }
134
- if (argc > 1) {
135
- params = xcalloc((size_t)argc, sizeof(VALUE));
136
- for(i = 0; i < argc; i++) {
137
- params[i] = sqlite3val2rb(argv[i]);
119
+ VALUE inst = rb_sqlite3_aggregate_instance(ctx);
120
+ VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
121
+ VALUE *params = NULL;
122
+ VALUE params_handle = 0;
123
+ VALUE one_param;
124
+ int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
125
+ int i;
126
+
127
+ if (exc_status) {
128
+ return;
129
+ }
130
+
131
+ if (argc == 1) {
132
+ one_param = sqlite3val2rb(argv[0]);
133
+ params = &one_param;
134
+ }
135
+ if (argc > 1) {
136
+ /* ALLOCV memory is conservatively marked, so stored VALUEs survive a
137
+ * GC raised by a later sqlite3val2rb call. */
138
+ params = ALLOCV_N(VALUE, params_handle, argc);
139
+ for (i = 0; i < argc; i++) {
140
+ params[i] = sqlite3val2rb(argv[i]);
141
+ }
138
142
  }
139
- }
140
- rb_sqlite3_protected_funcall(
141
- handler_instance, rb_intern("step"), argc, params, &exc_status);
142
- if (argc > 1) {
143
- xfree(params);
144
- }
145
-
146
- rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
143
+ rb_sqlite3_protected_funcall(
144
+ handler_instance, rb_intern("step"), argc, params, &exc_status);
145
+ if (argc > 1) {
146
+ ALLOCV_END(params_handle);
147
+ }
148
+
149
+ rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
147
150
  }
148
151
 
149
152
  /* we assume that this function is only called once per execution context */
150
153
  static void
151
- rb_sqlite3_aggregator_final(sqlite3_context * ctx)
154
+ rb_sqlite3_aggregator_final(sqlite3_context *ctx)
152
155
  {
153
- VALUE inst = rb_sqlite3_aggregate_instance(ctx);
154
- VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
155
- int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
156
+ VALUE inst = rb_sqlite3_aggregate_instance(ctx);
157
+ VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
158
+ int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
156
159
 
157
- if (!exc_status) {
158
- VALUE result = rb_sqlite3_protected_funcall(
159
- handler_instance, rb_intern("finalize"), 0, NULL, &exc_status);
160
160
  if (!exc_status) {
161
- set_sqlite3_func_result(ctx, result);
161
+ VALUE result = rb_sqlite3_protected_funcall(
162
+ handler_instance, rb_intern("finalize"), 0, NULL, &exc_status);
163
+ if (!exc_status) {
164
+ set_sqlite3_func_result(ctx, result);
165
+ }
162
166
  }
163
- }
164
167
 
165
- if (exc_status) {
166
- /* the user should never see this, as Statement.step() will pick up the
167
- * outstanding exception and raise it instead of generating a new one
168
- * for SQLITE_ERROR with message "Ruby Exception occurred" */
169
- sqlite3_result_error(ctx, "Ruby Exception occurred", -1);
170
- }
168
+ if (exc_status) {
169
+ /* the user should never see this, as Statement.step() will pick up the
170
+ * outstanding exception and raise it instead of generating a new one
171
+ * for SQLITE_ERROR with message "Ruby Exception occurred" */
172
+ sqlite3_result_error(ctx, "Ruby Exception occurred", -1);
173
+ }
171
174
 
172
- rb_sqlite3_aggregate_instance_destroy(ctx);
175
+ rb_sqlite3_aggregate_instance_destroy(ctx);
173
176
  }
174
177
 
175
178
  /* call-seq: define_aggregator2(aggregator)
176
179
  *
177
- * Define an aggregrate function according to a factory object (the "handler")
180
+ * Define an aggregate function according to a factory object (the "handler")
178
181
  * that knows how to obtain to all the information. The handler must provide
179
182
  * the following class methods:
180
183
  *
@@ -205,70 +208,73 @@ rb_sqlite3_aggregator_final(sqlite3_context * ctx)
205
208
  VALUE
206
209
  rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name)
207
210
  {
208
- /* define_aggregator is added as a method to SQLite3::Database in database.c */
209
- sqlite3RubyPtr ctx;
210
- int arity, status;
211
- VALUE aw;
212
- VALUE aggregators;
213
-
214
- Data_Get_Struct(self, sqlite3Ruby, ctx);
215
- if (!ctx->db) {
216
- rb_raise(rb_path2class("SQLite3::Exception"), "cannot use a closed database");
217
- }
218
-
219
- if (rb_respond_to(aggregator, rb_intern("arity"))) {
220
- VALUE ruby_arity = rb_funcall(aggregator, rb_intern("arity"), 0);
221
- arity = NUM2INT(ruby_arity);
222
- } else {
223
- arity = -1;
224
- }
225
-
226
- if (arity < -1 || arity > 127) {
211
+ /* define_aggregator is added as a method to SQLite3::Database in database.c */
212
+ sqlite3RubyPtr ctx = sqlite3_database_unwrap(self);
213
+ int arity, status;
214
+ VALUE aw;
215
+ VALUE aggregators;
216
+
217
+ if (!ctx->db) {
218
+ rb_raise(rb_path2class("SQLite3::Exception"), "cannot use a closed database");
219
+ }
220
+
221
+ if (rb_respond_to(aggregator, rb_intern("arity"))) {
222
+ VALUE ruby_arity = rb_funcall(aggregator, rb_intern("arity"), 0);
223
+ arity = NUM2INT(ruby_arity);
224
+ } else {
225
+ arity = -1;
226
+ }
227
+
228
+ if (arity < -1 || arity > 127) {
227
229
  #ifdef PRIsVALUE
228
- rb_raise(rb_eArgError, "%"PRIsVALUE" arity=%d out of range -1..127",
229
- self, arity);
230
+ rb_raise(rb_eArgError, "%"PRIsVALUE" arity=%d out of range -1..127",
231
+ self, arity);
230
232
  #else
231
- rb_raise(rb_eArgError, "Aggregator arity=%d out of range -1..127", arity);
233
+ rb_raise(rb_eArgError, "Aggregator arity=%d out of range -1..127", arity);
232
234
  #endif
233
- }
234
-
235
- if (!rb_ivar_defined(self, rb_intern("-aggregators"))) {
236
- rb_iv_set(self, "-aggregators", rb_ary_new());
237
- }
238
- aggregators = rb_iv_get(self, "-aggregators");
239
-
240
- aw = rb_class_new_instance(0, NULL, cAggregatorWrapper);
241
- rb_iv_set(aw, "-handler_klass", aggregator);
242
- rb_iv_set(aw, "-instances", rb_ary_new());
243
-
244
- status = sqlite3_create_function(
245
- ctx->db,
246
- StringValueCStr(ruby_name),
247
- arity,
248
- SQLITE_UTF8,
249
- (void*)aw,
250
- NULL,
251
- rb_sqlite3_aggregator_step,
252
- rb_sqlite3_aggregator_final
253
- );
254
-
255
- if (status != SQLITE_OK) {
256
- rb_sqlite3_raise(ctx->db, status);
257
- return self; // just in case rb_sqlite3_raise returns.
258
- }
259
-
260
- rb_ary_push(aggregators, aw);
261
-
262
- return self;
235
+ }
236
+
237
+ if (!rb_ivar_defined(self, rb_intern("-aggregators"))) {
238
+ rb_iv_set(self, "-aggregators", rb_ary_new());
239
+ }
240
+ aggregators = rb_iv_get(self, "-aggregators");
241
+
242
+ aw = rb_class_new_instance(0, NULL, cAggregatorWrapper);
243
+ rb_iv_set(aw, "-handler_klass", aggregator);
244
+ rb_iv_set(aw, "-instances", rb_ary_new());
245
+
246
+ status = sqlite3_create_function(
247
+ ctx->db,
248
+ StringValueCStr(ruby_name),
249
+ arity,
250
+ SQLITE_UTF8,
251
+ (void *)aw,
252
+ NULL,
253
+ rb_sqlite3_aggregator_step,
254
+ rb_sqlite3_aggregator_final
255
+ );
256
+
257
+ CHECK(ctx->db, status);
258
+
259
+ rb_ary_push(aggregators, aw);
260
+ RB_OBJ_WRITE(self, &ctx->aggregators, aggregators);
261
+
262
+ return self;
263
+ }
264
+
265
+ void
266
+ rb_sqlite3_aggregator_pin_instances(VALUE aw)
267
+ {
268
+ rb_sqlite3_pin_array_and_contents(rb_iv_get(aw, "-instances"));
263
269
  }
264
270
 
265
271
  void
266
272
  rb_sqlite3_aggregator_init(void)
267
273
  {
268
- /* rb_class_new generatos class with undefined allocator in ruby 1.9 */
269
- cAggregatorWrapper = rb_funcall(rb_cClass, rb_intern("new"), 0);
270
- rb_gc_register_mark_object(cAggregatorWrapper);
274
+ /* rb_class_new generatos class with undefined allocator in ruby 1.9 */
275
+ cAggregatorWrapper = rb_funcall(rb_cClass, rb_intern("new"), 0);
276
+ rb_gc_register_mark_object(cAggregatorWrapper);
271
277
 
272
- cAggregatorInstance = rb_funcall(rb_cClass, rb_intern("new"), 0);
273
- rb_gc_register_mark_object(cAggregatorInstance);
278
+ cAggregatorInstance = rb_funcall(rb_cClass, rb_intern("new"), 0);
279
+ rb_gc_register_mark_object(cAggregatorInstance);
274
280
  }
@@ -3,10 +3,12 @@
3
3
 
4
4
  #include <sqlite3_ruby.h>
5
5
 
6
- VALUE
7
- rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name);
6
+ VALUE rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name);
8
7
 
9
- void
10
- rb_sqlite3_aggregator_init(void);
8
+ void rb_sqlite3_aggregator_init(void);
9
+
10
+ /* sqlite stores each live instance's VALUE in its aggregate context, so those
11
+ * must not move either. */
12
+ void rb_sqlite3_aggregator_pin_instances(VALUE aw);
11
13
 
12
14
  #endif
data/ext/sqlite3/backup.c CHANGED
@@ -8,16 +8,31 @@
8
8
 
9
9
  VALUE cSqlite3Backup;
10
10
 
11
- static void deallocate(void * ctx)
11
+ static size_t
12
+ backup_memsize(const void *data)
12
13
  {
13
- sqlite3BackupRubyPtr c = (sqlite3BackupRubyPtr)ctx;
14
- xfree(c);
14
+ sqlite3BackupRubyPtr ctx = (sqlite3BackupRubyPtr)data;
15
+ // NB: can't account for ctx->p because the type is incomplete.
16
+ return sizeof(*ctx);
15
17
  }
16
18
 
17
- static VALUE allocate(VALUE klass)
19
+ static const rb_data_type_t backup_type = {
20
+ "SQLite3::Backup",
21
+ {
22
+ NULL,
23
+ RUBY_TYPED_DEFAULT_FREE,
24
+ backup_memsize,
25
+ },
26
+ 0,
27
+ 0,
28
+ RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
29
+ };
30
+
31
+ static VALUE
32
+ allocate(VALUE klass)
18
33
  {
19
- sqlite3BackupRubyPtr ctx = xcalloc((size_t)1, sizeof(sqlite3BackupRuby));
20
- return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
34
+ sqlite3BackupRubyPtr ctx;
35
+ return TypedData_Make_Struct(klass, sqlite3BackupRuby, &backup_type, ctx);
21
36
  }
22
37
 
23
38
  /* call-seq: SQLite3::Backup.new(dstdb, dstname, srcdb, srcname)
@@ -56,31 +71,33 @@ static VALUE allocate(VALUE klass)
56
71
  * b.finish
57
72
  *
58
73
  */
59
- static VALUE initialize(VALUE self, VALUE dstdb, VALUE dstname, VALUE srcdb, VALUE srcname)
74
+ static VALUE
75
+ initialize(VALUE self, VALUE dstdb, VALUE dstname, VALUE srcdb, VALUE srcname)
60
76
  {
61
- sqlite3BackupRubyPtr ctx;
62
- sqlite3RubyPtr ddb_ctx, sdb_ctx;
63
- sqlite3_backup *pBackup;
64
-
65
- Data_Get_Struct(self, sqlite3BackupRuby, ctx);
66
- Data_Get_Struct(dstdb, sqlite3Ruby, ddb_ctx);
67
- Data_Get_Struct(srcdb, sqlite3Ruby, sdb_ctx);
68
-
69
- if(!sdb_ctx->db)
70
- rb_raise(rb_eArgError, "cannot backup from a closed database");
71
- if(!ddb_ctx->db)
72
- rb_raise(rb_eArgError, "cannot backup to a closed database");
73
-
74
- pBackup = sqlite3_backup_init(ddb_ctx->db, StringValuePtr(dstname),
75
- sdb_ctx->db, StringValuePtr(srcname));
76
- if( pBackup ){
77
- ctx->p = pBackup;
78
- }
79
- else {
80
- CHECK(ddb_ctx->db, sqlite3_errcode(ddb_ctx->db));
81
- }
82
-
83
- return self;
77
+ sqlite3BackupRubyPtr ctx;
78
+ sqlite3RubyPtr ddb_ctx, sdb_ctx;
79
+ sqlite3_backup *pBackup;
80
+
81
+ TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
82
+ ddb_ctx = sqlite3_database_unwrap(dstdb);
83
+ sdb_ctx = sqlite3_database_unwrap(srcdb);
84
+
85
+ if (!sdb_ctx->db) {
86
+ rb_raise(rb_eArgError, "cannot backup from a closed database");
87
+ }
88
+ if (!ddb_ctx->db) {
89
+ rb_raise(rb_eArgError, "cannot backup to a closed database");
90
+ }
91
+
92
+ pBackup = sqlite3_backup_init(ddb_ctx->db, StringValuePtr(dstname),
93
+ sdb_ctx->db, StringValuePtr(srcname));
94
+ if (pBackup) {
95
+ ctx->p = pBackup;
96
+ } else {
97
+ CHECK(ddb_ctx->db, sqlite3_errcode(ddb_ctx->db));
98
+ }
99
+
100
+ return self;
84
101
  }
85
102
 
86
103
  /* call-seq: SQLite3::Backup#step(nPage)
@@ -92,30 +109,32 @@ static VALUE initialize(VALUE self, VALUE dstdb, VALUE dstname, VALUE srcdb, VAL
92
109
  * When coping is not done, it returns SQLite3::Constants::ErrorCode::OK.
93
110
  * When some errors occur, it returns the error code.
94
111
  */
95
- static VALUE step(VALUE self, VALUE nPage)
112
+ static VALUE
113
+ step(VALUE self, VALUE nPage)
96
114
  {
97
- sqlite3BackupRubyPtr ctx;
98
- int status;
115
+ sqlite3BackupRubyPtr ctx;
116
+ int status;
99
117
 
100
- Data_Get_Struct(self, sqlite3BackupRuby, ctx);
101
- REQUIRE_OPEN_BACKUP(ctx);
102
- status = sqlite3_backup_step(ctx->p, NUM2INT(nPage));
103
- return INT2NUM(status);
118
+ TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
119
+ REQUIRE_OPEN_BACKUP(ctx);
120
+ status = sqlite3_backup_step(ctx->p, NUM2INT(nPage));
121
+ return INT2NUM(status);
104
122
  }
105
123
 
106
124
  /* call-seq: SQLite3::Backup#finish
107
125
  *
108
126
  * Destroy the backup object.
109
127
  */
110
- static VALUE finish(VALUE self)
128
+ static VALUE
129
+ finish(VALUE self)
111
130
  {
112
- sqlite3BackupRubyPtr ctx;
131
+ sqlite3BackupRubyPtr ctx;
113
132
 
114
- Data_Get_Struct(self, sqlite3BackupRuby, ctx);
115
- REQUIRE_OPEN_BACKUP(ctx);
116
- (void)sqlite3_backup_finish(ctx->p);
117
- ctx->p = NULL;
118
- return Qnil;
133
+ TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
134
+ REQUIRE_OPEN_BACKUP(ctx);
135
+ (void)sqlite3_backup_finish(ctx->p);
136
+ ctx->p = NULL;
137
+ return Qnil;
119
138
  }
120
139
 
121
140
  /* call-seq: SQLite3::Backup#remaining
@@ -125,13 +144,14 @@ static VALUE finish(VALUE self)
125
144
  * Note that the value is only updated after step() is called,
126
145
  * so before calling step() returned value is invalid.
127
146
  */
128
- static VALUE remaining(VALUE self)
147
+ static VALUE
148
+ remaining(VALUE self)
129
149
  {
130
- sqlite3BackupRubyPtr ctx;
150
+ sqlite3BackupRubyPtr ctx;
131
151
 
132
- Data_Get_Struct(self, sqlite3BackupRuby, ctx);
133
- REQUIRE_OPEN_BACKUP(ctx);
134
- return INT2NUM(sqlite3_backup_remaining(ctx->p));
152
+ TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
153
+ REQUIRE_OPEN_BACKUP(ctx);
154
+ return INT2NUM(sqlite3_backup_remaining(ctx->p));
135
155
  }
136
156
 
137
157
  /* call-seq: SQLite3::Backup#pagecount
@@ -141,28 +161,30 @@ static VALUE remaining(VALUE self)
141
161
  * Note that the value is only updated after step() is called,
142
162
  * so before calling step() returned value is invalid.
143
163
  */
144
- static VALUE pagecount(VALUE self)
164
+ static VALUE
165
+ pagecount(VALUE self)
145
166
  {
146
- sqlite3BackupRubyPtr ctx;
167
+ sqlite3BackupRubyPtr ctx;
147
168
 
148
- Data_Get_Struct(self, sqlite3BackupRuby, ctx);
149
- REQUIRE_OPEN_BACKUP(ctx);
150
- return INT2NUM(sqlite3_backup_pagecount(ctx->p));
169
+ TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
170
+ REQUIRE_OPEN_BACKUP(ctx);
171
+ return INT2NUM(sqlite3_backup_pagecount(ctx->p));
151
172
  }
152
173
 
153
- void init_sqlite3_backup()
174
+ void
175
+ init_sqlite3_backup(void)
154
176
  {
155
177
  #if 0
156
- VALUE mSqlite3 = rb_define_module("SQLite3");
178
+ VALUE mSqlite3 = rb_define_module("SQLite3");
157
179
  #endif
158
- cSqlite3Backup = rb_define_class_under(mSqlite3, "Backup", rb_cObject);
159
-
160
- rb_define_alloc_func(cSqlite3Backup, allocate);
161
- rb_define_method(cSqlite3Backup, "initialize", initialize, 4);
162
- rb_define_method(cSqlite3Backup, "step", step, 1);
163
- rb_define_method(cSqlite3Backup, "finish", finish, 0);
164
- rb_define_method(cSqlite3Backup, "remaining", remaining, 0);
165
- rb_define_method(cSqlite3Backup, "pagecount", pagecount, 0);
180
+ cSqlite3Backup = rb_define_class_under(mSqlite3, "Backup", rb_cObject);
181
+
182
+ rb_define_alloc_func(cSqlite3Backup, allocate);
183
+ rb_define_method(cSqlite3Backup, "initialize", initialize, 4);
184
+ rb_define_method(cSqlite3Backup, "step", step, 1);
185
+ rb_define_method(cSqlite3Backup, "finish", finish, 0);
186
+ rb_define_method(cSqlite3Backup, "remaining", remaining, 0);
187
+ rb_define_method(cSqlite3Backup, "pagecount", pagecount, 0);
166
188
  }
167
189
 
168
190
  #endif
data/ext/sqlite3/backup.h CHANGED
@@ -4,11 +4,11 @@
4
4
  #include <sqlite3_ruby.h>
5
5
 
6
6
  struct _sqlite3BackupRuby {
7
- sqlite3_backup *p;
7
+ sqlite3_backup *p;
8
8
  };
9
9
 
10
10
  typedef struct _sqlite3BackupRuby sqlite3BackupRuby;
11
- typedef sqlite3BackupRuby * sqlite3BackupRubyPtr;
11
+ typedef sqlite3BackupRuby *sqlite3BackupRubyPtr;
12
12
 
13
13
  void init_sqlite3_backup();
14
14