167 lines
4.4 KiB
Plaintext
167 lines
4.4 KiB
Plaintext
# 2009 January 1
|
|
#
|
|
# The author disclaims copyright to this source code. In place of
|
|
# a legal notice, here is a blessing:
|
|
#
|
|
# May you do good and not evil.
|
|
# May you find forgiveness for yourself and forgive others.
|
|
# May you share freely, never taking more than you give.
|
|
#
|
|
#*************************************************************************
|
|
# This file implements regression tests for SQLite library. The
|
|
# focus of this script is testing the FTS3 module syntax parser.
|
|
#
|
|
# $Id: fts3expr2.test,v 1.2 2009/06/05 17:09:12 drh Exp $
|
|
#
|
|
|
|
set testdir [file dirname $argv0]
|
|
source $testdir/tester.tcl
|
|
|
|
# If SQLITE_ENABLE_FTS3 is defined, omit this file.
|
|
ifcapable !fts3 {
|
|
finish_test
|
|
return
|
|
}
|
|
|
|
# Test overview:
|
|
#
|
|
# The tests in this file are pseudo-randomly generated. They test
|
|
# the fts3 match expression parser via the test interface
|
|
# SQL function "fts3_exprtest" (see comments in fts3_expr.c).
|
|
#
|
|
# Each test case works as follows:
|
|
#
|
|
# 1. A random expression tree is generated using proc [random_expr_tree].
|
|
# 2. The expression tree is converted to the text of an equivalent
|
|
# fts3 expression using proc [tree_to_expr].
|
|
# 3. The test SQL function "fts3_exprtest" is used to parse the
|
|
# expression text generated in step (2), returning a parsed expression
|
|
# tree.
|
|
# 4. Test that the tree returned in step (3) matches that generated in
|
|
# step (1).
|
|
#
|
|
# In step (2), 4 different fts3 expressions are created from each
|
|
# expression tree by varying the following boolean properties:
|
|
#
|
|
# * Whether or not superflous parenthesis are included. i.e. if
|
|
# "a OR b AND (c OR d)" or "a OR (b AND (c OR d))" is generated.
|
|
#
|
|
# * Whether or not explict AND operators are used. i.e. if
|
|
# "a OR b AND c" or "a OR b c" is generated.
|
|
#
|
|
|
|
set sqlite_fts3_enable_parentheses 1
|
|
|
|
proc strip_phrase_data {L} {
|
|
if {[lindex $L 0] eq "PHRASE"} {
|
|
return [list P [lrange $L 3 end]]
|
|
}
|
|
return [list \
|
|
[lindex $L 0] \
|
|
[strip_phrase_data [lindex $L 1]] \
|
|
[strip_phrase_data [lindex $L 2]] \
|
|
]
|
|
}
|
|
proc test_fts3expr2 {expr} {
|
|
strip_phrase_data [
|
|
db one {SELECT fts3_exprtest('simple', $expr, 'a', 'b', 'c')}
|
|
]
|
|
}
|
|
|
|
proc rnd {nMax} { expr {int(rand()*$nMax)} }
|
|
|
|
proc random_phrase {} {
|
|
set phrases [list one two three four "one two" "three four"]
|
|
list P [lindex $phrases [rnd [llength $phrases]]]
|
|
}
|
|
|
|
# Generate and return a pseudo-random expression tree. Using the same
|
|
# format returned by the [test_fts3expr2] proc.
|
|
#
|
|
proc random_expr_tree {iHeight} {
|
|
if {$iHeight==0 || [rnd 3]==0} {
|
|
return [random_phrase]
|
|
}
|
|
|
|
set operators [list NEAR NOT AND OR]
|
|
set op [lindex $operators [rnd 4]]
|
|
|
|
if {$op eq "NEAR"} {
|
|
set iDistance [rnd 15]
|
|
return [list $op/$iDistance [random_phrase] [random_phrase]]
|
|
}
|
|
|
|
set iNH [expr {$iHeight - 1}]
|
|
return [list $op [random_expr_tree $iNH] [random_expr_tree $iNH]]
|
|
}
|
|
|
|
# Given an expression tree, generate a corresponding expression.
|
|
#
|
|
proc tree_to_expr {tree all_brackets implicit_and} {
|
|
set prec(NOT) 2
|
|
set prec(AND) 3
|
|
set prec() 3
|
|
set prec(OR) 4
|
|
|
|
set op [lindex $tree 0]
|
|
|
|
if {$op eq "P"} {
|
|
set phrase [lindex $tree 1]
|
|
if {[llength $phrase]>1} {
|
|
return "\"$phrase\""
|
|
} else {
|
|
return $phrase
|
|
}
|
|
}
|
|
|
|
if {$op eq "NEAR/10"} {
|
|
set op "NEAR"
|
|
}
|
|
if {$op eq "AND" && $implicit_and} {
|
|
set op ""
|
|
}
|
|
|
|
set lhs [lindex $tree 1]
|
|
set rhs [lindex $tree 2]
|
|
set zLeft [tree_to_expr $lhs $all_brackets $implicit_and]
|
|
set zRight [tree_to_expr $rhs $all_brackets $implicit_and]
|
|
|
|
set iPrec 5
|
|
set iLeftPrec 0
|
|
set iRightPrec 0
|
|
|
|
catch {set iPrec $prec($op)}
|
|
catch {set iLeftPrec $prec([lindex $lhs 0])}
|
|
catch {set iRightPrec $prec([lindex $rhs 0])}
|
|
|
|
if {$iLeftPrec > $iPrec || $all_brackets} {
|
|
set zLeft "($zLeft)"
|
|
}
|
|
if {$iRightPrec >= $iPrec || $all_brackets} {
|
|
set zRight "($zRight)"
|
|
}
|
|
|
|
return "$zLeft $op $zRight"
|
|
}
|
|
|
|
proc do_exprparse_test {name expr tree} {
|
|
uplevel do_test $name [list "test_fts3expr2 {$expr}"] [list $tree]
|
|
}
|
|
|
|
for {set iTest 1} {$iTest<500} {incr iTest} {
|
|
set t [random_expr_tree 4]
|
|
|
|
set e1 [tree_to_expr $t 0 0]
|
|
set e2 [tree_to_expr $t 0 1]
|
|
set e3 [tree_to_expr $t 1 0]
|
|
set e4 [tree_to_expr $t 1 1]
|
|
|
|
do_exprparse_test fts3expr2-$iTest.1 $e1 $t
|
|
do_exprparse_test fts3expr2-$iTest.2 $e2 $t
|
|
do_exprparse_test fts3expr2-$iTest.3 $e3 $t
|
|
do_exprparse_test fts3expr2-$iTest.4 $e4 $t
|
|
}
|
|
|
|
set sqlite_fts3_enable_parentheses 0
|
|
finish_test
|