gitlab.com/CoiaPrant/sqlite3@v1.19.1/testdata/tcl/fts3cov.test (about) 1 # 2009 December 03 2 # 3 # May you do good and not evil. 4 # May you find forgiveness for yourself and forgive others. 5 # May you share freely, never taking more than you give. 6 # 7 #*********************************************************************** 8 # 9 # The tests in this file are structural coverage tests for FTS3. 10 # 11 12 set testdir [file dirname $argv0] 13 source $testdir/tester.tcl 14 15 # If this build does not include FTS3, skip the tests in this file. 16 # 17 ifcapable !fts3 { finish_test ; return } 18 source $testdir/fts3_common.tcl 19 source $testdir/malloc_common.tcl 20 21 set DO_MALLOC_TEST 0 22 set testprefix fts3cov 23 24 #-------------------------------------------------------------------------- 25 # When it first needs to read a block from the %_segments table, the FTS3 26 # module compiles an SQL statement for that purpose. The statement is 27 # stored and reused each subsequent time a block is read. This test case 28 # tests the effects of an OOM error occuring while compiling the statement. 29 # 30 # Similarly, when FTS3 first needs to scan through a set of segment leaves 31 # to find a set of documents that matches a term, it allocates a string 32 # containing the text of the required SQL, and compiles one or more 33 # statements to traverse the leaves. This test case tests that OOM errors 34 # that occur while allocating this string and statement are handled correctly 35 # also. 36 # 37 do_test fts3cov-1.1 { 38 execsql { 39 CREATE VIRTUAL TABLE t1 USING fts3(x); 40 INSERT INTO t1(t1) VALUES('nodesize=24'); 41 BEGIN; 42 INSERT INTO t1 VALUES('Is the night chilly and dark?'); 43 INSERT INTO t1 VALUES('The night is chilly, but not dark.'); 44 INSERT INTO t1 VALUES('The thin gray cloud is spread on high,'); 45 INSERT INTO t1 VALUES('It covers but not hides the sky.'); 46 COMMIT; 47 SELECT count(*)>0 FROM t1_segments; 48 } 49 } {1} 50 51 set DO_MALLOC_TEST 1 52 do_restart_select_test fts3cov-1.2 { 53 SELECT docid FROM t1 WHERE t1 MATCH 'chilly'; 54 } {1 2} 55 set DO_MALLOC_TEST 0 56 57 #-------------------------------------------------------------------------- 58 # When querying the full-text index, if an expected internal node block is 59 # missing from the %_segments table, or if a NULL value is stored in the 60 # %_segments table instead of a binary blob, database corruption should be 61 # reported. 62 # 63 # Even with tiny 24 byte nodes, it takes a fair bit of data to produce a 64 # segment b-tree that uses the %_segments table to store internal nodes. 65 # 66 do_test fts3cov-2.1 { 67 execsql { 68 INSERT INTO t1(t1) VALUES('nodesize=24'); 69 BEGIN; 70 INSERT INTO t1 VALUES('The moon is behind, and at the full;'); 71 INSERT INTO t1 VALUES('And yet she looks both small and dull.'); 72 INSERT INTO t1 VALUES('The night is chill, the cloud is gray:'); 73 INSERT INTO t1 VALUES('''T is a month before the month of May,'); 74 INSERT INTO t1 VALUES('And the Spring comes slowly up this way.'); 75 INSERT INTO t1 VALUES('The lovely lady, Christabel,'); 76 INSERT INTO t1 VALUES('Whom her father loves so well,'); 77 INSERT INTO t1 VALUES('What makes her in the wood so late,'); 78 INSERT INTO t1 VALUES('A furlong from the castle gate?'); 79 INSERT INTO t1 VALUES('She had dreams all yesternight'); 80 INSERT INTO t1 VALUES('Of her own betrothed knight;'); 81 INSERT INTO t1 VALUES('And she in the midnight wood will pray'); 82 INSERT INTO t1 VALUES('For the weal of her lover that''s far away.'); 83 COMMIT; 84 } 85 execsql { 86 INSERT INTO t1(t1) VALUES('optimize'); 87 SELECT substr(hex(root), 1, 2) FROM t1_segdir; 88 } 89 } {03} 90 91 # Test the "missing entry" case: 92 sqlite3_db_config db DEFENSIVE 0 93 do_test fts3cov-2.2 { 94 set root [db one {SELECT root FROM t1_segdir}] 95 read_fts3varint [string range $root 1 end] left_child 96 execsql { DELETE FROM t1_segments WHERE blockid = $left_child } 97 } {} 98 do_error_test fts3cov-2.3 { 99 SELECT * FROM t1 WHERE t1 MATCH 'c*' 100 } {database disk image is malformed} 101 102 # Test the "replaced with NULL" case: 103 do_test fts3cov-2.4 { 104 execsql { INSERT INTO t1_segments VALUES($left_child, NULL) } 105 } {} 106 do_error_test fts3cov-2.5 { 107 SELECT * FROM t1 WHERE t1 MATCH 'cloud' 108 } {database disk image is malformed} 109 110 #-------------------------------------------------------------------------- 111 # The following tests are to test the effects of OOM errors while storing 112 # terms in the pending-hash table. Specifically, while creating doclist 113 # blobs to store in the table. More specifically, to test OOM errors while 114 # appending column numbers to doclists. For example, if a doclist consists 115 # of: 116 # 117 # <docid> <column 0 offset-list> 0x01 <column N> <column N offset-list> 118 # 119 # The following tests check that malloc errors encountered while appending 120 # the "0x01 <column N>" data to the dynamically growable blob used to 121 # accumulate the doclist in memory are handled correctly. 122 # 123 do_test fts3cov-3.1 { 124 set cols [list] 125 set vals [list] 126 for {set i 0} {$i < 120} {incr i} { 127 lappend cols "col$i" 128 lappend vals "'word'" 129 } 130 execsql "CREATE VIRTUAL TABLE t2 USING fts3([join $cols ,])" 131 } {} 132 set DO_MALLOC_TEST 1 133 do_write_test fts3cov-3.2 t2_content " 134 INSERT INTO t2(docid, [join $cols ,]) VALUES(1, [join $vals ,]) 135 " 136 do_write_test fts3cov-3.3 t2_content " 137 INSERT INTO t2(docid, [join $cols ,]) VALUES(200, [join $vals ,]) 138 " 139 do_write_test fts3cov-3.4 t2_content " 140 INSERT INTO t2(docid, [join $cols ,]) VALUES(60000, [join $vals ,]) 141 " 142 143 #------------------------------------------------------------------------- 144 # If too much data accumulates in the pending-terms hash table, it is 145 # flushed to the database automatically, even if the transaction has not 146 # finished. The following tests check the effects of encountering an OOM 147 # while doing this. 148 # 149 do_test fts3cov-4.1 { 150 execsql { 151 CREATE VIRTUAL TABLE t3 USING fts3(x); 152 INSERT INTO t3(t3) VALUES('nodesize=24'); 153 INSERT INTO t3(t3) VALUES('maxpending=100'); 154 } 155 } {} 156 set DO_MALLOC_TEST 1 157 do_write_test fts3cov-4.2 t3_content { 158 INSERT INTO t3(docid, x) 159 SELECT 1, 'Then Christabel stretched forth her hand,' UNION ALL 160 SELECT 3, 'And comforted fair Geraldine:' UNION ALL 161 SELECT 4, '''O well, bright dame, may you command' UNION ALL 162 SELECT 5, 'The service of Sir Leoline;' UNION ALL 163 SELECT 2, 'And gladly our stout chivalry' UNION ALL 164 SELECT 7, 'Will he send forth, and friends withal,' UNION ALL 165 SELECT 8, 'To guide and guard you safe and free' UNION ALL 166 SELECT 6, 'Home to your noble father''s hall.''' 167 } 168 169 #------------------------------------------------------------------------- 170 # When building the internal tree structure for each segment b-tree, FTS3 171 # assumes that the content of each internal node will be less than 172 # $nodesize bytes, where $nodesize is the advisory node size. If this turns 173 # out to be untrue, then an extra buffer must be malloc'd for each term. 174 # This test case tests these paths and the effects of said mallocs failing 175 # by inserting insert a document with some fairly large terms into a 176 # full-text table with a very small node-size. 177 # 178 # Test this handling of large terms in three contexts: 179 # 180 # 1. When flushing the pending-terms table. 181 # 2. When optimizing the data structures using the INSERT syntax. 182 # 2. When optimizing the data structures using the deprecated SELECT syntax. 183 # 184 do_test fts3cov-5.1 { 185 execsql { 186 CREATE VIRTUAL TABLE t4 USING fts3(x); 187 INSERT INTO t4(t4) VALUES('nodesize=24'); 188 } 189 } {} 190 set DO_MALLOC_TEST 1 191 192 # Test when flushing pending-terms table. 193 do_write_test fts3cov-5.2 t4_content { 194 INSERT INTO t4 195 SELECT 'ItisanancientMarinerAndhestoppethoneofthreeAA' UNION ALL 196 SELECT 'ItisanancientMarinerAndhestoppethoneofthreeBB' UNION ALL 197 SELECT 'ItisanancientMarinerAndhestoppethoneofthreeCC' UNION ALL 198 SELECT 'BythylonggreybeardandglitteringeyeNowwhereforestoppstAA' UNION ALL 199 SELECT 'BythylonggreybeardandglitteringeyeNowwhereforestoppstBB' UNION ALL 200 SELECT 'BythylonggreybeardandglitteringeyeNowwhereforestoppstCC' 201 } 202 203 # Test when optimizing via INSERT. 204 do_test fts3cov-5.3 { execsql { INSERT INTO t4 VALUES('extra!') } } {} 205 do_write_test fts3cov-5.2 t4_segments { INSERT INTO t4(t4) VALUES('optimize') } 206 207 # Test when optimizing via SELECT. 208 do_test fts3cov-5.5 { execsql { INSERT INTO t4 VALUES('more extra!') } } {} 209 do_write_test fts3cov-5.6 t4_segments { 210 SELECT * FROM (SELECT optimize(t4) FROM t4 LIMIT 1) 211 EXCEPT SELECT 'Index optimized' 212 } 213 214 #------------------------------------------------------------------------- 215 # When merging all segments at a given level to create a single segment 216 # at level+1, FTS3 runs a query of the form: 217 # 218 # SELECT count(*) FROM %_segdir WHERE level = ? 219 # 220 # The query is compiled the first time this operation is required and 221 # reused thereafter. This test aims to test the effects of an OOM while 222 # preparing and executing this query for the first time. 223 # 224 # Then, keep inserting rows into the table so that the effects of an OOM 225 # while re-executing the same query can also be tested. 226 # 227 do_test fts3cov-6.1 { 228 execsql { CREATE VIRTUAL TABLE t5 USING fts3(x) } 229 for {set i 0} {$i<16} {incr i} { execsql "INSERT INTO t5 VALUES('term$i')" } 230 execsql { SELECT count(*) FROM t5_segdir } 231 } {16} 232 233 # First time. 234 db close 235 sqlite3 db test.db 236 do_write_test fts3cov-6.2 t5_content { 237 INSERT INTO t5 VALUES('segment number 16!'); 238 } 239 240 # Second time. 241 do_test fts3cov-6.3 { 242 for {set i 1} {$i<16} {incr i} { execsql "INSERT INTO t5 VALUES('term$i')" } 243 execsql { SELECT count(*) FROM t5_segdir } 244 } {17} 245 do_write_test fts3cov-6.4 t5_content { 246 INSERT INTO t5 VALUES('segment number 16!'); 247 } 248 249 #------------------------------------------------------------------------- 250 # Update the docid of a row. Test this in two scenarios: 251 # 252 # 1. When the row being updated is the only row in the table. 253 # 2. When it is not. 254 # 255 # The two cases above take different paths because in case 1 all data 256 # structures can simply be emptied before inserting the new row record. 257 # In case 2, the data structures actually have to be updated. 258 # 259 do_test fts3cov-7.1 { 260 execsql { 261 CREATE VIRTUAL TABLE t7 USING fts3(a, b, c); 262 INSERT INTO t7 VALUES('A', 'B', 'C'); 263 UPDATE t7 SET docid = 5; 264 SELECT docid, * FROM t7; 265 } 266 } {5 A B C} 267 do_test fts3cov-7.2 { 268 execsql { 269 INSERT INTO t7 VALUES('D', 'E', 'F'); 270 UPDATE t7 SET docid = 1 WHERE docid = 6; 271 SELECT docid, * FROM t7; 272 } 273 } {1 D E F 5 A B C} 274 275 #------------------------------------------------------------------------- 276 # If a set of documents are modified within a transaction, the 277 # pending-terms table must be flushed each time a document with a docid 278 # less than or equal to the previous docid is modified. 279 # 280 # This test checks the effects of an OOM error occuring when the 281 # pending-terms table is flushed for this reason as part of a DELETE 282 # statement. 283 # 284 do_malloc_test fts3cov-8 -sqlprep { 285 BEGIN; 286 CREATE VIRTUAL TABLE t8 USING fts3; 287 INSERT INTO t8 VALUES('the output of each batch run'); 288 INSERT INTO t8 VALUES('(possibly a day''s work)'); 289 INSERT INTO t8 VALUES('was written to two separate disks'); 290 COMMIT; 291 } -sqlbody { 292 BEGIN; 293 DELETE FROM t8 WHERE rowid = 3; 294 DELETE FROM t8 WHERE rowid = 2; 295 DELETE FROM t8 WHERE rowid = 1; 296 COMMIT; 297 } 298 299 #------------------------------------------------------------------------- 300 # Test some branches in the code that handles "special" inserts like: 301 # 302 # INSERT INTO t1(t1) VALUES('optimize'); 303 # 304 # Also test that an optimize (INSERT method) works on an empty table. 305 # 306 set DO_MALLOC_TEST 0 307 do_test fts3cov-9.1 { 308 execsql { CREATE VIRTUAL TABLE xx USING fts3 } 309 } {} 310 do_error_test fts3cov-9.2 { 311 INSERT INTO xx(xx) VALUES('optimise'); -- British spelling 312 } {SQL logic error} 313 do_error_test fts3cov-9.3 { 314 INSERT INTO xx(xx) VALUES('short'); 315 } {SQL logic error} 316 do_error_test fts3cov-9.4 { 317 INSERT INTO xx(xx) VALUES('waytoolongtobecorrect'); 318 } {SQL logic error} 319 do_test fts3cov-9.5 { 320 execsql { INSERT INTO xx(xx) VALUES('optimize') } 321 } {} 322 323 #------------------------------------------------------------------------- 324 # Test that a table can be optimized in the middle of a transaction when 325 # the pending-terms table is non-empty. This case involves some extra 326 # branches because data must be read not only from the database, but 327 # also from the pending-terms table. 328 # 329 do_malloc_test fts3cov-10 -sqlprep { 330 CREATE VIRTUAL TABLE t10 USING fts3; 331 INSERT INTO t10 VALUES('Optimising images for the web is a tricky business'); 332 BEGIN; 333 INSERT INTO t10 VALUES('You have to get the right balance between'); 334 } -sqlbody { 335 INSERT INTO t10(t10) VALUES('optimize'); 336 } 337 338 #------------------------------------------------------------------------- 339 # Test a full-text query for a term that was once in the index, but is 340 # no longer. 341 # 342 do_test fts3cov-11.1 { 343 execsql { 344 CREATE VIRTUAL TABLE xx USING fts3; 345 INSERT INTO xx VALUES('one two three'); 346 INSERT INTO xx VALUES('four five six'); 347 DELETE FROM xx WHERE docid = 1; 348 } 349 execsql { SELECT * FROM xx WHERE xx MATCH 'two' } 350 } {} 351 352 353 do_malloc_test fts3cov-12 -sqlprep { 354 CREATE VIRTUAL TABLE t12 USING fts3; 355 INSERT INTO t12 VALUES('is one of the two togther'); 356 BEGIN; 357 INSERT INTO t12 VALUES('one which was appropriate at the time'); 358 } -sqlbody { 359 SELECT * FROM t12 WHERE t12 MATCH 'one' 360 } 361 362 do_malloc_test fts3cov-13 -sqlprep { 363 PRAGMA encoding = 'UTF-16'; 364 CREATE VIRTUAL TABLE t13 USING fts3; 365 INSERT INTO t13 VALUES('two scalar functions'); 366 INSERT INTO t13 VALUES('scalar two functions'); 367 INSERT INTO t13 VALUES('functions scalar two'); 368 } -sqlbody { 369 SELECT snippet(t13, '%%', '%%', '#') FROM t13 WHERE t13 MATCH 'two'; 370 SELECT snippet(t13, '%%', '%%') FROM t13 WHERE t13 MATCH 'two'; 371 SELECT snippet(t13, '%%') FROM t13 WHERE t13 MATCH 'two'; 372 } 373 374 do_execsql_test 14.0 { 375 CREATE VIRTUAL TABLE t14 USING fts4(a, b); 376 INSERT INTO t14 VALUES('one two three', 'one three four'); 377 INSERT INTO t14 VALUES('a b c', 'd e a'); 378 } 379 do_execsql_test 14.1 { 380 SELECT rowid FROM t14 WHERE t14 MATCH '"one two three"' 381 } {1} 382 do_execsql_test 14.2 { 383 SELECT rowid FROM t14 WHERE t14 MATCH '"one four"' 384 } {} 385 do_execsql_test 14.3 { 386 SELECT rowid FROM t14 WHERE t14 MATCH '"e a"' 387 } {2} 388 do_execsql_test 14.5 { 389 SELECT rowid FROM t14 WHERE t14 MATCH '"e b"' 390 } {} 391 do_catchsql_test 14.6 { 392 SELECT rowid FROM t14 WHERE rowid MATCH 'one' 393 } {1 {unable to use function MATCH in the requested context}} 394 do_catchsql_test 14.7 { 395 SELECT rowid FROM t14 WHERE docid MATCH 'one' 396 } {1 {unable to use function MATCH in the requested context}} 397 398 do_execsql_test 15.0 { 399 CREATE VIRTUAL TABLE t15 USING fts4(a, b, c); 400 INSERT INTO t15 VALUES('abc def ghi', 'abc2 def2 ghi2', 'abc3 def3 ghi3'); 401 INSERT INTO t15 VALUES('abc2 def2 ghi2', 'abc2 def2 ghi2', 'abc def3 ghi3'); 402 } 403 do_execsql_test 15.1 { 404 SELECT rowid FROM t15 WHERE t15 MATCH '"abc* def2"' 405 } {1 2} 406 407 # Test a corruption case. 408 # 409 sqlite3_db_config db DEFENSIVE 0 410 do_execsql_test 16.1 { 411 CREATE VIRTUAL TABLE t16 USING fts4; 412 INSERT INTO t16 VALUES('theoretical work to examine the relationship'); 413 INSERT INTO t16 VALUES('solution of our problems on the invisible'); 414 DELETE FROM t16_content WHERE rowid = 2; 415 } 416 do_catchsql_test 16.2 { 417 SELECT * FROM t16 WHERE t16 MATCH 'invisible' 418 } {1 {database disk image is malformed}} 419 420 # And another corruption test case. 421 # 422 do_execsql_test 17.1 { 423 CREATE VIRTUAL TABLE t17 USING fts4; 424 INSERT INTO t17(content) VALUES('one one one'); 425 UPDATE t17_segdir SET root = X'00036F6E65FFFFFFFFFFFFFFFFFFFFFF02030300' 426 } {} 427 do_catchsql_test 17.2 { 428 SELECT * FROM t17 WHERE t17 MATCH 'one' 429 } {1 {database disk image is malformed}} 430 431 432 433 434 finish_test