1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
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
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
|
use strict;
use warnings;
use lib "t/lib";
use SQLiteTest qw/connect_ok @CALL_FUNCS/;
use Test::More;
use DBD::SQLite::Constants qw/:database_connection_configuration_options/;
use if -d ".git", "Test::FailWarnings";
# LOOKASIDE
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'LOOKASIDE is not supported', 2 if !SQLITE_DBCONFIG_LOOKASIDE;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
eval { $dbh->$func(SQLITE_DBCONFIG_LOOKASIDE, 1, 'db_config') };
ok $@, 'LOOKASIDE is not supported';
like $@ => qr/LOOKASIDE is not supported/;
}
}
# MAINDBNAME
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'MAINDBNAME is not supported', 2 if !SQLITE_DBCONFIG_MAINDBNAME;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
eval { $dbh->$func(SQLITE_DBCONFIG_MAINDBNAME, 1, 'db_config') };
ok $@, 'MAINDBNAME is not supported';
like $@ => qr/MAINDBNAME is not supported/;
}
}
# ENABLE_FKEY
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'ENABLE_FKEY is not supported', 3 if !SQLITE_DBCONFIG_ENABLE_FKEY;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_FKEY, -1, 'db_config');
note "current ENABLE_FKEY value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_FKEY, 1, 'db_config');
is $ret => 1, 'enable foreign key';
# TODO: add foreign key check
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_FKEY, 0, 'db_config');
is $ret => 0, 'disable foreign key';
}
}
# ENABLE_TRIGGER
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'ENABLE_TRIGGER is not supported', 3 if !SQLITE_DBCONFIG_ENABLE_TRIGGER;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_TRIGGER, -1, 'db_config');
note "current ENABLE_TRIGGER value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_TRIGGER, 1, 'db_config');
is $ret => 1, 'enable trigger';
# TODO: add trigger check
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_TRIGGER, 0, 'db_config');
is $ret => 0, 'disable trigger';
}
}
# ENABLE_FTS3_TOKENIZER
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'ENABLE_FTS3_TOKENIZER is not supported', 3 if !SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, -1, 'db_config');
note "current ENABLE_FTS3_TOKENIZER value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 'db_config');
is $ret => 1, 'enable fts3_tokenizer';
# TODO: add fts3_tokenizer check
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 0, 'db_config');
is $ret => 0, 'disable fts3_tokenizer';
}
}
# ENABLE_LOAD_EXTENSION
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'ENABLE_LOAD_EXTENSION is not supported', 3 if !SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, -1, 'db_config');
note "current ENABLE_LOAD_EXTENSION value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, 'db_config');
is $ret => 1, 'enable load_extension';
# TODO: add load_extension check
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 0, 'db_config');
is $ret => 0, 'disable load_extension';
}
}
# NO_CKPT_ON_CLOSE
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'NO_CKPT_ON_CLOSE is not supported', 3 if !SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, -1, 'db_config');
note "current NO_CKPT_ON_CLOSE value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, 1, 'db_config');
is $ret => 1, 'no checkpoint on close';
# TODO: add checkpoint check
$ret = $dbh->$func(SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, 0, 'db_config');
is $ret => 0, 'checkpoint on close';
}
}
# ENABLE_QPSG
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'ENABLE_QPSG is not supported', 3 if !SQLITE_DBCONFIG_ENABLE_QPSG;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_QPSG, -1, 'db_config');
note "current ENABLE_OPSG value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_QPSG, 1, 'db_config');
is $ret => 1, 'enable query planner stability guarantee';
# TODO: add qpsg check
$ret = $dbh->$func(SQLITE_DBCONFIG_ENABLE_QPSG, 0, 'db_config');
is $ret => 0, 'disable query planner stability guarantee';
}
}
# TRIGGER_EQP
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'TRIGGER_EQP is not supported', 3 if !SQLITE_DBCONFIG_TRIGGER_EQP;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_TRIGGER_EQP, -1, 'db_config');
note "current TRIGGER_EQP value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_TRIGGER_EQP, 1, 'db_config');
is $ret => 1, 'trigger explain query plan';
# TODO: add trigger check
$ret = $dbh->$func(SQLITE_DBCONFIG_TRIGGER_EQP, 0, 'db_config');
is $ret => 0, 'no trigger explain query plan';
}
}
# RESET_DATABASE
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'RESET_DATABASE is not supported', 3 if !SQLITE_DBCONFIG_RESET_DATABASE;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_RESET_DATABASE, -1, 'db_config');
note "current RESET_DATABASE value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_RESET_DATABASE, 1, 'db_config');
is $ret => 1, 'enable reset database';
# TODO: add reset check
$ret = $dbh->$func(SQLITE_DBCONFIG_RESET_DATABASE, 0, 'db_config');
is $ret => 0, 'disable reset database';
}
}
# DEFENSIVE
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'DEFENSIVE is not supported', 8 if !SQLITE_DBCONFIG_DEFENSIVE;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $sql = 'CREATE TABLE foo (id, text)';
$dbh->do($sql);
$dbh->do('PRAGMA writable_schema=ON');
my $row = $dbh->selectrow_hashref('SELECT * FROM sqlite_master WHERE name = ?', {Slice => +{}}, 'foo');
is $row->{sql} => $sql, 'found sql';
my $ret = $dbh->$func(SQLITE_DBCONFIG_DEFENSIVE, -1, 'db_config');
note "current DEFENSIVE value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_DEFENSIVE, 1, 'db_config');
is $ret => 1;
eval { $dbh->do('UPDATE sqlite_master SET name = ? WHERE name = ?', undef, 'bar', 'foo'); };
ok $@, "updating sqlite_master is prohibited";
like $@ => qr/table sqlite_master may not be modified/;
$ret = $dbh->$func(SQLITE_DBCONFIG_DEFENSIVE, 0, 'db_config');
is $ret => 0;
$ret = $dbh->do('UPDATE sqlite_master SET name = ? WHERE name = ?', undef, 'bar', 'foo');
ok $ret, 'updating sqlite_master is succeeded';
$row = $dbh->selectrow_hashref('SELECT * FROM sqlite_master WHERE name = ?', {Slice => +{}}, 'foo');
ok !$row, 'sql not found';
}
}
# DEFENSIVE at connection
SKIP: {
skip 'DEFENSIVE is not supported', 3 if !SQLITE_DBCONFIG_DEFENSIVE;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0, sqlite_defensive => 1);
my $sql = 'CREATE TABLE foo (id, text)';
$dbh->do($sql);
$dbh->do('PRAGMA writable_schema=ON');
eval { $dbh->do('UPDATE sqlite_master SET name = ? WHERE name = ?', undef, 'bar', 'foo'); };
ok $@, "updating sqlite_master is prohibited";
like $@ => qr/table sqlite_master may not be modified/;
}
# WRITABLE_SCHEMA
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'WRITABLE_SCHEMA is not supported', 5 if !SQLITE_DBCONFIG_WRITABLE_SCHEMA;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, 'db_config');
note "current WRITABLE_SCHEMA value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 'db_config');
is $ret => 1, 'schema is writable';
$ret = $dbh->$func(SQLITE_DBCONFIG_WRITABLE_SCHEMA, 0, 'db_config');
is $ret => 0, 'schema is not writable';
$dbh->do('PRAGMA writable_schema=ON');
$ret = $dbh->$func(SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, 'db_config');
is $ret => 1, 'schema is writable (by pragma)';
$dbh->do('PRAGMA writable_schema=OFF');
$ret = $dbh->$func(SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, 'db_config');
is $ret => 0, 'schema is not writable (by pragma)';
}
}
# LEGACY_ALTER_TABLE
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'WRITABLE_SCHEMA is not supported', 5 if !SQLITE_DBCONFIG_LEGACY_ALTER_TABLE;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, -1, 'db_config');
note "current LEGACY_ALTER_TABLE value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, 1, 'db_config');
is $ret => 1, 'use legacy alter table';
$ret = $dbh->$func(SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, 0, 'db_config');
is $ret => 0, 'no legacy alter table';
# TODO: add alter table check?
$dbh->do('PRAGMA legacy_alter_table=ON');
$ret = $dbh->$func(SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, -1, 'db_config');
is $ret => 1, 'use legacy alter table (by pragma)';
$dbh->do('PRAGMA legacy_alter_table=OFF');
$ret = $dbh->$func(SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, -1, 'db_config');
is $ret => 0, 'no legacy alter table (by pragma)';
}
}
# DQS_DML
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'DQS_DML is not supported', 5 if !SQLITE_DBCONFIG_DQS_DML;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_DQS_DML, -1, 'db_config');
note "current DQS_DML value: $ret";
$dbh->do('CREATE TABLE foo (id, text)');
$ret = $dbh->$func(SQLITE_DBCONFIG_DQS_DML, 1, 'db_config');
is $ret => 1, 'allows double-quoted string literal';
eval { $dbh->do('INSERT INTO foo VALUES (1, "text")'); };
ok !$@, "double-quoted string literal is allowed";
$ret = $dbh->$func(SQLITE_DBCONFIG_DQS_DML, 0, 'db_config');
is $ret => 0, 'no double-quoted string literal';
eval { $dbh->do('INSERT INTO foo VALUES (2, "text2")'); };
like $@ => qr/no such column/, "double-quoted string literal is not allowed";
}
}
# DQS_DDL
for my $func (@CALL_FUNCS) {
SKIP: {
skip 'DQS_DDL is not supported', 5 if !SQLITE_DBCONFIG_DQS_DDL;
my $dbh = connect_ok(RaiseError => 1, PrintError => 0);
my $ret = $dbh->$func(SQLITE_DBCONFIG_DQS_DDL, -1, 'db_config');
note "current DQS_DDL value: $ret";
$ret = $dbh->$func(SQLITE_DBCONFIG_DQS_DDL, 1, 'db_config');
is $ret => 1, 'allows double-quoted string literal';
eval { $dbh->do('CREATE TABLE foo (a, b, c CHECK (c!="null") )'); };
ok !$@, "double-quoted string literal is allowed";
$ret = $dbh->$func(SQLITE_DBCONFIG_DQS_DDL, 0, 'db_config');
is $ret => 0, 'no double-quoted string literal';
eval { $dbh->do('CREATE TABLE bar (a, b, c CHECK (c!="null") )'); };
like $@ => qr/no such column/, "double-quoted string literal is not allowed";
}
}
done_testing;
|
