Debian Codegraph @

test/fts3auto.test

raw
1 # 2011 June 10
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
10 set testdir [file dirname $argv0]
11 source $testdir/tester.tcl
12
13 # If this build does not include FTS3, skip the tests in this file.
14 #
15 ifcapable !fts3 { finish_test ; return }
16 source $testdir/fts3_common.tcl
17 source $testdir/malloc_common.tcl
18
19 set testprefix fts3auto
20 set sfep $sqlite_fts3_enable_parentheses
21 set sqlite_fts3_enable_parentheses 1
22
23 #--------------------------------------------------------------------------
24 # Start of Tcl infrastructure used by tests. The entry points are:
25 #
26 # do_fts3query_test
27 # fts3_make_deferrable
28 # fts3_zero_long_segments
29 #
30
31 #
32 # do_fts3query_test TESTNAME ?OPTIONS? TABLE MATCHEXPR
33 #
34 # This proc runs several test cases on FTS3/4 table $TABLE using match
35 # expression $MATCHEXPR. All documents in $TABLE must be formatted so that
36 # they can be "tokenized" using the Tcl list commands (llength, lindex etc.).
37 # The name and column names used by $TABLE must not require any quoting or
38 # escaping when used in SQL statements.
39 #
40 # $MATCHINFO may be any expression accepted by the FTS4 MATCH operator,
41 # except that the "<column-name>:token" syntax is not supported. Tcl list
42 # commands are used to tokenize the expression. Any parenthesis must appear
43 # either as separate list elements, or as the first (for opening) or last
44 # (for closing) character of a list element. i.e. the expression "(a OR b)c"
45 # will not be parsed correctly, but "( a OR b) c" will.
46 #
47 # Available OPTIONS are:
48 #
49 # -deferred TOKENLIST
50 #
51 # If the "deferred" option is supplied, it is passed a list of tokens that
52 # are deferred by FTS and result in the relevant matchinfo() stats being an
53 # approximation.
54 #
55 set sqlite_fts3_enable_parentheses 1
56 proc do_fts3query_test {tn args} {
57
58 set nArg [llength $args]
59 if {$nArg < 2 || ($nArg % 2)} {
60 set cmd do_fts3query_test
61 error "wrong # args: should be \"$cmd ?-deferred LIST? TABLE MATCHEXPR\""
62 }
63 set tbl [lindex $args [expr $nArg-2]]
64 set match [lindex $args [expr $nArg-1]]
65 set deferred [list]
66
67 foreach {k v} [lrange $args 0 [expr $nArg-3]] {
68 switch -- $k {
69 -deferred {
70 ifcapable fts4_deferred { set deferred $v }
71 }
72 default {
73 error "bad option \"$k\": must be -deferred"
74 }
75 }
76 }
77
78 get_near_results $tbl $match $deferred aHit
79 get_near_results $tbl [string map {AND OR} $match] $deferred aMatchinfo
80
81 set matchinfo_asc [list]
82 foreach docid [lsort -integer -incr [array names aHit]] {
83 lappend matchinfo_asc $docid $aMatchinfo($docid)
84 }
85 set matchinfo_desc [list]
86 foreach docid [lsort -integer -decr [array names aHit]] {
87 lappend matchinfo_desc $docid $aMatchinfo($docid)
88 }
89
90 set title "(\"$match\" -> [llength [array names aHit]] rows)"
91
92 do_execsql_test $tn$title.1 "
93 SELECT docid FROM $tbl WHERE $tbl MATCH '$match' ORDER BY docid ASC
94 " [lsort -integer -incr [array names aHit]]
95
96 do_execsql_test $tn$title.2 "
97 SELECT docid FROM $tbl WHERE $tbl MATCH '$match' ORDER BY docid DESC
98 " [lsort -integer -decr [array names aHit]]
99
100 do_execsql_test $tn$title.3 "
101 SELECT docid, mit(matchinfo($tbl, 'x')) FROM $tbl
102 WHERE $tbl MATCH '$match' ORDER BY docid DESC
103 " $matchinfo_desc
104
105 do_execsql_test $tn$title.4 "
106 SELECT docid, mit(matchinfo($tbl, 'x')) FROM $tbl
107 WHERE $tbl MATCH '$match' ORDER BY docid ASC
108 " $matchinfo_asc
109 }
110
111 # fts3_make_deferrable TABLE TOKEN ?NROW?
112 #
113 proc fts3_make_deferrable {tbl token {nRow 0}} {
114
115 set stmt [sqlite3_prepare db "SELECT * FROM $tbl" -1 dummy]
116 set name [sqlite3_column_name $stmt 0]
117 sqlite3_finalize $stmt
118
119 if {$nRow==0} {
120 set nRow [db one "SELECT count(*) FROM $tbl"]
121 }
122 set pgsz [db one "PRAGMA page_size"]
123 execsql BEGIN
124 for {set i 0} {$i < ($nRow * $pgsz * 1.2)/100} {incr i} {
125 set doc [string repeat "$token " 100]
126 execsql "INSERT INTO $tbl ($name) VALUES(\$doc)"
127 }
128 execsql "INSERT INTO $tbl ($name) VALUES('aaaaaaa ${token}aaaaa')"
129 execsql COMMIT
130
131 return [expr $nRow*$pgsz]
132 }
133
134 # fts3_zero_long_segments TABLE ?LIMIT?
135 #
136 proc fts3_zero_long_segments {tbl limit} {
137 sqlite3_db_config db DEFENSIVE 0
138 execsql "
139 UPDATE ${tbl}_segments
140 SET block = zeroblob(length(block))
141 WHERE length(block)>$limit
142 "
143 return [db changes]
144 }
145
146
147 proc mit {blob} {
148 set scan(littleEndian) i*
149 set scan(bigEndian) I*
150 binary scan $blob $scan($::tcl_platform(byteOrder)) r
151 return $r
152 }
153 db func mit mit
154
155 proc fix_phrase_expr {cols expr colfiltervar} {
156 upvar $colfiltervar iColFilter
157
158 set out [list]
159 foreach t $expr {
160 if {[string match *:* $t]} {
161 set col [lindex [split $t :] 0]
162 set t [lindex [split $t :] 1]
163 set iCol [lsearch $cols $col]
164 if {$iCol<0} { error "unknown column: $col" }
165 if {$iColFilter < 0} {
166 set iColFilter $iCol
167 } elseif {$iColFilter != $iCol} {
168 set iColFilter [llength $cols]
169 }
170 }
171 lappend out $t
172 }
173
174 return $out
175 }
176
177 proc fix_near_expr {cols expr colfiltervar} {
178 upvar $colfiltervar iColFilter
179
180 set iColFilter -1
181
182 set out [list]
183 lappend out [fix_phrase_expr $cols [lindex $expr 0] iColFilter]
184 foreach {a b} [lrange $expr 1 end] {
185 if {[string match -nocase near $a]} { set a 10 }
186 if {[string match -nocase near/* $a]} { set a [string range $a 5 end] }
187 lappend out $a
188 lappend out [fix_phrase_expr $cols $b iColFilter]
189 }
190 return $out
191 }
192
193 proc get_single_near_results {tbl expr deferred arrayvar nullvar} {
194 upvar $arrayvar aMatchinfo
195 upvar $nullvar nullentry
196 catch {array unset aMatchinfo}
197
198 set cols [list]
199 set miss [list]
200 db eval "PRAGMA table_info($tbl)" A { lappend cols $A(name) ; lappend miss 0 }
201 set expr [fix_near_expr $cols $expr iColFilter]
202
203 # Calculate the expected results using [fts3_near_match]. The following
204 # loop populates the "hits" and "counts" arrays as follows:
205 #
206 # 1. For each document in the table that matches the NEAR expression,
207 # hits($docid) is set to 1. The set of docids that match the expression
208 # can therefore be found using [array names hits].
209 #
210 # 2. For each column of each document in the table, counts($docid,$iCol)
211 # is set to the -phrasecountvar output.
212 #
213 set res [list]
214 catch { array unset hits }
215 db eval "SELECT docid, * FROM $tbl" d {
216 set iCol 0
217 foreach col [lrange $d(*) 1 end] {
218 set docid $d(docid)
219 if {$iColFilter<0 || $iCol==$iColFilter} {
220 set hit [fts3_near_match $d($col) $expr -p counts($docid,$iCol)]
221 if {$hit} { set hits($docid) 1 }
222 } else {
223 set counts($docid,$iCol) $miss
224 }
225 incr iCol
226 }
227 }
228 set nPhrase [expr ([llength $expr]+1)/2]
229 set nCol $iCol
230
231 # This block populates the nHit and nDoc arrays. For each phrase/column
232 # in the query/table, array elements are set as follows:
233 #
234 # nHit($iPhrase,$iCol) - Total number of hits for phrase $iPhrase in
235 # column $iCol.
236 #
237 # nDoc($iPhrase,$iCol) - Number of documents with at least one hit for
238 # phrase $iPhrase in column $iCol.
239 #
240 for {set iPhrase 0} {$iPhrase < $nPhrase} {incr iPhrase} {
241 for {set iCol 0} {$iCol < $nCol} {incr iCol} {
242 set nHit($iPhrase,$iCol) 0
243 set nDoc($iPhrase,$iCol) 0
244 }
245 }
246 foreach key [array names counts] {
247 set iCol [lindex [split $key ,] 1]
248 set iPhrase 0
249 foreach c $counts($key) {
250 if {$c>0} { incr nDoc($iPhrase,$iCol) 1 }
251 incr nHit($iPhrase,$iCol) $c
252 incr iPhrase
253 }
254 }
255
256 if {[llength $deferred] && [llength $expr]==1} {
257 set phrase [lindex $expr 0]
258 set rewritten [list]
259 set partial 0
260 foreach tok $phrase {
261 if {[lsearch $deferred $tok]>=0} {
262 lappend rewritten *
263 } else {
264 lappend rewritten $tok
265 set partial 1
266 }
267 }
268 if {$partial==0} {
269 set tblsize [db one "SELECT count(*) FROM $tbl"]
270 for {set iCol 0} {$iCol < $nCol} {incr iCol} {
271 set nHit(0,$iCol) $tblsize
272 set nDoc(0,$iCol) $tblsize
273 }
274 } elseif {$rewritten != $phrase} {
275 while {[lindex $rewritten end] == "*"} {
276 set rewritten [lrange $rewritten 0 end-1]
277 }
278 while {[lindex $rewritten 0] == "*"} {
279 set rewritten [lrange $rewritten 1 end]
280 }
281 get_single_near_results $tbl [list $rewritten] {} aRewrite nullentry
282 foreach docid [array names hits] {
283 set aMatchinfo($docid) $aRewrite($docid)
284 }
285 return
286 }
287 }
288
289 # Set up the aMatchinfo array. For each document, set aMatchinfo($docid) to
290 # contain the output of matchinfo('x') for the document.
291 #
292 foreach docid [array names hits] {
293 set mi [list]
294 for {set iPhrase 0} {$iPhrase<$nPhrase} {incr iPhrase} {
295 for {set iCol 0} {$iCol<$nCol} {incr iCol} {
296 lappend mi [lindex $counts($docid,$iCol) $iPhrase]
297 lappend mi $nHit($iPhrase,$iCol)
298 lappend mi $nDoc($iPhrase,$iCol)
299 }
300 }
301 set aMatchinfo($docid) $mi
302 }
303
304 # Set up the nullentry output.
305 #
306 set nullentry [list]
307 for {set iPhrase 0} {$iPhrase<$nPhrase} {incr iPhrase} {
308 for {set iCol 0} {$iCol<$nCol} {incr iCol} {
309 lappend nullentry 0 $nHit($iPhrase,$iCol) $nDoc($iPhrase,$iCol)
310 }
311 }
312 }
313
314
315 proc matching_brackets {expr} {
316 if {[string range $expr 0 0]!="(" || [string range $expr end end] !=")"} {
317 return 0
318 }
319
320 set iBracket 1
321 set nExpr [string length $expr]
322 for {set i 1} {$iBracket && $i < $nExpr} {incr i} {
323 set c [string range $expr $i $i]
324 if {$c == "("} {incr iBracket}
325 if {$c == ")"} {incr iBracket -1}
326 }
327
328 return [expr ($iBracket==0 && $i==$nExpr)]
329 }
330
331 proc get_near_results {tbl expr deferred arrayvar {nullvar ""}} {
332 upvar $arrayvar aMatchinfo
333 if {$nullvar != ""} { upvar $nullvar nullentry }
334
335 set expr [string trim $expr]
336 while { [matching_brackets $expr] } {
337 set expr [string trim [string range $expr 1 end-1]]
338 }
339
340 set prec(NOT) 1
341 set prec(AND) 2
342 set prec(OR) 3
343
344 set currentprec 0
345 set iBracket 0
346 set expr_length [llength $expr]
347 for {set i 0} {$i < $expr_length} {incr i} {
348 set op [lindex $expr $i]
349 if {$iBracket==0 && [info exists prec($op)] && $prec($op)>=$currentprec } {
350 set opidx $i
351 set currentprec $prec($op)
352 } else {
353 for {set j 0} {$j < [string length $op]} {incr j} {
354 set c [string range $op $j $j]
355 if {$c == "("} { incr iBracket +1 }
356 if {$c == ")"} { incr iBracket -1 }
357 }
358 }
359 }
360 if {$iBracket!=0} { error "mismatched brackets in: $expr" }
361
362 if {[info exists opidx]==0} {
363 get_single_near_results $tbl $expr $deferred aMatchinfo nullentry
364 } else {
365 set eLeft [lrange $expr 0 [expr $opidx-1]]
366 set eRight [lrange $expr [expr $opidx+1] end]
367
368 get_near_results $tbl $eLeft $deferred aLeft nullleft
369 get_near_results $tbl $eRight $deferred aRight nullright
370
371 switch -- [lindex $expr $opidx] {
372 "NOT" {
373 foreach hit [array names aLeft] {
374 if {0==[info exists aRight($hit)]} {
375 set aMatchinfo($hit) $aLeft($hit)
376 }
377 }
378 set nullentry $nullleft
379 }
380
381 "AND" {
382 foreach hit [array names aLeft] {
383 if {[info exists aRight($hit)]} {
384 set aMatchinfo($hit) [concat $aLeft($hit) $aRight($hit)]
385 }
386 }
387 set nullentry [concat $nullleft $nullright]
388 }
389
390 "OR" {
391 foreach hit [array names aLeft] {
392 if {[info exists aRight($hit)]} {
393 set aMatchinfo($hit) [concat $aLeft($hit) $aRight($hit)]
394 unset aRight($hit)
395 } else {
396 set aMatchinfo($hit) [concat $aLeft($hit) $nullright]
397 }
398 }
399 foreach hit [array names aRight] {
400 set aMatchinfo($hit) [concat $nullleft $aRight($hit)]
401 }
402
403 set nullentry [concat $nullleft $nullright]
404 }
405 }
406 }
407 }
408
409
410 # End of test procs. Actual tests are below this line.
411 #--------------------------------------------------------------------------
412
413 #--------------------------------------------------------------------------
414 # The following test cases - fts3auto-1.* - focus on testing the Tcl
415 # command [fts3_near_match], which is used by other tests in this file.
416 #
417 proc test_fts3_near_match {tn doc expr res} {
418 fts3_near_match $doc $expr -phrasecountvar p
419 uplevel do_test [list $tn] [list [list set {} $p]] [list $res]
420 }
421
422 test_fts3_near_match 1.1.1 {a b c a b} a {2}
423 test_fts3_near_match 1.1.2 {a b c a b} {a 5 b 6 c} {2 2 1}
424 test_fts3_near_match 1.1.3 {a b c a b} {"a b"} {2}
425 test_fts3_near_match 1.1.4 {a b c a b} {"b c"} {1}
426 test_fts3_near_match 1.1.5 {a b c a b} {"c c"} {0}
427
428 test_fts3_near_match 1.2.1 "a b c d e f g" {b 2 f} {0 0}
429 test_fts3_near_match 1.2.2 "a b c d e f g" {b 3 f} {1 1}
430 test_fts3_near_match 1.2.3 "a b c d e f g" {f 2 b} {0 0}
431 test_fts3_near_match 1.2.4 "a b c d e f g" {f 3 b} {1 1}
432 test_fts3_near_match 1.2.5 "a b c d e f g" {"a b" 2 "f g"} {0 0}
433 test_fts3_near_match 1.2.6 "a b c d e f g" {"a b" 3 "f g"} {1 1}
434
435 set A "a b c d e f g h i j k l m n o p q r s t u v w x y z"
436 test_fts3_near_match 1.3.1 $A {"c d" 5 "i j" 1 "e f"} {0 0 0}
437 test_fts3_near_match 1.3.2 $A {"c d" 5 "i j" 2 "e f"} {1 1 1}
438
439 #--------------------------------------------------------------------------
440 # Test cases fts3auto-2.* run some simple tests using the
441 # [do_fts3query_test] proc.
442 #
443 foreach {tn create} {
444 1 "fts4(a, b)"
445 2 "fts4(a, b, order=DESC)"
446 3 "fts4(a, b, order=ASC)"
447 4 "fts4(a, b, prefix=1)"
448 5 "fts4(a, b, order=DESC, prefix=1)"
449 6 "fts4(a, b, order=ASC, prefix=1)"
450 } {
451 do_test 2.$tn.1 {
452 catchsql { DROP TABLE t1 }
453 execsql "CREATE VIRTUAL TABLE t1 USING $create"
454 for {set i 0} {$i<32} {incr i} {
455 set doc [list]
456 if {$i&0x01} {lappend doc one}
457 if {$i&0x02} {lappend doc two}
458 if {$i&0x04} {lappend doc three}
459 if {$i&0x08} {lappend doc four}
460 if {$i&0x10} {lappend doc five}
461 execsql { INSERT INTO t1 VALUES($doc, null) }
462 }
463 } {}
464
465 foreach {tn2 expr} {
466 1 {one}
467 2 {one NEAR/1 five}
468 3 {t*}
469 4 {t* NEAR/0 five}
470 5 {o* NEAR/1 f*}
471 6 {one NEAR five NEAR two NEAR four NEAR three}
472 7 {one NEAR xyz}
473 8 {one OR two}
474 9 {one AND two}
475 10 {one NOT two}
476 11 {one AND two OR three}
477 12 {three OR one AND two}
478 13 {(three OR one) AND two}
479 14 {(three OR one) AND two NOT (five NOT four)}
480 15 {"one two"}
481 16 {"one two" NOT "three four"}
482 } {
483 do_fts3query_test 2.$tn.2.$tn2 t1 $expr
484 }
485 }
486
487 #--------------------------------------------------------------------------
488 # Some test cases involving deferred tokens.
489 #
490
491 foreach {tn create} {
492 1 "fts4(x)"
493 2 "fts4(x, order=DESC)"
494 } {
495 catchsql { DROP TABLE t1 }
496 execsql "CREATE VIRTUAL TABLE t1 USING $create"
497 do_execsql_test 3.$tn.1 {
498 INSERT INTO t1(docid, x) VALUES(-2, 'a b c d e f g h i j k');
499 INSERT INTO t1(docid, x) VALUES(-1, 'b c d e f g h i j k a');
500 INSERT INTO t1(docid, x) VALUES(0, 'c d e f g h i j k a b');
501 INSERT INTO t1(docid, x) VALUES(1, 'd e f g h i j k a b c');
502 INSERT INTO t1(docid, x) VALUES(2, 'e f g h i j k a b c d');
503 INSERT INTO t1(docid, x) VALUES(3, 'f g h i j k a b c d e');
504 INSERT INTO t1(docid, x) VALUES(4, 'a c e g i k');
505 INSERT INTO t1(docid, x) VALUES(5, 'a d g j');
506 INSERT INTO t1(docid, x) VALUES(6, 'c a b');
507 }
508
509 set limit [fts3_make_deferrable t1 c]
510
511 do_fts3query_test 3.$tn.2.1 t1 {a OR c}
512
513 ifcapable fts4_deferred {
514 do_test 3.$tn.3 { fts3_zero_long_segments t1 $limit } {1}
515 }
516
517 foreach {tn2 expr def} {
518 1 {a NEAR c} {}
519 2 {a AND c} c
520 3 {"a c"} c
521 4 {"c a"} c
522 5 {"a c" NEAR/1 g} {}
523 6 {"a c" NEAR/0 g} {}
524 } {
525 do_fts3query_test 3.$tn.4.$tn2 -deferred $def t1 $expr
526 }
527 }
528
529 #--------------------------------------------------------------------------
530 #
531 foreach {tn create} {
532 1 "fts4(x, y)"
533 2 "fts4(x, y, order=DESC)"
534 3 "fts4(x, y, order=DESC, prefix=2)"
535 } {
536
537 execsql [subst {
538 DROP TABLE t1;
539 CREATE VIRTUAL TABLE t1 USING $create;
540 INSERT INTO t1 VALUES('one two five four five', '');
541 INSERT INTO t1 VALUES('', 'one two five four five');
542 INSERT INTO t1 VALUES('one two', 'five four five');
543 }]
544
545 do_fts3query_test 4.$tn.1.1 t1 {one AND five}
546 do_fts3query_test 4.$tn.1.2 t1 {one NEAR five}
547 do_fts3query_test 4.$tn.1.3 t1 {one NEAR/1 five}
548 do_fts3query_test 4.$tn.1.4 t1 {one NEAR/2 five}
549 do_fts3query_test 4.$tn.1.5 t1 {one NEAR/3 five}
550
551 do_test 4.$tn.2 {
552 set limit [fts3_make_deferrable t1 five]
553 execsql { INSERT INTO t1(t1) VALUES('optimize') }
554 ifcapable fts4_deferred {
555 expr {[fts3_zero_long_segments t1 $limit]>0}
556 } else {
557 expr 1
558 }
559 } {1}
560
561 do_fts3query_test 4.$tn.3.1 -deferred five t1 {one AND five}
562 do_fts3query_test 4.$tn.3.2 -deferred five t1 {one NEAR five}
563 do_fts3query_test 4.$tn.3.3 -deferred five t1 {one NEAR/1 five}
564 do_fts3query_test 4.$tn.3.4 -deferred five t1 {one NEAR/2 five}
565
566 do_fts3query_test 4.$tn.3.5 -deferred five t1 {one NEAR/3 five}
567
568 do_fts3query_test 4.$tn.4.1 -deferred fi* t1 {on* AND fi*}
569 do_fts3query_test 4.$tn.4.2 -deferred fi* t1 {on* NEAR fi*}
570 do_fts3query_test 4.$tn.4.3 -deferred fi* t1 {on* NEAR/1 fi*}
571 do_fts3query_test 4.$tn.4.4 -deferred fi* t1 {on* NEAR/2 fi*}
572 do_fts3query_test 4.$tn.4.5 -deferred fi* t1 {on* NEAR/3 fi*}
573
574 ifcapable fts4_deferred {
575 db eval {UPDATE t1_stat SET value=x'' WHERE id=0}
576 do_catchsql_test 4.$tn.4.6 {
577 SELECT docid FROM t1 WHERE t1 MATCH 'on* NEAR/3 fi*'
578 } {1 {database disk image is malformed}}
579 }
580 }
581
582 #--------------------------------------------------------------------------
583 # The following test cases - fts3auto-5.* - focus on using prefix indexes.
584 #
585 set chunkconfig [fts3_configure_incr_load 1 1]
586 foreach {tn create pending} {
587 1 "fts4(a, b)" 1
588 2 "fts4(a, b, order=ASC, prefix=1)" 1
589 3 "fts4(a, b, order=ASC, prefix=\"1,3\")" 0
590 4 "fts4(a, b, order=DESC, prefix=\"2,4\")" 0
591 5 "fts4(a, b, order=DESC, prefix=\"1\")" 0
592 6 "fts4(a, b, order=ASC, prefix=\"1,3\")" 0
593 } {
594
595 execsql [subst {
596 DROP TABLE IF EXISTS t1;
597 CREATE VIRTUAL TABLE t1 USING $create;
598 }]
599
600 if {$pending} {execsql BEGIN}
601
602 foreach {a b} {
603 "the song of songs which is solomons"
604 "let him kiss me with the kisses of his mouth for thy love is better than wine"
605 "because of the savour of thy good ointments thy name is as ointment poured forth therefore do the virgins love thee"
606 "draw me we will run after thee the king hath brought me into his chambers we will be glad and rejoice in thee we will remember thy love more than wine the upright love thee"
607 "i am black but comely o ye daughters of jerusalem as the tents of kedar as the curtains of solomon"
608 "look not upon me because i am black because the sun hath looked upon me my mothers children were angry with me they made me the keeper of the vineyards but mine own vineyard have i not kept"
609 "tell me o thou whom my soul loveth where thou feedest where thou makest thy flock to rest at noon for why should i be as one that turneth aside by the flocks of thy companions?"
610 "if thou know not o thou fairest among women go thy way forth by the footsteps of the flock and feed thy kids beside the shepherds tents"
611 "i have compared thee o my love to a company of horses in pharaohs chariots"
612 "thy cheeks are comely with rows of jewels thy neck with chains of gold"
613 "we will make thee borders of gold with studs of silver"
614 "while the king sitteth at his table my spikenard sendeth forth the smell thereof"
615 "a bundle of myrrh is my wellbeloved unto me he shall lie all night betwixt my breasts"
616 "my beloved is unto me as a cluster of camphire in the vineyards of en gedi"
617 "behold thou art fair my love behold thou art fair thou hast doves eyes"
618 "behold thou art fair my beloved yea pleasant also our bed is green"
619 "the beams of our house are cedar and our rafters of fir"
620 } {
621 execsql {INSERT INTO t1(a, b) VALUES($a, $b)}
622 }
623
624
625 do_fts3query_test 5.$tn.1.1 t1 {s*}
626 do_fts3query_test 5.$tn.1.2 t1 {so*}
627 do_fts3query_test 5.$tn.1.3 t1 {"s* o*"}
628 do_fts3query_test 5.$tn.1.4 t1 {b* NEAR/3 a*}
629 do_fts3query_test 5.$tn.1.5 t1 {a*}
630 do_fts3query_test 5.$tn.1.6 t1 {th* NEAR/5 a* NEAR/5 w*}
631 do_fts3query_test 5.$tn.1.7 t1 {"b* th* art* fair*"}
632
633 if {$pending} {execsql COMMIT}
634 }
635 eval fts3_configure_incr_load $chunkconfig
636
637 foreach {tn pending create} {
638 1 0 "fts4(a, b, c, d)"
639 2 1 "fts4(a, b, c, d)"
640 3 0 "fts4(a, b, c, d, order=DESC)"
641 4 1 "fts4(a, b, c, d, order=DESC)"
642 } {
643 execsql [subst {
644 DROP TABLE IF EXISTS t1;
645 CREATE VIRTUAL TABLE t1 USING $create;
646 }]
647
648
649 if {$pending} { execsql BEGIN }
650
651 foreach {a b c d} {
652 "A B C" "D E F" "G H I" "J K L"
653 "B C D" "E F G" "H I J" "K L A"
654 "C D E" "F G H" "I J K" "L A B"
655 "D E F" "G H I" "J K L" "A B C"
656 "E F G" "H I J" "K L A" "B C D"
657 "F G H" "I J K" "L A B" "C D E"
658 } {
659 execsql { INSERT INTO t1 VALUES($a, $b, $c, $d) }
660 }
661
662 do_fts3query_test 6.$tn.1 t1 {b:G}
663 do_fts3query_test 6.$tn.2 t1 {b:G AND c:I}
664 do_fts3query_test 6.$tn.3 t1 {b:G NEAR c:I}
665 do_fts3query_test 6.$tn.4 t1 {a:C OR b:G OR c:K OR d:C}
666
667 do_fts3query_test 6.$tn.5 t1 {a:G OR b:G}
668
669 catchsql { COMMIT }
670 }
671
672 foreach {tn create} {
673 1 "fts4(x)"
674 2 "fts4(x, order=DESC)"
675 } {
676 execsql [subst {
677 DROP TABLE IF EXISTS t1;
678 CREATE VIRTUAL TABLE t1 USING $create;
679 }]
680
681 foreach {x} {
682 "F E N O T K X V A X I E X A P G Q V H U"
683 "R V A E T C V Q N I E L O N U G J K L U"
684 "U Y I G W M V F J L X I D C H F P J Q B"
685 "S G D Z X R P G S S Y B K A S G A I L L"
686 "L S I C H T Z S R Q P R N K J X L F M J"
687 "C C C D P X B Z C M A D A C X S B T X V"
688 "W Y J M D R G V R K B X S A W R I T N C"
689 "P K L W T M S P O Y Y V V O E H Q A I R"
690 "C D Y I C Z F H J C O Y A Q F L S B D K"
691 "P G S C Y C Y V I M B D S Z D D Y W I E"
692 "Z K Z U E E S F Y X T U A L W O U J C Q"
693 "P A T Z S W L P L Q V Y Y I P W U X S S"
694 "I U I H U O F Z F R H R F T N D X A G M"
695 "N A B M S H K X S O Y D T X S B R Y H Z"
696 "L U D A S K I L S V Z J P U B E B Y H M"
697 } {
698 execsql { INSERT INTO t1 VALUES($x) }
699 }
700
701 # Add extra documents to the database such that token "B" will be considered
702 # deferrable if considering the other tokens means that 2 or fewer documents
703 # will be loaded into memory.
704 #
705 fts3_make_deferrable t1 B 2
706
707 # B is not deferred in either of the first two tests below, since filtering
708 # on "M" or "D" returns 10 documents or so. But filtering on "M * D" only
709 # returns 2, so B is deferred in this case.
710 #
711 do_fts3query_test 7.$tn.1 t1 {"M B"}
712 do_fts3query_test 7.$tn.2 t1 {"B D"}
713 do_fts3query_test 7.$tn.3 -deferred B t1 {"M B D"}
714 }
715
716 set sqlite_fts3_enable_parentheses $sfep
717 finish_test