← Index
NYTProf Performance Profile   « block view • line view • sub view »
For /usr/share/koha/opac/cgi-bin/opac/opac-search.pl
  Run on Tue Oct 15 11:58:52 2013
Reported on Tue Oct 15 12:01:43 2013

Filename/usr/share/koha/lib/OpenILS/QueryParser.pm
StatementsExecuted 29 statements in 13.7ms
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
11145µs96µsOpenILS::QueryParser::_util::::BEGIN@1311 OpenILS::QueryParser::_util::BEGIN@1311
11132µs128µsOpenILS::QueryParser::query_plan::node::::BEGIN@1830 OpenILS::QueryParser::query_plan::node::BEGIN@1830
11131µs40µsbase::::BEGIN@1 base::BEGIN@1
11124µs123µsOpenILS::QueryParser::Canonicalize::::BEGIN@1354 OpenILS::QueryParser::Canonicalize::BEGIN@1354
11121µs46µsbase::::BEGIN@2 base::BEGIN@2
11114µs270µsOpenILS::QueryParser::::BEGIN@5 OpenILS::QueryParser::BEGIN@5
11112µs12µsOpenILS::QueryParser::::modifiers OpenILS::QueryParser::modifiers
0000s0sOpenILS::QueryParser::Canonicalize::::_abstract_query2str_filter OpenILS::QueryParser::Canonicalize::_abstract_query2str_filter
0000s0sOpenILS::QueryParser::Canonicalize::::_abstract_query2str_modifier OpenILS::QueryParser::Canonicalize::_abstract_query2str_modifier
0000s0sOpenILS::QueryParser::Canonicalize::::_kid_list OpenILS::QueryParser::Canonicalize::_kid_list
0000s0sOpenILS::QueryParser::Canonicalize::::abstract_query2str_impl OpenILS::QueryParser::Canonicalize::abstract_query2str_impl
0000s0sOpenILS::QueryParser::_util::::compare_abstract_atoms OpenILS::QueryParser::_util::compare_abstract_atoms
0000s0sOpenILS::QueryParser::_util::::default_joiner OpenILS::QueryParser::_util::default_joiner
0000s0sOpenILS::QueryParser::_util::::fake_abstract_atom_from_phrase OpenILS::QueryParser::_util::fake_abstract_atom_from_phrase
0000s0sOpenILS::QueryParser::_util::::find_arrays_in_abstract OpenILS::QueryParser::_util::find_arrays_in_abstract
0000s0sOpenILS::QueryParser::_util::::is_joiner OpenILS::QueryParser::_util::is_joiner
0000s0sOpenILS::QueryParser::::add_facet_class OpenILS::QueryParser::add_facet_class
0000s0sOpenILS::QueryParser::::add_facet_field OpenILS::QueryParser::add_facet_field
0000s0sOpenILS::QueryParser::::add_filter_normalizer OpenILS::QueryParser::add_filter_normalizer
0000s0sOpenILS::QueryParser::::add_query_normalizer OpenILS::QueryParser::add_query_normalizer
0000s0sOpenILS::QueryParser::::add_search_class OpenILS::QueryParser::add_search_class
0000s0sOpenILS::QueryParser::::add_search_class_alias OpenILS::QueryParser::add_search_class_alias
0000s0sOpenILS::QueryParser::::add_search_field OpenILS::QueryParser::add_search_field
0000s0sOpenILS::QueryParser::::add_search_field_alias OpenILS::QueryParser::add_search_field_alias
0000s0sOpenILS::QueryParser::::add_search_filter OpenILS::QueryParser::add_search_filter
0000s0sOpenILS::QueryParser::::add_search_modifier OpenILS::QueryParser::add_search_modifier
0000s0sOpenILS::QueryParser::::allow_nested_modifiers OpenILS::QueryParser::allow_nested_modifiers
0000s0sOpenILS::QueryParser::::canonicalize OpenILS::QueryParser::canonicalize
0000s0sOpenILS::QueryParser::::core_limit OpenILS::QueryParser::core_limit
0000s0sOpenILS::QueryParser::::custom_data OpenILS::QueryParser::custom_data
0000s0sOpenILS::QueryParser::::debug OpenILS::QueryParser::debug
0000s0sOpenILS::QueryParser::::decompose OpenILS::QueryParser::decompose
0000s0sOpenILS::QueryParser::::default_search_class OpenILS::QueryParser::default_search_class
0000s0sOpenILS::QueryParser::::facet_class_count OpenILS::QueryParser::facet_class_count
0000s0sOpenILS::QueryParser::::facet_classes OpenILS::QueryParser::facet_classes
0000s0sOpenILS::QueryParser::::facet_fields OpenILS::QueryParser::facet_fields
0000s0sOpenILS::QueryParser::::filter_callbacks OpenILS::QueryParser::filter_callbacks
0000s0sOpenILS::QueryParser::::filter_count OpenILS::QueryParser::filter_count
0000s0sOpenILS::QueryParser::::filter_normalizers OpenILS::QueryParser::filter_normalizers
0000s0sOpenILS::QueryParser::::filters OpenILS::QueryParser::filters
0000s0sOpenILS::QueryParser::::find_class_index OpenILS::QueryParser::find_class_index
0000s0sOpenILS::QueryParser::::floating_plan OpenILS::QueryParser::floating_plan
0000s0sOpenILS::QueryParser::::modifier_count OpenILS::QueryParser::modifier_count
0000s0sOpenILS::QueryParser::::new OpenILS::QueryParser::new
0000s0sOpenILS::QueryParser::::new_plan OpenILS::QueryParser::new_plan
0000s0sOpenILS::QueryParser::::operator OpenILS::QueryParser::operator
0000s0sOpenILS::QueryParser::::operators OpenILS::QueryParser::operators
0000s0sOpenILS::QueryParser::::parse OpenILS::QueryParser::parse
0000s0sOpenILS::QueryParser::::parse_tree OpenILS::QueryParser::parse_tree
0000s0sOpenILS::QueryParser::::query OpenILS::QueryParser::query
0000s0sOpenILS::QueryParser::::query_normalizers OpenILS::QueryParser::query_normalizers
0000s0sOpenILS::QueryParser::query_plan::::QueryParser OpenILS::QueryParser::query_plan::QueryParser
0000s0sOpenILS::QueryParser::query_plan::::_merge_filters OpenILS::QueryParser::query_plan::_merge_filters
0000s0sOpenILS::QueryParser::query_plan::::add_facet OpenILS::QueryParser::query_plan::add_facet
0000s0sOpenILS::QueryParser::query_plan::::add_filter OpenILS::QueryParser::query_plan::add_filter
0000s0sOpenILS::QueryParser::query_plan::::add_modifier OpenILS::QueryParser::query_plan::add_modifier
0000s0sOpenILS::QueryParser::query_plan::::add_node OpenILS::QueryParser::query_plan::add_node
0000s0sOpenILS::QueryParser::query_plan::::classed_node OpenILS::QueryParser::query_plan::classed_node
0000s0sOpenILS::QueryParser::query_plan::::collapse_filters OpenILS::QueryParser::query_plan::collapse_filters
0000s0sOpenILS::QueryParser::query_plan::facet::::name OpenILS::QueryParser::query_plan::facet::name
0000s0sOpenILS::QueryParser::query_plan::facet::::negate OpenILS::QueryParser::query_plan::facet::negate
0000s0sOpenILS::QueryParser::query_plan::facet::::new OpenILS::QueryParser::query_plan::facet::new
0000s0sOpenILS::QueryParser::query_plan::facet::::plan OpenILS::QueryParser::query_plan::facet::plan
0000s0sOpenILS::QueryParser::query_plan::facet::::to_abstract_query OpenILS::QueryParser::query_plan::facet::to_abstract_query
0000s0sOpenILS::QueryParser::query_plan::facet::::values OpenILS::QueryParser::query_plan::facet::values
0000s0sOpenILS::QueryParser::query_plan::::facets OpenILS::QueryParser::query_plan::facets
0000s0sOpenILS::QueryParser::query_plan::filter::::args OpenILS::QueryParser::query_plan::filter::args
0000s0sOpenILS::QueryParser::query_plan::filter::::name OpenILS::QueryParser::query_plan::filter::name
0000s0sOpenILS::QueryParser::query_plan::filter::::negate OpenILS::QueryParser::query_plan::filter::negate
0000s0sOpenILS::QueryParser::query_plan::filter::::new OpenILS::QueryParser::query_plan::filter::new
0000s0sOpenILS::QueryParser::query_plan::filter::::plan OpenILS::QueryParser::query_plan::filter::plan
0000s0sOpenILS::QueryParser::query_plan::filter::::to_abstract_query OpenILS::QueryParser::query_plan::filter::to_abstract_query
0000s0sOpenILS::QueryParser::query_plan::::filters OpenILS::QueryParser::query_plan::filters
0000s0sOpenILS::QueryParser::query_plan::::find_filter OpenILS::QueryParser::query_plan::find_filter
0000s0sOpenILS::QueryParser::query_plan::::find_modifier OpenILS::QueryParser::query_plan::find_modifier
0000s0sOpenILS::QueryParser::query_plan::::floating OpenILS::QueryParser::query_plan::floating
0000s0sOpenILS::QueryParser::query_plan::::joiner OpenILS::QueryParser::query_plan::joiner
0000s0sOpenILS::QueryParser::query_plan::modifier::::name OpenILS::QueryParser::query_plan::modifier::name
0000s0sOpenILS::QueryParser::query_plan::modifier::::negate OpenILS::QueryParser::query_plan::modifier::negate
0000s0sOpenILS::QueryParser::query_plan::modifier::::new OpenILS::QueryParser::query_plan::modifier::new
0000s0sOpenILS::QueryParser::query_plan::modifier::::to_abstract_query OpenILS::QueryParser::query_plan::modifier::to_abstract_query
0000s0sOpenILS::QueryParser::query_plan::::modifiers OpenILS::QueryParser::query_plan::modifiers
0000s0sOpenILS::QueryParser::query_plan::::negate OpenILS::QueryParser::query_plan::negate
0000s0sOpenILS::QueryParser::query_plan::::new OpenILS::QueryParser::query_plan::new
0000s0sOpenILS::QueryParser::query_plan::::new_facet OpenILS::QueryParser::query_plan::new_facet
0000s0sOpenILS::QueryParser::query_plan::::new_filter OpenILS::QueryParser::query_plan::new_filter
0000s0sOpenILS::QueryParser::query_plan::::new_modifier OpenILS::QueryParser::query_plan::new_modifier
0000s0sOpenILS::QueryParser::query_plan::::new_node OpenILS::QueryParser::query_plan::new_node
0000s0sOpenILS::QueryParser::query_plan::node::::add_dummy_atom OpenILS::QueryParser::query_plan::node::add_dummy_atom
0000s0sOpenILS::QueryParser::query_plan::node::::add_fts_atom OpenILS::QueryParser::query_plan::node::add_fts_atom
0000s0sOpenILS::QueryParser::query_plan::node::::add_phrase OpenILS::QueryParser::query_plan::node::add_phrase
0000s0sOpenILS::QueryParser::query_plan::node::::alias OpenILS::QueryParser::query_plan::node::alias
0000s0sOpenILS::QueryParser::query_plan::node::::alias_fields OpenILS::QueryParser::query_plan::node::alias_fields
0000s0sOpenILS::QueryParser::query_plan::node::atom::::contentOpenILS::QueryParser::query_plan::node::atom::content
0000s0sOpenILS::QueryParser::query_plan::node::atom::::newOpenILS::QueryParser::query_plan::node::atom::new
0000s0sOpenILS::QueryParser::query_plan::node::atom::::nodeOpenILS::QueryParser::query_plan::node::atom::node
0000s0sOpenILS::QueryParser::query_plan::node::atom::::prefixOpenILS::QueryParser::query_plan::node::atom::prefix
0000s0sOpenILS::QueryParser::query_plan::node::atom::::suffixOpenILS::QueryParser::query_plan::node::atom::suffix
0000s0sOpenILS::QueryParser::query_plan::node::atom::::to_abstract_queryOpenILS::QueryParser::query_plan::node::atom::to_abstract_query
0000s0sOpenILS::QueryParser::query_plan::node::::classname OpenILS::QueryParser::query_plan::node::classname
0000s0sOpenILS::QueryParser::query_plan::node::::fields OpenILS::QueryParser::query_plan::node::fields
0000s0sOpenILS::QueryParser::query_plan::node::::negate OpenILS::QueryParser::query_plan::node::negate
0000s0sOpenILS::QueryParser::query_plan::node::::new OpenILS::QueryParser::query_plan::node::new
0000s0sOpenILS::QueryParser::query_plan::node::::new_atom OpenILS::QueryParser::query_plan::node::new_atom
0000s0sOpenILS::QueryParser::query_plan::node::::phrases OpenILS::QueryParser::query_plan::node::phrases
0000s0sOpenILS::QueryParser::query_plan::node::::plan OpenILS::QueryParser::query_plan::node::plan
0000s0sOpenILS::QueryParser::query_plan::node::::query_atoms OpenILS::QueryParser::query_plan::node::query_atoms
0000s0sOpenILS::QueryParser::query_plan::node::::replace_phrase_in_abstract_query OpenILS::QueryParser::query_plan::node::replace_phrase_in_abstract_query
0000s0sOpenILS::QueryParser::query_plan::node::::requested_class OpenILS::QueryParser::query_plan::node::requested_class
0000s0sOpenILS::QueryParser::query_plan::node::::to_abstract_query OpenILS::QueryParser::query_plan::node::to_abstract_query
0000s0sOpenILS::QueryParser::query_plan::::plan_level OpenILS::QueryParser::query_plan::plan_level
0000s0sOpenILS::QueryParser::query_plan::::query_nodes OpenILS::QueryParser::query_plan::query_nodes
0000s0sOpenILS::QueryParser::query_plan::::remove_last_node OpenILS::QueryParser::query_plan::remove_last_node
0000s0sOpenILS::QueryParser::query_plan::::to_abstract_query OpenILS::QueryParser::query_plan::to_abstract_query
0000s0sOpenILS::QueryParser::query_plan::::top_plan OpenILS::QueryParser::query_plan::top_plan
0000s0sOpenILS::QueryParser::::remove_facet_class OpenILS::QueryParser::remove_facet_class
0000s0sOpenILS::QueryParser::::remove_facet_field OpenILS::QueryParser::remove_facet_field
0000s0sOpenILS::QueryParser::::remove_search_class OpenILS::QueryParser::remove_search_class
0000s0sOpenILS::QueryParser::::remove_search_class_alias OpenILS::QueryParser::remove_search_class_alias
0000s0sOpenILS::QueryParser::::remove_search_field OpenILS::QueryParser::remove_search_field
0000s0sOpenILS::QueryParser::::remove_search_field_alias OpenILS::QueryParser::remove_search_field_alias
0000s0sOpenILS::QueryParser::::search_class_aliases OpenILS::QueryParser::search_class_aliases
0000s0sOpenILS::QueryParser::::search_class_count OpenILS::QueryParser::search_class_count
0000s0sOpenILS::QueryParser::::search_classes OpenILS::QueryParser::search_classes
0000s0sOpenILS::QueryParser::::search_field_aliases OpenILS::QueryParser::search_field_aliases
0000s0sOpenILS::QueryParser::::search_fields OpenILS::QueryParser::search_fields
0000s0sOpenILS::QueryParser::::superpage OpenILS::QueryParser::superpage
0000s0sOpenILS::QueryParser::::superpage_size OpenILS::QueryParser::superpage_size
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1344µs248µs
# spent 40µs (31+9) within base::BEGIN@1 which was called: # once (31µs+9µs) by base::import at line 1
use strict;
# spent 40µs making 1 call to base::BEGIN@1 # spent 9µs making 1 call to strict::import
2337µs271µs
# spent 46µs (21+25) within base::BEGIN@2 which was called: # once (21µs+25µs) by base::import at line 2
use warnings;
# spent 46µs making 1 call to base::BEGIN@2 # spent 25µs making 1 call to warnings::import
3
4package OpenILS::QueryParser;
537.65ms2525µs
# spent 270µs (14+255) within OpenILS::QueryParser::BEGIN@5 which was called: # once (14µs+255µs) by base::import at line 5
use JSON;
# spent 270µs making 1 call to OpenILS::QueryParser::BEGIN@5 # spent 255µs making 1 call to JSON::import
6
7=head1 NAME
8
- -
24# Note that the first key must match the name of the package.
25119µsour %parser_config = (
26 'OpenILS::QueryParser' => {
27 filters => [],
28 modifiers => [],
29 operators => {
30 'and' => '&&',
31 'or' => '||',
32 float_start => '{{',
33 float_end => '}}',
34 group_start => '(',
35 group_end => ')',
36 required => '+',
37 disallowed => '-',
38 modifier => '#',
39 negated => '!'
40 }
41 }
42);
43
44sub canonicalize {
45 my $self = shift;
46 return OpenILS::QueryParser::Canonicalize::abstract_query2str_impl(
47 $self->parse_tree->to_abstract_query(@_)
48 );
49}
50
51
52=head2 facet_class_count
53
- -
57sub facet_class_count {
58 my $self = shift;
59 return @{$self->facet_classes};
60}
61
62=head2 search_class_count
63
- -
67sub search_class_count {
68 my $self = shift;
69 return @{$self->search_classes};
70}
71
72=head2 filter_count
73
- -
77sub filter_count {
78 my $self = shift;
79 return @{$self->filters};
80}
81
82=head2 modifier_count
83
- -
87sub modifier_count {
88 my $self = shift;
89 return @{$self->modifiers};
90}
91
92=head2 custom_data
93
- -
97sub custom_data {
98 my $class = shift;
99 $class = ref($class) || $class;
100
101 $parser_config{$class}{custom_data} ||= {};
102 return $parser_config{$class}{custom_data};
103}
104
105=head2 operators
106
- -
112sub operators {
113 my $class = shift;
114 $class = ref($class) || $class;
115
116 $parser_config{$class}{operators} ||= {};
117 return $parser_config{$class}{operators};
118}
119
120sub allow_nested_modifiers {
121 my $class = shift;
122 my $v = shift;
123 $class = ref($class) || $class;
124
125 $parser_config{$class}{allow_nested_modifiers} = $v if (defined $v);
126 return $parser_config{$class}{allow_nested_modifiers};
127}
128
129=head2 filters
130
- -
136sub filters {
137 my $class = shift;
138 $class = ref($class) || $class;
139
140 $parser_config{$class}{filters} ||= [];
141 return $parser_config{$class}{filters};
142}
143
144=head2 filter_callbacks
145
- -
151sub filter_callbacks {
152 my $class = shift;
153 $class = ref($class) || $class;
154
155 $parser_config{$class}{filter_callbacks} ||= {};
156 return $parser_config{$class}{filter_callbacks};
157}
158
159=head2 modifiers
160
- -
166
# spent 12µs within OpenILS::QueryParser::modifiers which was called: # once (12µs+0s) by C4::Search::parseQuery at line 1224 of /usr/share/koha/lib/C4/Search.pm
sub modifiers {
167417µs my $class = shift;
168 $class = ref($class) || $class;
169
170 $parser_config{$class}{modifiers} ||= [];
171 return $parser_config{$class}{modifiers};
172}
173
174=head2 new
175
- -
181sub new {
182 my $class = shift;
183 $class = ref($class) || $class;
184
185 my %opts = @_;
186
187 my $self = bless {} => $class;
188
189 for my $o (keys %{OpenILS::QueryParser->operators}) {
190 $class->operator($o => OpenILS::QueryParser->operator($o)) unless ($class->operator($o));
191 }
192
193 for my $opt ( keys %opts) {
194 $self->$opt( $opts{$opt} ) if ($self->can($opt));
195 }
196
197 return $self;
198}
199
200=head2 new_plan
201
- -
207sub new_plan {
208 my $self = shift;
209 my $pkg = ref($self) || $self;
210 return do{$pkg.'::query_plan'}->new( QueryParser => $self, @_ );
211}
212
213=head2 add_search_filter
214
- -
221sub add_search_filter {
222 my $pkg = shift;
223 $pkg = ref($pkg) || $pkg;
224 my $filter = shift;
225 my $callback = shift;
226
227 return $filter if (grep { $_ eq $filter } @{$pkg->filters});
228 push @{$pkg->filters}, $filter;
229 $pkg->filter_callbacks->{$filter} = $callback if ($callback);
230 return $filter;
231}
232
233=head2 add_search_modifier
234
- -
240sub add_search_modifier {
241 my $pkg = shift;
242 $pkg = ref($pkg) || $pkg;
243 my $modifier = shift;
244
245 return $modifier if (grep { $_ eq $modifier } @{$pkg->modifiers});
246 push @{$pkg->modifiers}, $modifier;
247 return $modifier;
248}
249
250=head2 add_facet_class
251
- -
257sub add_facet_class {
258 my $pkg = shift;
259 $pkg = ref($pkg) || $pkg;
260 my $class = shift;
261
262 return $class if (grep { $_ eq $class } @{$pkg->facet_classes});
263
264 push @{$pkg->facet_classes}, $class;
265 $pkg->facet_fields->{$class} = [];
266
267 return $class;
268}
269
270=head2 add_search_class
271
- -
277sub add_search_class {
278 my $pkg = shift;
279 $pkg = ref($pkg) || $pkg;
280 my $class = shift;
281
282 return $class if (grep { $_ eq $class } @{$pkg->search_classes});
283
284 push @{$pkg->search_classes}, $class;
285 $pkg->search_fields->{$class} = [];
286 $pkg->default_search_class( $pkg->search_classes->[0] ) if (@{$pkg->search_classes} == 1);
287
288 return $class;
289}
290
291=head2 add_search_modifier
292
- -
318sub operator {
319 my $class = shift;
320 $class = ref($class) || $class;
321 my $opname = shift;
322 my $op = shift;
323
324 return unless ($opname);
325
326 $parser_config{$class}{operators} ||= {};
327 $parser_config{$class}{operators}{$opname} = $op if ($op);
328
329 return $parser_config{$class}{operators}{$opname};
330}
331
332=head2 facet_classes
333
- -
340sub facet_classes {
341 my $class = shift;
342 $class = ref($class) || $class;
343 my $classes = shift;
344
345 $parser_config{$class}{facet_classes} ||= [];
346 $parser_config{$class}{facet_classes} = $classes if (ref($classes) && @$classes);
347 return $parser_config{$class}{facet_classes};
348}
349
350=head2 search_classes
351
- -
358sub search_classes {
359 my $class = shift;
360 $class = ref($class) || $class;
361 my $classes = shift;
362
363 $parser_config{$class}{classes} ||= [];
364 $parser_config{$class}{classes} = $classes if (ref($classes) && @$classes);
365 return $parser_config{$class}{classes};
366}
367
368=head2 add_query_normalizer
369
- -
374sub add_query_normalizer {
375 my $pkg = shift;
376 $pkg = ref($pkg) || $pkg;
377 my $class = shift;
378 my $field = shift;
379 my $func = shift;
380 my $params = shift || [];
381
382 # do not add if function AND params are identical to existing member
383 return $func if (grep {
384 $_->{function} eq $func and
385 to_json($_->{params}) eq to_json($params)
386 } @{$pkg->query_normalizers->{$class}->{$field}});
387
388 push(@{$pkg->query_normalizers->{$class}->{$field}}, { function => $func, params => $params });
389
390 return $func;
391}
392
393=head2 query_normalizers
394
- -
401sub query_normalizers {
402 my $pkg = shift;
403 $pkg = ref($pkg) || $pkg;
404
405 my $class = shift;
406 my $field = shift;
407
408 $parser_config{$pkg}{normalizers} ||= {};
409 if ($class) {
410 if ($field) {
411 $parser_config{$pkg}{normalizers}{$class}{$field} ||= [];
412 return $parser_config{$pkg}{normalizers}{$class}{$field};
413 } else {
414 return $parser_config{$pkg}{normalizers}{$class};
415 }
416 }
417
418 return $parser_config{$pkg}{normalizers};
419}
420
421=head2 add_filter_normalizer
422
- -
428sub add_filter_normalizer {
429 my $pkg = shift;
430 $pkg = ref($pkg) || $pkg;
431 my $filter = shift;
432 my $func = shift;
433 my $params = shift || [];
434
435 return $func if (grep { $_ eq $func } @{$pkg->filter_normalizers->{$filter}});
436
437 push(@{$pkg->filter_normalizers->{$filter}}, { function => $func, params => $params });
438
439 return $func;
440}
441
442=head2 filter_normalizers
443
- -
449sub filter_normalizers {
450 my $pkg = shift;
451 $pkg = ref($pkg) || $pkg;
452
453 my $filter = shift;
454
455 $parser_config{$pkg}{filter_normalizers} ||= {};
456 if ($filter) {
457 $parser_config{$pkg}{filter_normalizers}{$filter} ||= [];
458 return $parser_config{$pkg}{filter_normalizers}{$filter};
459 }
460
461 return $parser_config{$pkg}{filter_normalizers};
462}
463
464=head2 default_search_class
465
- -
471sub default_search_class {
472 my $pkg = shift;
473 $pkg = ref($pkg) || $pkg;
474 my $class = shift;
475 $OpenILS::QueryParser::parser_config{$pkg}{default_class} = $pkg->add_search_class( $class ) if $class;
476
477 return $OpenILS::QueryParser::parser_config{$pkg}{default_class};
478}
479
480=head2 remove_facet_class
481
- -
487sub remove_facet_class {
488 my $pkg = shift;
489 $pkg = ref($pkg) || $pkg;
490 my $class = shift;
491
492 return $class if (!grep { $_ eq $class } @{$pkg->facet_classes});
493
494 $pkg->facet_classes( [ grep { $_ ne $class } @{$pkg->facet_classes} ] );
495 delete $OpenILS::QueryParser::parser_config{$pkg}{facet_fields}{$class};
496
497 return $class;
498}
499
500=head2 remove_search_class
501
- -
507sub remove_search_class {
508 my $pkg = shift;
509 $pkg = ref($pkg) || $pkg;
510 my $class = shift;
511
512 return $class if (!grep { $_ eq $class } @{$pkg->search_classes});
513
514 $pkg->search_classes( [ grep { $_ ne $class } @{$pkg->search_classes} ] );
515 delete $OpenILS::QueryParser::parser_config{$pkg}{fields}{$class};
516
517 return $class;
518}
519
520=head2 add_facet_field
521
- -
528sub add_facet_field {
529 my $pkg = shift;
530 $pkg = ref($pkg) || $pkg;
531 my $class = shift;
532 my $field = shift;
533
534 $pkg->add_facet_class( $class );
535
536 return { $class => $field } if (grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
537
538 push @{$pkg->facet_fields->{$class}}, $field;
539
540 return { $class => $field };
541}
542
543=head2 facet_fields
544
- -
550sub facet_fields {
551 my $class = shift;
552 $class = ref($class) || $class;
553
554 $parser_config{$class}{facet_fields} ||= {};
555 return $parser_config{$class}{facet_fields};
556}
557
558=head2 add_search_field
559
- -
566sub add_search_field {
567 my $pkg = shift;
568 $pkg = ref($pkg) || $pkg;
569 my $class = shift;
570 my $field = shift;
571
572 $pkg->add_search_class( $class );
573
574 return { $class => $field } if (grep { $_ eq $field } @{$pkg->search_fields->{$class}});
575
576 push @{$pkg->search_fields->{$class}}, $field;
577
578 return { $class => $field };
579}
580
581=head2 search_fields
582
- -
588sub search_fields {
589 my $class = shift;
590 $class = ref($class) || $class;
591
592 $parser_config{$class}{fields} ||= {};
593 return $parser_config{$class}{fields};
594}
595
596=head2 add_search_class_alias
597
- -
601sub add_search_class_alias {
602 my $pkg = shift;
603 $pkg = ref($pkg) || $pkg;
604 my $class = shift;
605 my $alias = shift;
606
607 $pkg->add_search_class( $class );
608
609 return { $class => $alias } if (grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
610
611 push @{$pkg->search_class_aliases->{$class}}, $alias;
612
613 return { $class => $alias };
614}
615
616=head2 search_class_aliases
617
- -
621sub search_class_aliases {
622 my $class = shift;
623 $class = ref($class) || $class;
624
625 $parser_config{$class}{class_map} ||= {};
626 return $parser_config{$class}{class_map};
627}
628
629=head2 add_search_field_alias
630
- -
634sub add_search_field_alias {
635 my $pkg = shift;
636 $pkg = ref($pkg) || $pkg;
637 my $class = shift;
638 my $field = shift;
639 my $alias = shift;
640
641 return { $class => { $field => $alias } } if (grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
642
643 push @{$pkg->search_field_aliases->{$class}{$field}}, $alias;
644
645 return { $class => { $field => $alias } };
646}
647
648=head2 search_field_aliases
649
- -
653sub search_field_aliases {
654 my $class = shift;
655 $class = ref($class) || $class;
656
657 $parser_config{$class}{field_alias_map} ||= {};
658 return $parser_config{$class}{field_alias_map};
659}
660
661=head2 remove_facet_field
662
- -
666sub remove_facet_field {
667 my $pkg = shift;
668 $pkg = ref($pkg) || $pkg;
669 my $class = shift;
670 my $field = shift;
671
672 return { $class => $field } if (!$pkg->facet_fields->{$class} || !grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
673
674 $pkg->facet_fields->{$class} = [ grep { $_ ne $field } @{$pkg->facet_fields->{$class}} ];
675
676 return { $class => $field };
677}
678
679=head2 remove_search_field
680
- -
684sub remove_search_field {
685 my $pkg = shift;
686 $pkg = ref($pkg) || $pkg;
687 my $class = shift;
688 my $field = shift;
689
690 return { $class => $field } if (!$pkg->search_fields->{$class} || !grep { $_ eq $field } @{$pkg->search_fields->{$class}});
691
692 $pkg->search_fields->{$class} = [ grep { $_ ne $field } @{$pkg->search_fields->{$class}} ];
693
694 return { $class => $field };
695}
696
697=head2 remove_search_field_alias
698
- -
702sub remove_search_field_alias {
703 my $pkg = shift;
704 $pkg = ref($pkg) || $pkg;
705 my $class = shift;
706 my $field = shift;
707 my $alias = shift;
708
709 return { $class => { $field => $alias } } if (!$pkg->search_field_aliases->{$class}{$field} || !grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
710
711 $pkg->search_field_aliases->{$class}{$field} = [ grep { $_ ne $alias } @{$pkg->search_field_aliases->{$class}{$field}} ];
712
713 return { $class => { $field => $alias } };
714}
715
716=head2 remove_search_class_alias
717
- -
721sub remove_search_class_alias {
722 my $pkg = shift;
723 $pkg = ref($pkg) || $pkg;
724 my $class = shift;
725 my $alias = shift;
726
727 return { $class => $alias } if (!$pkg->search_class_aliases->{$class} || !grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
728
729 $pkg->search_class_aliases->{$class} = [ grep { $_ ne $alias } @{$pkg->search_class_aliases->{$class}} ];
730
731 return { $class => $alias };
732}
733
734=head2 debug
735
- -
741sub debug {
742 my $self = shift;
743 my $q = shift;
744 $self->{_debug} = $q if (defined $q);
745 return $self->{_debug};
746}
747
748=head2 query
749
- -
755sub query {
756 my $self = shift;
757 my $q = shift;
758 $self->{_query} = " $q " if (defined $q);
759 return $self->{_query};
760}
761
762=head2 parse_tree
763
- -
769sub parse_tree {
770 my $self = shift;
771 my $q = shift;
772 $self->{_parse_tree} = $q if (defined $q);
773 return $self->{_parse_tree};
774}
775
776sub floating_plan {
777 my $self = shift;
778 my $q = shift;
779 $self->{_top} = $q if (defined $q);
780 return $self->{_top};
781}
782
783=head2 parse
784
- -
791sub parse {
792 my $self = shift;
793 my $pkg = ref($self) || $self;
794 warn " ** parse package is $pkg\n" if $self->debug;
795# $self->parse_tree(
796# $self->decompose(
797# $self->query( shift() )
798# )
799# );
800
801 undef $self->{_parse_tree};
802
803 $self->decompose( $self->query( shift() ) );
804
805 if ($self->floating_plan) {
806 $self->floating_plan->add_node( $self->parse_tree );
807 $self->parse_tree( $self->floating_plan );
808 }
809
810 $self->parse_tree->plan_level(0);
811
812 return $self;
813}
814
815=head2 decompose
816
- -
8241600nsour $last_class = '';
8251400nsour $last_type = '';
8261300nsour $floating = 0;
8271300nsour $fstart;
828
829sub decompose {
830 my $self = shift;
831 my $pkg = ref($self) || $self;
832
833
834 $_ = shift;
835 my $current_class = shift || $self->default_search_class;
836
837 my $recursing = shift || 0;
838 my $phrase_helper = shift || 0;
839
840 # Build the search class+field uber-regexp
841 my $search_class_re = '^\s*(';
842 my $first_class = 1;
843
844 warn ' 'x$recursing." ** decompose package is $pkg\n" if $self->debug;
845
846 my %seen_classes;
847 for my $class ( keys %{$pkg->search_field_aliases} ) {
848 warn ' 'x$recursing." *** ... Looking for search fields in $class\n" if $self->debug;
849
850 for my $field ( keys %{$pkg->search_field_aliases->{$class}} ) {
851 warn ' 'x$recursing." *** ... Looking for aliases of $field\n" if $self->debug;
852
853 for my $alias ( @{$pkg->search_field_aliases->{$class}{$field}} ) {
854 next unless ($alias);
855 my $aliasr = qr/$alias/;
856 s/(^|\s+)$aliasr\|/$1$class\|$field#$alias\|/g;
857 s/(^|\s+)$aliasr[:=]/$1$class\|$field#$alias:/g;
858 warn ' 'x$recursing." *** Rewriting: $alias ($aliasr) as $class\|$field\n" if $self->debug;
859 }
860 }
861
862 $search_class_re .= '|' unless ($first_class);
863 $first_class = 0;
864 $search_class_re .= $class . '(?:[|#][^:|]+)*';
865 $seen_classes{$class} = 1;
866 }
867
868 for my $class ( keys %{$pkg->search_class_aliases} ) {
869
870 for my $alias ( @{$pkg->search_class_aliases->{$class}} ) {
871 next unless ($alias);
872 my $aliasr = qr/$alias/;
873 s/(^|[^|])\b$aliasr\|/$1$class#$alias\|/g;
874 s/(^|[^|])\b$aliasr[:=]/$1$class#$alias:/g;
875 warn ' 'x$recursing." *** Rewriting: $alias ($aliasr) as $class\n" if $self->debug;
876 }
877
878 if (!$seen_classes{$class}) {
879 $search_class_re .= '|' unless ($first_class);
880 $first_class = 0;
881
882 $search_class_re .= $class . '(?:[|#][^:|]+)*';
883 $seen_classes{$class} = 1;
884 }
885 }
886 $search_class_re .= '):';
887
888 warn ' 'x$recursing." ** Rewritten query: $_\n" if $self->debug;
889 warn ' 'x$recursing." ** Search class RE: $search_class_re\n" if $self->debug;
890
891 my $required_op = $pkg->operator('required');
892 my $required_re = qr/\Q$required_op\E/;
893
894 my $disallowed_op = $pkg->operator('disallowed');
895 my $disallowed_re = qr/\Q$disallowed_op\E/;
896
897 my $negated_op = $pkg->operator('negated');
898 my $negated_re = qr/\Q$negated_op\E/;
899
900 my $and_op = $pkg->operator('and');
901 my $and_re = qr/^\s*\Q$and_op\E/;
902
903 my $or_op = $pkg->operator('or');
904 my $or_re = qr/^\s*\Q$or_op\E/;
905
906 my $group_start = $pkg->operator('group_start');
907 my $group_start_re = qr/^\s*($negated_re|$disallowed_re)?\Q$group_start\E/;
908
909 my $group_end = $pkg->operator('group_end');
910 my $group_end_re = qr/^\s*\Q$group_end\E/;
911
912 my $float_start = $pkg->operator('float_start');
913 my $float_start_re = qr/^\s*\Q$float_start\E/;
914
915 my $float_end = $pkg->operator('float_end');
916 my $float_end_re = qr/^\s*\Q$float_end\E/;
917
918 my $modifier_tag = $pkg->operator('modifier');
919 my $modifier_tag_re = qr/^\s*\Q$modifier_tag\E/;
920
921 # Group start/end normally are ( and ), but can be overridden.
922 # We thus include ( and ) specifically due to filters, as well as : for classes.
923 my $phrase_cleanup_re = qr/\s*(\Q$required_op\E|\Q$disallowed_op\E|\Q$and_op\E|\Q$or_op\E|\Q$group_start\E|\Q$group_end\E|\Q$float_start\E|\Q$float_end\E|\Q$modifier_tag\E|\Q$negated_op\E|:|\(|\))/;
924
925 # Build the filter and modifier uber-regexps
926 my $facet_re = '^\s*(-?)((?:' . join( '|', @{$pkg->facet_classes}) . ')(?:\|\w+)*)\[(.+?)\]';
927 warn ' 'x$recursing." ** Facet RE: $facet_re\n" if $self->debug;
928
929 my $filter_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . ')\(([^()]+)\)';
930 my $filter_as_class_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . '):\s*(\S+)';
931
932 my $modifier_re = '^\s*'.$modifier_tag_re.'(' . join( '|', @{$pkg->modifiers}) . ')\b';
933 my $modifier_as_class_re = '^\s*(' . join( '|', @{$pkg->modifiers}) . '):\s*(\S+)';
934
935 my $struct = shift || $self->new_plan( level => $recursing );
936 $self->parse_tree( $struct ) if (!$self->parse_tree);
937
938 my $remainder = '';
939
940 while (!$remainder) {
941 warn ' 'x$recursing."Start of the loop. last_type: $last_type, joiner: ".$struct->joiner.", struct: $struct\n" if $self->debug;
942 if ($last_type eq 'FEND' and $fstart and $fstart != $struct) { # fall back further
943 $remainder = $_;
944 last;
945 } elsif ($last_type eq 'FEND') {
946 $fstart = undef;
947 $last_type = '';
948 }
949
950 if (/^\s*$/) { # end of an explicit group
951 local $last_type = '';
952 last;
953 } elsif (/$float_end_re/) { # end of an explicit group
954 warn ' 'x$recursing."Encountered explicit float end, remainder: $'\n" if $self->debug;
955
956 $remainder = $';
957 $_ = '';
958
959 $floating = 0;
960 $last_type = 'FEND';
961 last;
962 } elsif (/$group_end_re/) { # end of an explicit group
963 warn ' 'x$recursing."Encountered explicit group end, remainder: $'\n" if $self->debug;
964
965 $remainder = $';
966 $_ = '';
967
968 local $last_type = '';
969 } elsif ($self->filter_count && /$filter_re/) { # found a filter
970 warn ' 'x$recursing."Encountered search filter: $1$2 set to $3\n" if $self->debug;
971
972 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
973 $_ = $';
974
975 my $filter = $2;
976 my $params = [ split '[,]+', $3 ];
977
978 if ($pkg->filter_callbacks->{$filter}) {
979 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
980 $_ = "$replacement $_" if ($replacement);
981 } else {
982 $struct->new_filter( $filter => $params, $negate );
983 }
984
985
986 local $last_type = '';
987 } elsif ($self->filter_count && /$filter_as_class_re/) { # found a filter
988 warn ' 'x$recursing."Encountered search filter: $1$2 set to $3\n" if $self->debug;
989
990 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
991 $_ = $';
992
993 my $filter = $2;
994 my $params = [ split '[,]+', $3 ];
995
996 if ($pkg->filter_callbacks->{$filter}) {
997 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
998 $_ = "$replacement $_" if ($replacement);
999 } else {
1000 $struct->new_filter( $filter => $params, $negate );
1001 }
1002
1003 local $last_type = '';
1004 } elsif ($self->modifier_count && /$modifier_re/) { # found a modifier
1005 warn ' 'x$recursing."Encountered search modifier: $1\n" if $self->debug;
1006
1007 $_ = $';
1008 if (!($struct->top_plan || $parser_config{$pkg}->{allow_nested_modifiers})) {
1009 warn ' 'x$recursing." Search modifiers only allowed at the top level of the query\n" if $self->debug;
1010 } else {
1011 $struct->new_modifier($1);
1012 }
1013
1014 local $last_type = '';
1015 } elsif ($self->modifier_count && /$modifier_as_class_re/) { # found a modifier
1016 warn ' 'x$recursing."Encountered search modifier: $1\n" if $self->debug;
1017
1018 my $mod = $1;
1019
1020 $_ = $';
1021 if (!($struct->top_plan || $parser_config{$pkg}->{allow_nested_modifiers})) {
1022 warn ' 'x$recursing." Search modifiers only allowed at the top level of the query\n" if $self->debug;
1023 } elsif ($2 =~ /^[ty1]/i) {
1024 $struct->new_modifier($mod);
1025 }
1026
1027 local $last_type = '';
1028 } elsif (/$float_start_re/) { # start of an explicit float
1029 warn ' 'x$recursing."Encountered explicit float start\n" if $self->debug;
1030 $floating = 1;
1031 $fstart = $struct;
1032
1033 $last_class = $current_class;
1034 $current_class = undef;
1035
1036 $self->floating_plan( $self->new_plan( floating => 1 ) ) if (!$self->floating_plan);
1037
1038 # pass the floating_plan struct to be modified by the float'ed chunk
1039 my ($floating_plan, $subremainder) = $self->new( debug => $self->debug )->decompose( $', undef, undef, undef, $self->floating_plan);
1040 $_ = $subremainder;
1041 warn ' 'x$recursing."Remainder after explicit float: $_\n" if $self->debug;
1042
1043 $current_class = $last_class;
1044
1045 $last_type = '';
1046 } elsif (/$group_start_re/) { # start of an explicit group
1047 warn ' 'x$recursing."Encountered explicit group start\n" if $self->debug;
1048 my $negate = $1;
1049 my ($substruct, $subremainder) = $self->decompose( $', $current_class, $recursing + 1 );
1050 $substruct->negate(1) if ($substruct && $negate);
1051 $struct->add_node( $substruct ) if ($substruct);
1052 $_ = $subremainder;
1053 warn ' 'x$recursing."Query remainder after bool group: $_\n" if $self->debug;
1054
1055 local $last_type = '';
1056
1057 } elsif (/$and_re/) { # ANDed expression
1058 $_ = $';
1059 warn ' 'x$recursing."Encountered AND\n" if $self->debug;
1060 do {warn ' 'x$recursing."!!! Already doing the bool dance for AND\n" if $self->debug; next} if ($last_type eq 'AND');
1061 do {warn ' 'x$recursing."!!! Already doing the bool dance for OR\n" if $self->debug; next} if ($last_type eq 'OR');
1062 local $last_type = 'AND';
1063
1064 warn ' 'x$recursing."Saving LHS, building RHS\n" if $self->debug;
1065 my $LHS = $struct;
1066 #my ($RHS, $subremainder) = $self->decompose( "$group_start $_ $group_end", $current_class, $recursing + 1 );
1067 my ($RHS, $subremainder) = $self->decompose( $_, $current_class, $recursing + 1 );
1068 $_ = $subremainder;
1069
1070 warn ' 'x$recursing."RHS built\n" if $self->debug;
1071 warn ' 'x$recursing."Post-AND remainder: $subremainder\n" if $self->debug;
1072
1073 my $wrapper = $self->new_plan( level => $recursing + 1 );
1074
1075 if ($LHS->floating) {
1076 $wrapper->{query} = $LHS->{query};
1077 my $outer_wrapper = $self->new_plan( level => $recursing + 1 );
1078 $outer_wrapper->add_node($_) for ($wrapper,$RHS);
1079 $LHS->{query} = [$outer_wrapper];
1080 $struct = $LHS;
1081 } else {
1082 $wrapper->add_node($_) for ($LHS, $RHS);
1083 $wrapper->plan_level($wrapper->plan_level); # reset levels all the way down
1084 $struct = $self->new_plan( level => $recursing );
1085 $struct->add_node($wrapper);
1086 }
1087
1088 $self->parse_tree( $struct ) if ($self->parse_tree == $LHS);
1089
1090 local $last_type = '';
1091 } elsif (/$or_re/) { # ORed expression
1092 $_ = $';
1093 warn ' 'x$recursing."Encountered OR\n" if $self->debug;
1094 do {warn ' 'x$recursing."!!! Already doing the bool dance for AND\n" if $self->debug; next} if ($last_type eq 'AND');
1095 do {warn ' 'x$recursing."!!! Already doing the bool dance for OR\n" if $self->debug; next} if ($last_type eq 'OR');
1096 local $last_type = 'OR';
1097
1098 warn ' 'x$recursing."Saving LHS, building RHS\n" if $self->debug;
1099 my $LHS = $struct;
1100 #my ($RHS, $subremainder) = $self->decompose( "$group_start $_ $group_end", $current_class, $recursing + 1 );
1101 my ($RHS, $subremainder) = $self->decompose( $_, $current_class, $recursing + 2 );
1102 $_ = $subremainder;
1103
1104 warn ' 'x$recursing."RHS built\n" if $self->debug;
1105 warn ' 'x$recursing."Post-OR remainder: $subremainder\n" if $self->debug;
1106
1107 my $wrapper = $self->new_plan( level => $recursing + 1, joiner => '|' );
1108
1109 if ($LHS->floating) {
1110 $wrapper->{query} = $LHS->{query};
1111 my $outer_wrapper = $self->new_plan( level => $recursing + 1, joiner => '|' );
1112 $outer_wrapper->add_node($_) for ($wrapper,$RHS);
1113 $LHS->{query} = [$outer_wrapper];
1114 $struct = $LHS;
1115 } else {
1116 $wrapper->add_node($_) for ($LHS, $RHS);
1117 $wrapper->plan_level($wrapper->plan_level); # reset levels all the way down
1118 $struct = $self->new_plan( level => $recursing );
1119 $struct->add_node($wrapper);
1120 }
1121
1122 $self->parse_tree( $struct ) if ($self->parse_tree == $LHS);
1123
1124 local $last_type = '';
1125 } elsif ($self->facet_class_count && /$facet_re/) { # changing current class
1126 warn ' 'x$recursing."Encountered facet: $1$2 => $3\n" if $self->debug;
1127
1128 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
1129 my $facet = $2;
1130 my $facet_value = [ split '\s*#\s*', $3 ];
1131 $struct->new_facet( $facet => $facet_value, $negate );
1132 $_ = $';
1133
1134 local $last_type = '';
1135 } elsif ($self->search_class_count && /$search_class_re/) { # changing current class
1136
1137 if ($last_type eq 'CLASS') {
1138 $struct->remove_last_node( $current_class );
1139 warn ' 'x$recursing."Encountered class change with no searches!\n" if $self->debug;
1140 }
1141
1142 warn ' 'x$recursing."Encountered class change: $1\n" if $self->debug;
1143
1144 $current_class = $struct->classed_node( $1 )->requested_class();
1145 $_ = $';
1146
1147 local $last_type = 'CLASS';
1148 } elsif (/^\s*($required_re|$disallowed_re|$negated_re)?"([^"]+)"/) { # phrase, always anded
1149 warn ' 'x$recursing.'Encountered' . ($1 ? " ['$1' modified]" : '') . " phrase: $2\n" if $self->debug;
1150
1151 my $req_ness = $1 || '';
1152 $req_ness = $disallowed_op if ($req_ness eq $negated_op);
1153 my $phrase = $2;
1154
1155 if (!$phrase_helper) {
1156 warn ' 'x$recursing."Recursing into decompose with the phrase as a subquery\n" if $self->debug;
1157 my $after = $';
1158 my ($substruct, $subremainder) = $self->decompose( qq/$req_ness"$phrase"/, $current_class, $recursing + 1, 1 );
1159 $struct->add_node( $substruct ) if ($substruct);
1160 $_ = $after;
1161 } else {
1162 warn ' 'x$recursing."Directly parsing the phrase subquery\n" if $self->debug;
1163 $struct->joiner( '&' );
1164
1165 my $class_node = $struct->classed_node($current_class);
1166
1167 if ($req_ness eq $disallowed_op) {
1168 $class_node->negate(1);
1169 }
1170 $class_node->add_phrase( $phrase );
1171
1172 # Save $' before we clean up $phrase
1173 my $temp_val = $';
1174
1175 # Cleanup the phrase to make it so that we don't parse things in it as anything other than atoms
1176 $phrase =~ s/$phrase_cleanup_re/ /g;
1177
1178 $_ = $temp_val;
1179
1180 }
1181
1182 local $last_type = '';
1183
1184 } elsif (/^\s*($required_re|$disallowed_re)([^${group_end}${float_end}\s"]+)/) { # convert require/disallow word to {un}phrase
1185 warn ' 'x$recursing."Encountered required atom (mini phrase), transforming for phrase parse: $1\n" if $self->debug;
1186
1187 $_ = $1 . '"' . $2 . '"' . $';
1188
1189 local $last_type = '';
1190 } elsif (/^\s*([^${group_end}${float_end}\s]+)/o) { # atom
1191 warn ' 'x$recursing."Encountered atom: $1\n" if $self->debug;
1192 warn ' 'x$recursing."Remainder: $'\n" if $self->debug;
1193
1194 my $atom = $1;
1195 my $after = $';
1196
1197 $_ = $after;
1198 local $last_type = '';
1199
1200 my $class_node = $struct->classed_node($current_class);
1201
1202 my $prefix = ($atom =~ s/^$negated_re//o) ? '!' : '';
1203 my $truncate = ($atom =~ s/\*$//o) ? '*' : '';
1204
1205 if ($atom ne '' and !grep { $atom =~ /^\Q$_\E+$/ } ('&','|')) { # throw away & and |, not allowed in tsquery, and not really useful anyway
1206# $class_node->add_phrase( $atom ) if ($atom =~ s/^$required_re//o);
1207
1208 $class_node->add_fts_atom( $atom, suffix => $truncate, prefix => $prefix, node => $class_node );
1209 $struct->joiner( '&' );
1210 }
1211
1212 local $last_type = '';
1213 }
1214
1215 last unless ($_);
1216
1217 }
1218
1219 $struct = undef if
1220 scalar(@{$struct->query_nodes}) == 0 &&
1221 scalar(@{$struct->filters}) == 0 &&
1222 !$struct->top_plan;
1223
1224 return $struct if !wantarray;
1225 return ($struct, $remainder);
1226}
1227
1228=head2 find_class_index
1229
- -
1233sub find_class_index {
1234 my $class = shift;
1235 my $query = shift;
1236
1237 my ($class_part, @field_parts) = split '\|', $class;
1238 $class_part ||= $class;
1239
1240 for my $idx ( 0 .. scalar(@$query) - 1 ) {
1241 next unless ref($$query[$idx]);
1242 return $idx if ( $$query[$idx]{requested_class} && $class eq $$query[$idx]{requested_class} );
1243 }
1244
1245 push(@$query, { classname => $class_part, (@field_parts ? (fields => \@field_parts) : ()), requested_class => $class, ftsquery => [], phrases => [] });
1246 return -1;
1247}
1248
1249=head2 core_limit
1250
- -
1256sub core_limit {
1257 my $self = shift;
1258 my $l = shift;
1259 $self->{core_limit} = $l if ($l);
1260 return $self->{core_limit};
1261}
1262
1263=head2 superpage
1264
- -
1270sub superpage {
1271 my $self = shift;
1272 my $l = shift;
1273 $self->{superpage} = $l if ($l);
1274 return $self->{superpage};
1275}
1276
1277=head2 superpage_size
1278
- -
1284sub superpage_size {
1285 my $self = shift;
1286 my $l = shift;
1287 $self->{superpage_size} = $l if ($l);
1288 return $self->{superpage_size};
1289}
1290
1291
1292#-------------------------------
1293package OpenILS::QueryParser::_util;
1294
1295# At this level, joiners are always & or |. This is not
1296# the external, configurable representation of joiners that
1297# defaults to # && and ||.
1298sub is_joiner {
1299 my $str = shift;
1300
1301 return (not ref $str and ($str eq '&' or $str eq '|'));
1302}
1303
1304sub default_joiner { '&' }
1305
1306# 0 for different, 1 for the same.
1307sub compare_abstract_atoms {
1308 my ($left, $right) = @_;
1309
1310 foreach (qw/prefix suffix content/) {
13113356µs2148µs
# spent 96µs (45+52) within OpenILS::QueryParser::_util::BEGIN@1311 which was called: # once (45µs+52µs) by base::import at line 1311
no warnings; # undef can stand in for '' here
# spent 96µs making 1 call to OpenILS::QueryParser::_util::BEGIN@1311 # spent 51µs making 1 call to warnings::unimport
1312 return 0 unless $left->{$_} eq $right->{$_};
1313 }
1314
1315 return 1;
1316}
1317
1318sub fake_abstract_atom_from_phrase {
1319 my $phrase = shift;
1320 my $neg = shift;
1321 my $qp_class = shift || 'OpenILS::QueryParser';
1322
1323 my $prefix = '"';
1324 if ($neg) {
1325 $prefix =
1326 $OpenILS::QueryParser::parser_config{$qp_class}{operators}{disallowed} .
1327 $prefix;
1328 }
1329
1330 return {
1331 "type" => "atom", "prefix" => $prefix, "suffix" => '"',
1332 "content" => $phrase
1333 }
1334}
1335
1336sub find_arrays_in_abstract {
1337 my ($hash) = @_;
1338
1339 my @arrays;
1340 foreach my $key (keys %$hash) {
1341 if (ref $hash->{$key} eq "ARRAY") {
1342 push @arrays, $hash->{$key};
1343 foreach (@{$hash->{$key}}) {
1344 push @arrays, find_arrays_in_abstract($_);
1345 }
1346 }
1347 }
1348
1349 return @arrays;
1350}
1351
1352#-------------------------------
1353package OpenILS::QueryParser::Canonicalize; # not OO
135433.22ms2223µs
# spent 123µs (24+100) within OpenILS::QueryParser::Canonicalize::BEGIN@1354 which was called: # once (24µs+100µs) by base::import at line 1354
use Data::Dumper;
# spent 123µs making 1 call to OpenILS::QueryParser::Canonicalize::BEGIN@1354 # spent 100µs making 1 call to Exporter::import
1355
1356sub _abstract_query2str_filter {
1357 my $f = shift;
1358 my $qp_class = shift || 'OpenILS::QueryParser';
1359 my $qpconfig = $OpenILS::QueryParser::parser_config{$qp_class};
1360
1361 return sprintf(
1362 '%s%s(%s)',
1363 $f->{negate} ? $qpconfig->{operators}{disallowed} : "",
1364 $f->{name},
1365 join(",", @{$f->{args}})
1366 );
1367}
1368
1369sub _abstract_query2str_modifier {
1370 my $f = shift;
1371 my $qp_class = shift || 'OpenILS::QueryParser';
1372 my $qpconfig = $OpenILS::QueryParser::parser_config{$qp_class};
1373
1374 return $qpconfig->{operators}{modifier} . $f;
1375}
1376
1377sub _kid_list {
1378 my $children = shift;
1379 my $op = (keys %$children)[0];
1380 return @{$$children{$op}};
1381}
1382
1383
1384# This should produce an equivalent query to the original, given an
1385# abstract_query.
1386sub abstract_query2str_impl {
1387 my $abstract_query = shift;
1388 my $depth = shift || 0;
1389
1390 my $qp_class ||= shift || 'OpenILS::QueryParser';
1391 my $force_qp_node = shift || 0;
1392 my $qpconfig = $OpenILS::QueryParser::parser_config{$qp_class};
1393
1394 my $fs = $qpconfig->{operators}{float_start};
1395 my $fe = $qpconfig->{operators}{float_end};
1396 my $gs = $qpconfig->{operators}{group_start};
1397 my $ge = $qpconfig->{operators}{group_end};
1398 my $and = $qpconfig->{operators}{and};
1399 my $or = $qpconfig->{operators}{or};
1400 my $ng = $qpconfig->{operators}{negated};
1401
1402 my $isnode = 0;
1403 my $negate = '';
1404 my $size = 0;
1405 my $q = "";
1406
1407 if (exists $abstract_query->{type}) {
1408 if ($abstract_query->{type} eq 'query_plan') {
1409 $q .= join(" ", map { _abstract_query2str_filter($_, $qp_class) } @{$abstract_query->{filters}}) if
1410 exists $abstract_query->{filters};
1411
1412 $q .= ($q ? ' ' : '') . join(" ", map { _abstract_query2str_modifier($_, $qp_class) } @{$abstract_query->{modifiers}}) if
1413 exists $abstract_query->{modifiers};
1414
1415 $size = _kid_list($abstract_query->{children});
1416 if ($abstract_query->{negate}) {
1417 $isnode = 1;
1418 $negate = $ng;
1419 }
1420 $isnode = 1 if ($size > 1 and ($force_qp_node or $depth));
1421 #warn "size: $size, depth: $depth, isnode: $isnode, AQ: ".Dumper($abstract_query);
1422 } elsif ($abstract_query->{type} eq 'node') {
1423 if ($abstract_query->{alias}) {
1424 $q .= ($q ? ' ' : '') . $abstract_query->{alias};
1425 $q .= "|$_" foreach @{$abstract_query->{alias_fields}};
1426 } else {
1427 $q .= ($q ? ' ' : '') . $abstract_query->{class};
1428 $q .= "|$_" foreach @{$abstract_query->{fields}};
1429 }
1430 $q .= ":";
1431 $isnode = 1;
1432 } elsif ($abstract_query->{type} eq 'atom') {
1433 my $prefix = $abstract_query->{prefix} || '';
1434 $prefix = $qpconfig->{operators}{negated} if $prefix eq '!';
1435 $q .= ($q ? ' ' : '') . $prefix .
1436 ($abstract_query->{content} || '') .
1437 ($abstract_query->{suffix} || '');
1438 } elsif ($abstract_query->{type} eq 'facet') {
1439 # facet syntax [ # ] is hardcoded I guess?
1440 my $prefix = $abstract_query->{negate} ? $qpconfig->{operators}{disallowed} : '';
1441 $q .= ($q ? ' ' : '') . $prefix . $abstract_query->{name} . "[" .
1442 join(" # ", @{$abstract_query->{values}}) . "]";
1443 }
1444 }
1445
1446 my $next_depth = int($size > 1);
1447
1448 if (exists $abstract_query->{children}) {
1449
1450 my $op = (keys(%{$abstract_query->{children}}))[0];
1451
1452 if ($abstract_query->{floating}) { # always the top node!
1453 my $sub_node = pop @{$abstract_query->{children}{$op}};
1454
1455 $abstract_query->{floating} = 0;
1456 $q = $fs . " " . abstract_query2str_impl($abstract_query,0,$qp_class, 1) . $fe. " ";
1457
1458 $abstract_query = $sub_node;
1459 }
1460
1461 if ($abstract_query && exists $abstract_query->{children}) {
1462 $op = (keys(%{$abstract_query->{children}}))[0];
1463 $q .= ($q ? ' ' : '') . join(
1464 ($op eq '&' ? ' ' : " $or "),
1465 map {
1466 my $x = abstract_query2str_impl($_, $depth + $next_depth, $qp_class, $force_qp_node); $x =~ s/^\s+//; $x =~ s/\s+$//; $x;
1467 } @{$abstract_query->{children}{$op}}
1468 );
1469 }
1470 } elsif ($abstract_query->{'&'} or $abstract_query->{'|'}) {
1471 my $op = (keys(%{$abstract_query}))[0];
1472 $q .= ($q ? ' ' : '') . join(
1473 ($op eq '&' ? ' ' : " $or "),
1474 map {
1475 my $x = abstract_query2str_impl($_, $depth + $next_depth, $qp_class, $force_qp_node); $x =~ s/^\s+//; $x =~ s/\s+$//; $x;
1476 } @{$abstract_query->{$op}}
1477 );
1478 }
1479
1480 $q = "$gs$q$ge" if ($isnode);
1481 $q = $negate . $q if ($q);;
1482
1483 return $q;
1484}
1485
1486#-------------------------------
1487package OpenILS::QueryParser::query_plan;
1488
1489sub QueryParser {
1490 my $self = shift;
1491 return unless ref($self);
1492 return $self->{QueryParser};
1493}
1494
1495sub new {
1496 my $pkg = shift;
1497 $pkg = ref($pkg) || $pkg;
1498 my %args = (query => [], joiner => '&', @_);
1499
1500 return bless \%args => $pkg;
1501}
1502
1503sub new_node {
1504 my $self = shift;
1505 my $pkg = ref($self) || $self;
1506 my $node = do{$pkg.'::node'}->new( plan => $self, @_ );
1507 $self->add_node( $node );
1508 return $node;
1509}
1510
1511sub new_facet {
1512 my $self = shift;
1513 my $pkg = ref($self) || $self;
1514 my $name = shift;
1515 my $args = shift;
1516 my $negate = shift;
1517
1518 my $node = do{$pkg.'::facet'}->new( plan => $self, name => $name, 'values' => $args, negate => $negate );
1519 $self->add_node( $node );
1520
1521 return $node;
1522}
1523
1524sub new_filter {
1525 my $self = shift;
1526 my $pkg = ref($self) || $self;
1527 my $name = shift;
1528 my $args = shift;
1529 my $negate = shift;
1530
1531 my $node = do{$pkg.'::filter'}->new( plan => $self, name => $name, args => $args, negate => $negate );
1532 $self->add_filter( $node );
1533
1534 return $node;
1535}
1536
1537
1538sub _merge_filters {
1539 my $left_filter = shift;
1540 my $right_filter = shift;
1541 my $join = shift;
1542
1543 return unless $left_filter or $right_filter;
1544 return $right_filter unless $left_filter;
1545 return $left_filter unless $right_filter;
1546
1547 my $args = $left_filter->{args} || [];
1548
1549 if ($join eq '|') {
1550 push(@$args, @{$right_filter->{args}});
1551
1552 } else {
1553 # find the intersect values
1554 my %new_vals;
1555 map { $new_vals{$_} = 1 } @{$right_filter->{args} || []};
1556 $args = [ grep { $new_vals{$_} } @$args ];
1557 }
1558
1559 $left_filter->{args} = $args;
1560 return $left_filter;
1561}
1562
1563sub collapse_filters {
1564 my $self = shift;
1565 my $name = shift;
1566
1567 # start by merging any filters at this level.
1568 # like-level filters are always ORed together
1569
1570 my $cur_filter;
1571 my @cur_filters = grep {$_->name eq $name } @{ $self->filters };
1572 if (@cur_filters) {
1573 $cur_filter = shift @cur_filters;
1574 my $args = $cur_filter->{args} || [];
1575 $cur_filter = _merge_filters($cur_filter, $_, '|') for @cur_filters;
1576 }
1577
1578 # next gather the collapsed filters from sub-plans and
1579 # merge them with our own
1580
1581 my @subquery = @{$self->{query}};
1582
1583 while (@subquery) {
1584 my $blob = shift @subquery;
1585 shift @subquery; # joiner
1586 next unless $blob->isa('OpenILS::QueryParser::query_plan');
1587 my $sub_filter = $blob->collapse_filters($name);
1588 $cur_filter = _merge_filters($cur_filter, $sub_filter, $self->joiner);
1589 }
1590
1591 if ($self->QueryParser->debug) {
1592 my @args = ($cur_filter and $cur_filter->{args}) ? @{$cur_filter->{args}} : ();
1593 warn "collapse_filters($name) => [@args]\n";
1594 }
1595
1596 return $cur_filter;
1597}
1598
1599sub find_filter {
1600 my $self = shift;
1601 my $needle = shift;;
1602 return unless ($needle);
1603
1604 my $filter = $self->collapse_filters($needle);
1605
1606 warn "find_filter($needle) => " .
1607 (($filter and $filter->{args}) ? "@{$filter->{args}}" : '[]') . "\n"
1608 if $self->QueryParser->debug;
1609
1610 return $filter ? ($filter) : ();
1611}
1612
1613sub find_modifier {
1614 my $self = shift;
1615 my $needle = shift;;
1616 return unless ($needle);
1617 return grep { $_->name eq $needle } @{ $self->modifiers };
1618}
1619
1620sub new_modifier {
1621 my $self = shift;
1622 my $pkg = ref($self) || $self;
1623 my $name = shift;
1624
1625 my $node = do{$pkg.'::modifier'}->new( $name );
1626 $self->add_modifier( $node );
1627
1628 return $node;
1629}
1630
1631sub classed_node {
1632 my $self = shift;
1633 my $requested_class = shift;
1634
1635 my $node;
1636 for my $n (@{$self->{query}}) {
1637 next unless (ref($n) && $n->isa( 'OpenILS::QueryParser::query_plan::node' ));
1638 if ($n->requested_class eq $requested_class) {
1639 $node = $n;
1640 last;
1641 }
1642 }
1643
1644 if (!$node) {
1645 $node = $self->new_node;
1646 $node->requested_class( $requested_class );
1647 }
1648
1649 return $node;
1650}
1651
1652sub remove_last_node {
1653 my $self = shift;
1654 my $requested_class = shift;
1655
1656 my $old = pop(@{$self->query_nodes});
1657 pop(@{$self->query_nodes}) if (@{$self->query_nodes});
1658
1659 return $old;
1660}
1661
1662sub query_nodes {
1663 my $self = shift;
1664 return $self->{query};
1665}
1666
1667sub floating {
1668 my $self = shift;
1669 my $f = shift;
1670 $self->{floating} = $f if (defined $f);
1671 return $self->{floating};
1672}
1673
1674sub add_node {
1675 my $self = shift;
1676 my $node = shift;
1677
1678 $self->{query} ||= [];
1679 push(@{$self->{query}}, $self->joiner) if (@{$self->{query}});
1680 push(@{$self->{query}}, $node);
1681
1682 return $self;
1683}
1684
1685sub top_plan {
1686 my $self = shift;
1687
1688 return $self->{level} ? 0 : 1;
1689}
1690
1691sub plan_level {
1692 my $self = shift;
1693 my $level = shift;
1694
1695 if (defined $level) {
1696 $self->{level} = $level;
1697 for (@{$self->query_nodes}) {
1698 $_->plan_level($level + 1) if (ref and $_->isa('OpenILS::QueryParser::query_plan'));
1699 }
1700 }
1701
1702 return $self->{level};
1703}
1704
1705sub joiner {
1706 my $self = shift;
1707 my $joiner = shift;
1708
1709 $self->{joiner} = $joiner if ($joiner);
1710 return $self->{joiner};
1711}
1712
1713sub modifiers {
1714 my $self = shift;
1715 $self->{modifiers} ||= [];
1716 return $self->{modifiers};
1717}
1718
1719sub add_modifier {
1720 my $self = shift;
1721 my $modifier = shift;
1722
1723 $self->{modifiers} ||= [];
1724 $self->{modifiers} = [ grep {$_->name ne $modifier->name} @{$self->{modifiers}} ];
1725
1726 push(@{$self->{modifiers}}, $modifier);
1727
1728 return $self;
1729}
1730
1731sub facets {
1732 my $self = shift;
1733 $self->{facets} ||= [];
1734 return $self->{facets};
1735}
1736
1737sub add_facet {
1738 my $self = shift;
1739 my $facet = shift;
1740
1741 $self->{facets} ||= [];
1742 $self->{facets} = [ grep {$_->name ne $facet->name} @{$self->{facets}} ];
1743
1744 push(@{$self->{facets}}, $facet);
1745
1746 return $self;
1747}
1748
1749sub filters {
1750 my $self = shift;
1751 $self->{filters} ||= [];
1752 return $self->{filters};
1753}
1754
1755sub add_filter {
1756 my $self = shift;
1757 my $filter = shift;
1758
1759 $self->{filters} ||= [];
1760
1761 push(@{$self->{filters}}, $filter);
1762
1763 return $self;
1764}
1765
1766sub negate {
1767 my $self = shift;
1768 my $negate = shift;
1769
1770 $self->{negate} = $negate if (defined $negate);
1771
1772 return $self->{negate};
1773}
1774
1775# %opts supports two options at this time:
1776# no_phrases :
1777# If true, do not do anything to the phrases
1778# fields on any discovered nodes.
1779# with_config :
1780# If true, also return the query parser config as part of the blob.
1781# This will get set back to 0 before recursion to avoid repetition.
1782sub to_abstract_query {
1783 my $self = shift;
1784 my %opts = @_;
1785
1786 my $pkg = ref $self->QueryParser || $self->QueryParser;
1787
1788 my $abstract_query = {
1789 type => "query_plan",
1790 floating => $self->floating,
1791 level => $self->plan_level,
1792 filters => [map { $_->to_abstract_query } @{$self->filters}],
1793 modifiers => [map { $_->to_abstract_query } @{$self->modifiers}],
1794 negate => $self->negate
1795 };
1796
1797 if ($opts{with_config}) {
1798 $opts{with_config} = 0;
1799 $abstract_query->{config} = $OpenILS::QueryParser::parser_config{$pkg};
1800 }
1801
1802 my $kids = [];
1803
1804 for my $qnode (@{$self->query_nodes}) {
1805 # Remember: qnode can be a joiner string, a node, or another query_plan
1806
1807 if (OpenILS::QueryParser::_util::is_joiner($qnode)) {
1808 if ($abstract_query->{children}) {
1809 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1810 next if $open_joiner eq $qnode;
1811
1812 my $oldroot = $abstract_query->{children};
1813 $kids = [$oldroot];
1814 $abstract_query->{children} = {$qnode => $kids};
1815 } else {
1816 $abstract_query->{children} = {$qnode => $kids};
1817 }
1818 } else {
1819 push @$kids, $qnode->to_abstract_query(%opts);
1820 }
1821 }
1822
1823 $abstract_query->{children} ||= { OpenILS::QueryParser::_util::default_joiner() => $kids };
1824 return $abstract_query;
1825}
1826
1827
1828#-------------------------------
1829package OpenILS::QueryParser::query_plan::node;
183032.35ms2224µs
# spent 128µs (32+96) within OpenILS::QueryParser::query_plan::node::BEGIN@1830 which was called: # once (32µs+96µs) by base::import at line 1830
use Data::Dumper;
# spent 128µs making 1 call to OpenILS::QueryParser::query_plan::node::BEGIN@1830 # spent 96µs making 1 call to Exporter::import
18311900ns$Data::Dumper::Indent = 0;
1832
1833sub new {
1834 my $pkg = shift;
1835 $pkg = ref($pkg) || $pkg;
1836 my %args = @_;
1837
1838 return bless \%args => $pkg;
1839}
1840
1841sub new_atom {
1842 my $self = shift;
1843 my $pkg = ref($self) || $self;
1844 return do{$pkg.'::atom'}->new( @_ );
1845}
1846
1847sub requested_class { # also split into classname, fields and alias
1848 my $self = shift;
1849 my $class = shift;
1850
1851 if ($class) {
1852 my @afields;
1853 my (undef, $alias) = split '#', $class;
1854 if ($alias) {
1855 $class =~ s/#[^|]+//;
1856 ($alias, @afields) = split '\|', $alias;
1857 }
1858
1859 my @fields = @afields;
1860 my ($class_part, @field_parts) = split '\|', $class;
1861 for my $f (@field_parts) {
1862 push(@fields, $f) unless (grep { $f eq $_ } @fields);
1863 }
1864
1865 $class_part ||= $class;
1866
1867 $self->{requested_class} = $class;
1868 $self->{alias} = $alias if $alias;
1869 $self->{alias_fields} = \@afields if $alias;
1870 $self->{classname} = $class_part;
1871 $self->{fields} = \@fields;
1872 }
1873
1874 return $self->{requested_class};
1875}
1876
1877sub plan {
1878 my $self = shift;
1879 my $plan = shift;
1880
1881 $self->{plan} = $plan if ($plan);
1882 return $self->{plan};
1883}
1884
1885sub alias {
1886 my $self = shift;
1887 my $alias = shift;
1888
1889 $self->{alias} = $alias if ($alias);
1890 return $self->{alias};
1891}
1892
1893sub alias_fields {
1894 my $self = shift;
1895 my $alias = shift;
1896
1897 $self->{alias_fields} = $alias if ($alias);
1898 return $self->{alias_fields};
1899}
1900
1901sub classname {
1902 my $self = shift;
1903 my $class = shift;
1904
1905 $self->{classname} = $class if ($class);
1906 return $self->{classname};
1907}
1908
1909sub fields {
1910 my $self = shift;
1911 my @fields = @_;
1912
1913 $self->{fields} ||= [];
1914 $self->{fields} = \@fields if (@fields);
1915 return $self->{fields};
1916}
1917
1918sub phrases {
1919 my $self = shift;
1920 my @phrases = @_;
1921
1922 $self->{phrases} ||= [];
1923 $self->{phrases} = \@phrases if (@phrases);
1924 return $self->{phrases};
1925}
1926
1927sub add_phrase {
1928 my $self = shift;
1929 my $phrase = shift;
1930
1931 push(@{$self->phrases}, $phrase);
1932
1933 return $self;
1934}
1935
1936sub negate {
1937 my $self = shift;
1938 my $negate = shift;
1939
1940 $self->{negate} = $negate if (defined $negate);
1941
1942 return $self->{negate};
1943}
1944
1945sub query_atoms {
1946 my $self = shift;
1947 my @query_atoms = @_;
1948
1949 $self->{query_atoms} ||= [];
1950 $self->{query_atoms} = \@query_atoms if (@query_atoms);
1951 return $self->{query_atoms};
1952}
1953
1954sub add_fts_atom {
1955 my $self = shift;
1956 my $atom = shift;
1957
1958 if (!ref($atom)) {
1959 my $content = $atom;
1960 my @parts = @_;
1961
1962 $atom = $self->new_atom( content => $content, @parts );
1963 }
1964
1965 push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1966 push(@{$self->query_atoms}, $atom);
1967
1968 return $self;
1969}
1970
1971sub add_dummy_atom {
1972 my $self = shift;
1973 my @parts = @_;
1974
1975 my $atom = $self->new_atom( @parts, dummy => 1 );
1976
1977 push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1978 push(@{$self->query_atoms}, $atom);
1979
1980 return $self;
1981}
1982
1983# This will find up to one occurence of @$short_list within @$long_list, and
1984# replace it with the single atom $replacement.
1985sub replace_phrase_in_abstract_query {
1986 my ($self, $short_list, $long_list, $replacement) = @_;
1987
1988 my $success = 0;
1989 my @already = ();
1990 my $goal = scalar @$short_list;
1991
1992 for (my $i = 0; $i < scalar (@$long_list); $i++) {
1993 my $right = $long_list->[$i];
1994
1995 if (OpenILS::QueryParser::_util::compare_abstract_atoms(
1996 $short_list->[scalar @already], $right
1997 )) {
1998 push @already, $i;
1999 } elsif (scalar @already) {
2000 @already = ();
2001 next;
2002 }
2003
2004 if (scalar @already == $goal) {
2005 splice @$long_list, $already[0], scalar(@already), $replacement;
2006 $success = 1;
2007 last;
2008 }
2009 }
2010
2011 return $success;
2012}
2013
2014sub to_abstract_query {
2015 my $self = shift;
2016 my %opts = @_;
2017
2018 my $pkg = ref $self->plan->QueryParser || $self->plan->QueryParser;
2019
2020 my $abstract_query = {
2021 "type" => "node",
2022 "alias" => $self->alias,
2023 "alias_fields" => $self->alias_fields,
2024 "class" => $self->classname,
2025 "fields" => $self->fields
2026 };
2027
2028 my $kids = [];
2029
2030 for my $qatom (@{$self->query_atoms}) {
2031 if (OpenILS::QueryParser::_util::is_joiner($qatom)) {
2032 if ($abstract_query->{children}) {
2033 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
2034 next if $open_joiner eq $qatom;
2035
2036 my $oldroot = $abstract_query->{children};
2037 $kids = [$oldroot];
2038 $abstract_query->{children} = {$qatom => $kids};
2039 } else {
2040 $abstract_query->{children} = {$qatom => $kids};
2041 }
2042 } else {
2043 push @$kids, $qatom->to_abstract_query;
2044 }
2045 }
2046
2047 $abstract_query->{children} ||= { OpenILS::QueryParser::_util::default_joiner() => $kids };
2048
2049 if ($self->{phrases} and not $opts{no_phrases}) {
2050 for my $phrase (@{$self->{phrases}}) {
2051 # Phrases appear duplication in a real QP tree, and we don't want
2052 # that duplication in our abstract query. So for all our phrases,
2053 # break them into atoms as QP would, and remove any matching
2054 # sequences of atoms from our abstract query.
2055
2056 my $tmp_prefix = '';
2057 $tmp_prefix = $OpenILS::QueryParser::parser_config{$pkg}{operators}{disallowed} if ($self->{negate});
2058
2059 my $tmptree = $self->{plan}->{QueryParser}->new(query => $tmp_prefix.'"'.$phrase.'"')->parse->parse_tree;
2060 if ($tmptree) {
2061 # For a well-behaved phrase, we should now have only one node
2062 # in the $tmptree query plan, and that node should have an
2063 # orderly list of atoms and joiners.
2064
2065 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
2066 my $tmplist;
2067
2068 eval {
2069 $tmplist = $tmptree->{query}->[0]->to_abstract_query(
2070 no_phrases => 1
2071 )->{children}->{'&'}->[0]->{children}->{'&'};
2072 };
2073 next if $@;
2074
2075 foreach (
2076 OpenILS::QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
2077 ) {
2078 last if $self->replace_phrase_in_abstract_query(
2079 $tmplist,
2080 $_,
2081 OpenILS::QueryParser::_util::fake_abstract_atom_from_phrase($phrase, $self->{negate}, $pkg)
2082 );
2083 }
2084 }
2085 }
2086 }
2087 }
2088
2089 $abstract_query->{children} ||= { OpenILS::QueryParser::_util::default_joiner() => $kids };
2090 return $abstract_query;
2091}
2092
2093#-------------------------------
2094package OpenILS::QueryParser::query_plan::node::atom;
2095
2096sub new {
2097 my $pkg = shift;
2098 $pkg = ref($pkg) || $pkg;
2099 my %args = @_;
2100
2101 return bless \%args => $pkg;
2102}
2103
2104sub node {
2105 my $self = shift;
2106 return unless (ref $self);
2107 return $self->{node};
2108}
2109
2110sub content {
2111 my $self = shift;
2112 return unless (ref $self);
2113 return $self->{content};
2114}
2115
2116sub prefix {
2117 my $self = shift;
2118 return unless (ref $self);
2119 return $self->{prefix};
2120}
2121
2122sub suffix {
2123 my $self = shift;
2124 return unless (ref $self);
2125 return $self->{suffix};
2126}
2127
2128sub to_abstract_query {
2129 my ($self) = @_;
2130
2131 return {
2132 (map { $_ => $self->$_ } qw/prefix suffix content/),
2133 "type" => "atom"
2134 };
2135}
2136#-------------------------------
2137package OpenILS::QueryParser::query_plan::filter;
2138
2139sub new {
2140 my $pkg = shift;
2141 $pkg = ref($pkg) || $pkg;
2142 my %args = @_;
2143
2144 return bless \%args => $pkg;
2145}
2146
2147sub plan {
2148 my $self = shift;
2149 return $self->{plan};
2150}
2151
2152sub name {
2153 my $self = shift;
2154 return $self->{name};
2155}
2156
2157sub negate {
2158 my $self = shift;
2159 return $self->{negate};
2160}
2161
2162sub args {
2163 my $self = shift;
2164 return $self->{args};
2165}
2166
2167sub to_abstract_query {
2168 my ($self) = @_;
2169
2170 return {
2171 map { $_ => $self->$_ } qw/name negate args/
2172 };
2173}
2174
2175#-------------------------------
2176package OpenILS::QueryParser::query_plan::facet;
2177
2178sub new {
2179 my $pkg = shift;
2180 $pkg = ref($pkg) || $pkg;
2181 my %args = @_;
2182
2183 return bless \%args => $pkg;
2184}
2185
2186sub plan {
2187 my $self = shift;
2188 return $self->{plan};
2189}
2190
2191sub name {
2192 my $self = shift;
2193 return $self->{name};
2194}
2195
2196sub negate {
2197 my $self = shift;
2198 return $self->{negate};
2199}
2200
2201sub values {
2202 my $self = shift;
2203 return $self->{'values'};
2204}
2205
2206sub to_abstract_query {
2207 my ($self) = @_;
2208
2209 return {
2210 (map { $_ => $self->$_ } qw/name negate values/),
2211 "type" => "facet"
2212 };
2213}
2214
2215#-------------------------------
2216package OpenILS::QueryParser::query_plan::modifier;
2217
2218sub new {
2219 my $pkg = shift;
2220 $pkg = ref($pkg) || $pkg;
2221 my $modifier = shift;
2222 my $negate = shift;
2223
2224 return bless { name => $modifier, negate => $negate } => $pkg;
2225}
2226
2227sub name {
2228 my $self = shift;
2229 return $self->{name};
2230}
2231
2232sub negate {
2233 my $self = shift;
2234 return $self->{negate};
2235}
2236
2237sub to_abstract_query {
2238 my ($self) = @_;
2239
2240 return $self->name;
2241}
2242111µs1;
Report produced by the NYTProf 4.04 Perl profiler, developed by Tim Bunce and Adam Kaplan.