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.
- checksums.yaml +4 -4
- data/CHANGELOG.md +594 -1
- data/CONTRIBUTING.md +112 -6
- data/{faq/faq.md → FAQ.md} +52 -84
- data/INSTALLATION.md +267 -0
- data/LICENSE +18 -22
- data/README.md +87 -124
- data/dependencies.yml +10 -11
- data/ext/sqlite3/aggregator.c +153 -147
- data/ext/sqlite3/aggregator.h +6 -4
- data/ext/sqlite3/backup.c +86 -64
- data/ext/sqlite3/backup.h +2 -2
- data/ext/sqlite3/database.c +744 -484
- data/ext/sqlite3/database.h +23 -4
- data/ext/sqlite3/exception.c +116 -92
- data/ext/sqlite3/exception.h +5 -1
- data/ext/sqlite3/extconf.rb +68 -33
- data/ext/sqlite3/sqlite3.c +177 -115
- data/ext/sqlite3/sqlite3_ruby.h +2 -2
- data/ext/sqlite3/statement.c +590 -293
- data/ext/sqlite3/statement.h +4 -3
- data/ext/sqlite3/timespec.h +20 -0
- data/lib/sqlite3/constants.rb +195 -47
- data/lib/sqlite3/database.rb +252 -195
- data/lib/sqlite3/errors.rb +54 -1
- data/lib/sqlite3/fork_safety.rb +66 -0
- data/lib/sqlite3/pragmas.rb +196 -143
- data/lib/sqlite3/resultset.rb +14 -105
- data/lib/sqlite3/statement.rb +58 -13
- data/lib/sqlite3/value.rb +17 -20
- data/lib/sqlite3/version.rb +2 -21
- data/lib/sqlite3/version_info.rb +17 -0
- data/lib/sqlite3.rb +8 -4
- data/ports/archives/sqlite-autoconf-3530200.tar.gz +0 -0
- metadata +16 -108
- data/API_CHANGES.md +0 -49
- data/ChangeLog.cvs +0 -88
- data/Gemfile +0 -3
- data/LICENSE-DEPENDENCIES +0 -20
- data/faq/faq.rb +0 -145
- data/faq/faq.yml +0 -426
- data/lib/sqlite3/translator.rb +0 -118
- data/ports/archives/sqlite-autoconf-3400000.tar.gz +0 -0
- data/test/helper.rb +0 -27
- data/test/test_backup.rb +0 -33
- data/test/test_collation.rb +0 -82
- data/test/test_database.rb +0 -545
- data/test/test_database_flags.rb +0 -95
- data/test/test_database_readonly.rb +0 -36
- data/test/test_database_readwrite.rb +0 -41
- data/test/test_deprecated.rb +0 -44
- data/test/test_encoding.rb +0 -155
- data/test/test_integration.rb +0 -507
- data/test/test_integration_aggregate.rb +0 -336
- data/test/test_integration_open_close.rb +0 -30
- data/test/test_integration_pending.rb +0 -115
- data/test/test_integration_resultset.rb +0 -142
- data/test/test_integration_statement.rb +0 -194
- data/test/test_result_set.rb +0 -37
- data/test/test_sqlite3.rb +0 -30
- data/test/test_statement.rb +0 -263
- data/test/test_statement_execute.rb +0 -35
data/ext/sqlite3/aggregator.c
CHANGED
|
@@ -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
|
-
|
|
35
|
-
|
|
34
|
+
protected_funcall_args_t *args =
|
|
35
|
+
(protected_funcall_args_t *)protected_funcall_args_ptr;
|
|
36
36
|
|
|
37
|
-
|
|
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*
|
|
42
|
+
int *exc_status)
|
|
43
43
|
{
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
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
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
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
|
-
|
|
63
|
-
|
|
64
|
-
|
|
62
|
+
if (!inst_ptr) {
|
|
63
|
+
rb_fatal("SQLite is out-of-memory");
|
|
64
|
+
}
|
|
65
65
|
|
|
66
|
-
|
|
66
|
+
inst = *inst_ptr;
|
|
67
67
|
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
68
|
+
if (inst == Qfalse) { /* Qfalse == 0 */
|
|
69
|
+
VALUE instances = rb_iv_get(aw, "-instances");
|
|
70
|
+
int exc_status;
|
|
71
71
|
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
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
|
-
|
|
77
|
+
rb_ary_push(instances, inst);
|
|
78
78
|
|
|
79
|
-
|
|
80
|
-
|
|
79
|
+
*inst_ptr = inst;
|
|
80
|
+
}
|
|
81
81
|
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
82
|
+
if (inst == Qnil) {
|
|
83
|
+
rb_fatal("SQLite called us back on an already destroyed aggregate instance");
|
|
84
|
+
}
|
|
85
85
|
|
|
86
|
-
|
|
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
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
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
|
-
|
|
101
|
-
|
|
102
|
-
|
|
100
|
+
if (!inst_ptr || !(inst = *inst_ptr)) {
|
|
101
|
+
return;
|
|
102
|
+
}
|
|
103
103
|
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
104
|
+
if (inst == Qnil) {
|
|
105
|
+
rb_fatal("attempt to destroy aggregate instance twice");
|
|
106
|
+
}
|
|
107
107
|
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
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
|
-
|
|
113
|
+
*inst_ptr = Qnil;
|
|
114
114
|
}
|
|
115
115
|
|
|
116
116
|
static void
|
|
117
|
-
rb_sqlite3_aggregator_step(sqlite3_context *
|
|
117
|
+
rb_sqlite3_aggregator_step(sqlite3_context *ctx, int argc, sqlite3_value **argv)
|
|
118
118
|
{
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
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
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
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 *
|
|
154
|
+
rb_sqlite3_aggregator_final(sqlite3_context *ctx)
|
|
152
155
|
{
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
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
|
-
|
|
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
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
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
|
-
|
|
175
|
+
rb_sqlite3_aggregate_instance_destroy(ctx);
|
|
173
176
|
}
|
|
174
177
|
|
|
175
178
|
/* call-seq: define_aggregator2(aggregator)
|
|
176
179
|
*
|
|
177
|
-
* Define an
|
|
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
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
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
|
-
|
|
229
|
-
|
|
230
|
+
rb_raise(rb_eArgError, "%"PRIsVALUE" arity=%d out of range -1..127",
|
|
231
|
+
self, arity);
|
|
230
232
|
#else
|
|
231
|
-
|
|
233
|
+
rb_raise(rb_eArgError, "Aggregator arity=%d out of range -1..127", arity);
|
|
232
234
|
#endif
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
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
|
-
|
|
269
|
-
|
|
270
|
-
|
|
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
|
-
|
|
273
|
-
|
|
278
|
+
cAggregatorInstance = rb_funcall(rb_cClass, rb_intern("new"), 0);
|
|
279
|
+
rb_gc_register_mark_object(cAggregatorInstance);
|
|
274
280
|
}
|
data/ext/sqlite3/aggregator.h
CHANGED
|
@@ -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
|
-
|
|
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
|
|
11
|
+
static size_t
|
|
12
|
+
backup_memsize(const void *data)
|
|
12
13
|
{
|
|
13
|
-
|
|
14
|
-
|
|
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
|
|
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
|
-
|
|
20
|
-
|
|
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
|
|
74
|
+
static VALUE
|
|
75
|
+
initialize(VALUE self, VALUE dstdb, VALUE dstname, VALUE srcdb, VALUE srcname)
|
|
60
76
|
{
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
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
|
|
112
|
+
static VALUE
|
|
113
|
+
step(VALUE self, VALUE nPage)
|
|
96
114
|
{
|
|
97
|
-
|
|
98
|
-
|
|
115
|
+
sqlite3BackupRubyPtr ctx;
|
|
116
|
+
int status;
|
|
99
117
|
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
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
|
|
128
|
+
static VALUE
|
|
129
|
+
finish(VALUE self)
|
|
111
130
|
{
|
|
112
|
-
|
|
131
|
+
sqlite3BackupRubyPtr ctx;
|
|
113
132
|
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
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
|
|
147
|
+
static VALUE
|
|
148
|
+
remaining(VALUE self)
|
|
129
149
|
{
|
|
130
|
-
|
|
150
|
+
sqlite3BackupRubyPtr ctx;
|
|
131
151
|
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
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
|
|
164
|
+
static VALUE
|
|
165
|
+
pagecount(VALUE self)
|
|
145
166
|
{
|
|
146
|
-
|
|
167
|
+
sqlite3BackupRubyPtr ctx;
|
|
147
168
|
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
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
|
|
174
|
+
void
|
|
175
|
+
init_sqlite3_backup(void)
|
|
154
176
|
{
|
|
155
177
|
#if 0
|
|
156
|
-
|
|
178
|
+
VALUE mSqlite3 = rb_define_module("SQLite3");
|
|
157
179
|
#endif
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
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
|
-
|
|
7
|
+
sqlite3_backup *p;
|
|
8
8
|
};
|
|
9
9
|
|
|
10
10
|
typedef struct _sqlite3BackupRuby sqlite3BackupRuby;
|
|
11
|
-
typedef sqlite3BackupRuby *
|
|
11
|
+
typedef sqlite3BackupRuby *sqlite3BackupRubyPtr;
|
|
12
12
|
|
|
13
13
|
void init_sqlite3_backup();
|
|
14
14
|
|