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
|
NAME
Text::Query - Query processing framework
SYNOPSIS
use Text::Query;
# Constructor
$query = Text::Query->new([QSTRING] [OPTIONS]);
# Methods
$query->prepare(QSTRING [OPTIONS]);
$query->match([TARGET]);
$query->matchscalar([TARGET]);
DESCRIPTION
This module provides an object that matches a data source
against a query expression.
Query expressions are compiled into an internal form when a new
object is created or the `prepare' method is called; they are
not recompiled on each match.
The class provided by this module uses four packages to process
the query. The query parser parses the question and calls a
query expression builder (internal form of the question). The
optimizer is then called to reduce the complexity of the
expression. The solver applies the expression on a data source.
The following parsers are provided:
Text::Query::ParseAdvanced
Text::Query::ParseSimple
The following builders are provided:
Text::Query::BuildAdvancedString
Text::Query::BuildSimpleString
The following solver is provided:
Text::Query::SolveSimpleString
Text::Query::SolveAdvancedString
EXAMPLES
use Text::Query;
my $q=new Text::Query('hello and world',
-parse => 'Text::Query::ParseAdvanced',
-solve => 'Text::Query::SolveAdvancedString',
-build => 'Text::Query::BuildAdvancedString');
die "bad query expression" if not defined $q;
print if $q->match;
...
$q->prepare('goodbye or adios or ta ta',
-litspace => 1,
-case => 1);
#requires single space between the two ta's
if($q->match($line)) {
#doesn't match "Goodbye"
...
$q->prepare('"and" or "or"');
#quoting operators for literal match
...
$q->prepare('\\bintegrate\\b', -regexp => 1);
#won't match "disintegrated"
CONSTRUCTOR
new ([QSTRING] [OPTIONS])
This is the constructor for a new Text::Query object. If a
`QSTRING' is given it will be compiled to internal form.
`OPTIONS' are passed in a hash like fashion, using key and
value pairs. Possible options are:
-parse - Package name of the parser. Default is
Text::Query::ParseSimple.
-build - Package name of the builder. Default is
Text::Query::Build.
-optimize - Package name of the optimizer. Default is
Text::Query::Optimize.
-solve - Package name of the solver. Default is
Text::Query::Solve.
-mode - Name of predefined group of packages to use. Options
are currently `simple_text' and `advanced_text'.
These options are handled by the `configure' method.
All other options are passed to the parser `prepare'
function. See the corresponding manual pages for a
description.
If `QSTRING' is undefined, the prepare function is not
called.
The constructor will croak if a `QSTRING' was supplied and
had illegal syntax.
METHODS
configure ([OPTIONS])
Set the `parse', `build', `optimize' or `solve' packages.
See the `CONSTRUCTOR' description for explanations.
prepare (QSTRING [OPTIONS])
Compiles the query expression in `QSTRING' to internal form
and sets any options (same as in the constructor). `prepare'
may be used to change the query expression and options for
an existing query object. If `OPTIONS' are omitted, any
options set by a previous call to `prepare' are persistent.
The optimizer (-optimize) is called with the result of the
parser (-parse). The parser uses the builder (-build) to
construct the internal form.
This method returns a reference to the query object if the
syntax of the expression was legal, or croak if not.
match ([TARGET])
Calls the match method of the solver (-solve).
matchscalar ([TARGET])
Calls the matchscalar method of the solver (-solve).
SEE ALSO
Text::Query::ParseAdvanced(3), Text::Query::ParseSimple(3),
Text::Query::BuildSimpleString(3),
Text::Query::BuildAdvanedString(3),
Text::Query::SolveSimpleString(3),
Text::Query::SolveAdvancedString(3),
Text::Query::Build(3), Text::Query::Parse(3),
Text::Query::Solve(3), Text::Query::Optimize(3)
AUTHORS
Eric Bohlman (ebohlman@netcom.com)
Loic Dachary (loic@senga.org)
|
