3838dd3ae3d3732018adca18da46242cb551bb7c
[working/Evergreen.git] / Open-ILS / src / perlmods / lib / OpenILS / Application / Storage / QueryParser.pm
1 use strict;
2 use warnings;
3
4 package QueryParser;
5 use OpenSRF::Utils::JSON;
6 our %parser_config = (
7     QueryParser => {
8         filters => [],
9         modifiers => [],
10         operators => { 
11             'and' => '&&',
12             'or' => '||',
13             group_start => '(',
14             group_end => ')',
15             required => '+',
16             disallowed => '-',
17             modifier => '#'
18         }
19     }
20 );
21
22 sub canonicalize {
23     my $self = shift;
24     return QueryParser::Canonicalize::abstract_query2str_impl(
25         $self->parse_tree->to_abstract_query(@_)
26     );
27 }
28
29
30 sub facet_class_count {
31     my $self = shift;
32     return @{$self->facet_classes};
33 }
34
35 sub search_class_count {
36     my $self = shift;
37     return @{$self->search_classes};
38 }
39
40 sub filter_count {
41     my $self = shift;
42     return @{$self->filters};
43 }
44
45 sub modifier_count {
46     my $self = shift;
47     return @{$self->modifiers};
48 }
49
50 sub custom_data {
51     my $class = shift;
52     $class = ref($class) || $class;
53
54     $parser_config{$class}{custom_data} ||= {};
55     return $parser_config{$class}{custom_data};
56 }
57
58 sub operators {
59     my $class = shift;
60     $class = ref($class) || $class;
61
62     $parser_config{$class}{operators} ||= {};
63     return $parser_config{$class}{operators};
64 }
65
66 sub filters {
67     my $class = shift;
68     $class = ref($class) || $class;
69
70     $parser_config{$class}{filters} ||= [];
71     return $parser_config{$class}{filters};
72 }
73
74 sub filter_callbacks {
75     my $class = shift;
76     $class = ref($class) || $class;
77
78     $parser_config{$class}{filter_callbacks} ||= {};
79     return $parser_config{$class}{filter_callbacks};
80 }
81
82 sub modifiers {
83     my $class = shift;
84     $class = ref($class) || $class;
85
86     $parser_config{$class}{modifiers} ||= [];
87     return $parser_config{$class}{modifiers};
88 }
89
90 sub new {
91     my $class = shift;
92     $class = ref($class) || $class;
93
94     my %opts = @_;
95
96     my $self = bless {} => $class;
97
98     for my $o (keys %{QueryParser->operators}) {
99         $class->operator($o => QueryParser->operator($o)) unless ($class->operator($o));
100     }
101
102     for my $opt ( keys %opts) {
103         $self->$opt( $opts{$opt} ) if ($self->can($opt));
104     }
105
106     return $self;
107 }
108
109 sub new_plan {
110     my $self = shift;
111     my $pkg = ref($self) || $self;
112     return do{$pkg.'::query_plan'}->new( QueryParser => $self, @_ );
113 }
114
115 sub add_search_filter {
116     my $pkg = shift;
117     $pkg = ref($pkg) || $pkg;
118     my $filter = shift;
119     my $callback = shift;
120
121     return $filter if (grep { $_ eq $filter } @{$pkg->filters});
122     push @{$pkg->filters}, $filter;
123     $pkg->filter_callbacks->{$filter} = $callback if ($callback);
124     return $filter;
125 }
126
127 sub add_search_modifier {
128     my $pkg = shift;
129     $pkg = ref($pkg) || $pkg;
130     my $modifier = shift;
131
132     return $modifier if (grep { $_ eq $modifier } @{$pkg->modifiers});
133     push @{$pkg->modifiers}, $modifier;
134     return $modifier;
135 }
136
137 sub add_facet_class {
138     my $pkg = shift;
139     $pkg = ref($pkg) || $pkg;
140     my $class = shift;
141
142     return $class if (grep { $_ eq $class } @{$pkg->facet_classes});
143
144     push @{$pkg->facet_classes}, $class;
145     $pkg->facet_fields->{$class} = [];
146
147     return $class;
148 }
149
150 sub add_search_class {
151     my $pkg = shift;
152     $pkg = ref($pkg) || $pkg;
153     my $class = shift;
154
155     return $class if (grep { $_ eq $class } @{$pkg->search_classes});
156
157     push @{$pkg->search_classes}, $class;
158     $pkg->search_fields->{$class} = [];
159     $pkg->default_search_class( $pkg->search_classes->[0] ) if (@{$pkg->search_classes} == 1);
160
161     return $class;
162 }
163
164 sub operator {
165     my $class = shift;
166     $class = ref($class) || $class;
167     my $opname = shift;
168     my $op = shift;
169
170     return undef unless ($opname);
171
172     $parser_config{$class}{operators} ||= {};
173     $parser_config{$class}{operators}{$opname} = $op if ($op);
174
175     return $parser_config{$class}{operators}{$opname};
176 }
177
178 sub facet_classes {
179     my $class = shift;
180     $class = ref($class) || $class;
181     my $classes = shift;
182
183     $parser_config{$class}{facet_classes} ||= [];
184     $parser_config{$class}{facet_classes} = $classes if (ref($classes) && @$classes);
185     return $parser_config{$class}{facet_classes};
186 }
187
188 sub search_classes {
189     my $class = shift;
190     $class = ref($class) || $class;
191     my $classes = shift;
192
193     $parser_config{$class}{classes} ||= [];
194     $parser_config{$class}{classes} = $classes if (ref($classes) && @$classes);
195     return $parser_config{$class}{classes};
196 }
197
198 sub add_query_normalizer {
199     my $pkg = shift;
200     $pkg = ref($pkg) || $pkg;
201     my $class = shift;
202     my $field = shift;
203     my $func = shift;
204     my $params = shift || [];
205
206     # do not add if function AND params are identical to existing member
207     return $func if (grep {
208         $_->{function} eq $func and 
209         OpenSRF::Utils::JSON->perl2JSON($_->{params}) eq OpenSRF::Utils::JSON->perl2JSON($params)
210     } @{$pkg->query_normalizers->{$class}->{$field}});
211
212     push(@{$pkg->query_normalizers->{$class}->{$field}}, { function => $func, params => $params });
213
214     return $func;
215 }
216
217 sub query_normalizers {
218     my $pkg = shift;
219     $pkg = ref($pkg) || $pkg;
220
221     my $class = shift;
222     my $field = shift;
223
224     $parser_config{$pkg}{normalizers} ||= {};
225     if ($class) {
226         if ($field) {
227             $parser_config{$pkg}{normalizers}{$class}{$field} ||= [];
228             return $parser_config{$pkg}{normalizers}{$class}{$field};
229         } else {
230             return $parser_config{$pkg}{normalizers}{$class};
231         }
232     }
233
234     return $parser_config{$pkg}{normalizers};
235 }
236
237 sub add_filter_normalizer {
238     my $pkg = shift;
239     $pkg = ref($pkg) || $pkg;
240     my $filter = shift;
241     my $func = shift;
242     my $params = shift || [];
243
244     return $func if (grep { $_ eq $func } @{$pkg->filter_normalizers->{$filter}});
245
246     push(@{$pkg->filter_normalizers->{$filter}}, { function => $func, params => $params });
247
248     return $func;
249 }
250
251 sub filter_normalizers {
252     my $pkg = shift;
253     $pkg = ref($pkg) || $pkg;
254
255     my $filter = shift;
256
257     $parser_config{$pkg}{filter_normalizers} ||= {};
258     if ($filter) {
259         $parser_config{$pkg}{filter_normalizers}{$filter} ||= [];
260         return $parser_config{$pkg}{filter_normalizers}{$filter};
261     }
262
263     return $parser_config{$pkg}{filter_normalizers};
264 }
265
266 sub default_search_class {
267     my $pkg = shift;
268     $pkg = ref($pkg) || $pkg;
269     my $class = shift;
270     $QueryParser::parser_config{$pkg}{default_class} = $pkg->add_search_class( $class ) if $class;
271
272     return $QueryParser::parser_config{$pkg}{default_class};
273 }
274
275 sub remove_facet_class {
276     my $pkg = shift;
277     $pkg = ref($pkg) || $pkg;
278     my $class = shift;
279
280     return $class if (!grep { $_ eq $class } @{$pkg->facet_classes});
281
282     $pkg->facet_classes( [ grep { $_ ne $class } @{$pkg->facet_classes} ] );
283     delete $QueryParser::parser_config{$pkg}{facet_fields}{$class};
284
285     return $class;
286 }
287
288 sub remove_search_class {
289     my $pkg = shift;
290     $pkg = ref($pkg) || $pkg;
291     my $class = shift;
292
293     return $class if (!grep { $_ eq $class } @{$pkg->search_classes});
294
295     $pkg->search_classes( [ grep { $_ ne $class } @{$pkg->search_classes} ] );
296     delete $QueryParser::parser_config{$pkg}{fields}{$class};
297
298     return $class;
299 }
300
301 sub add_facet_field {
302     my $pkg = shift;
303     $pkg = ref($pkg) || $pkg;
304     my $class = shift;
305     my $field = shift;
306
307     $pkg->add_facet_class( $class );
308
309     return { $class => $field }  if (grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
310
311     push @{$pkg->facet_fields->{$class}}, $field;
312
313     return { $class => $field };
314 }
315
316 sub facet_fields {
317     my $class = shift;
318     $class = ref($class) || $class;
319
320     $parser_config{$class}{facet_fields} ||= {};
321     return $parser_config{$class}{facet_fields};
322 }
323
324 sub add_search_field {
325     my $pkg = shift;
326     $pkg = ref($pkg) || $pkg;
327     my $class = shift;
328     my $field = shift;
329
330     $pkg->add_search_class( $class );
331
332     return { $class => $field }  if (grep { $_ eq $field } @{$pkg->search_fields->{$class}});
333
334     push @{$pkg->search_fields->{$class}}, $field;
335
336     return { $class => $field };
337 }
338
339 sub search_fields {
340     my $class = shift;
341     $class = ref($class) || $class;
342
343     $parser_config{$class}{fields} ||= {};
344     return $parser_config{$class}{fields};
345 }
346
347 sub add_search_class_alias {
348     my $pkg = shift;
349     $pkg = ref($pkg) || $pkg;
350     my $class = shift;
351     my $alias = shift;
352
353     $pkg->add_search_class( $class );
354
355     return { $class => $alias }  if (grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
356
357     push @{$pkg->search_class_aliases->{$class}}, $alias;
358
359     return { $class => $alias };
360 }
361
362 sub search_class_aliases {
363     my $class = shift;
364     $class = ref($class) || $class;
365
366     $parser_config{$class}{class_map} ||= {};
367     return $parser_config{$class}{class_map};
368 }
369
370 sub add_search_field_alias {
371     my $pkg = shift;
372     $pkg = ref($pkg) || $pkg;
373     my $class = shift;
374     my $field = shift;
375     my $alias = shift;
376
377     return { $class => { $field => $alias } }  if (grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
378
379     push @{$pkg->search_field_aliases->{$class}{$field}}, $alias;
380
381     return { $class => { $field => $alias } };
382 }
383
384 sub search_field_aliases {
385     my $class = shift;
386     $class = ref($class) || $class;
387
388     $parser_config{$class}{field_alias_map} ||= {};
389     return $parser_config{$class}{field_alias_map};
390 }
391
392 sub remove_facet_field {
393     my $pkg = shift;
394     $pkg = ref($pkg) || $pkg;
395     my $class = shift;
396     my $field = shift;
397
398     return { $class => $field }  if (!$pkg->facet_fields->{$class} || !grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
399
400     $pkg->facet_fields->{$class} = [ grep { $_ ne $field } @{$pkg->facet_fields->{$class}} ];
401
402     return { $class => $field };
403 }
404
405 sub remove_search_field {
406     my $pkg = shift;
407     $pkg = ref($pkg) || $pkg;
408     my $class = shift;
409     my $field = shift;
410
411     return { $class => $field }  if (!$pkg->search_fields->{$class} || !grep { $_ eq $field } @{$pkg->search_fields->{$class}});
412
413     $pkg->search_fields->{$class} = [ grep { $_ ne $field } @{$pkg->search_fields->{$class}} ];
414
415     return { $class => $field };
416 }
417
418 sub remove_search_field_alias {
419     my $pkg = shift;
420     $pkg = ref($pkg) || $pkg;
421     my $class = shift;
422     my $field = shift;
423     my $alias = shift;
424
425     return { $class => { $field => $alias } }  if (!$pkg->search_field_aliases->{$class}{$field} || !grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
426
427     $pkg->search_field_aliases->{$class}{$field} = [ grep { $_ ne $alias } @{$pkg->search_field_aliases->{$class}{$field}} ];
428
429     return { $class => { $field => $alias } };
430 }
431
432 sub remove_search_class_alias {
433     my $pkg = shift;
434     $pkg = ref($pkg) || $pkg;
435     my $class = shift;
436     my $alias = shift;
437
438     return { $class => $alias }  if (!$pkg->search_class_aliases->{$class} || !grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
439
440     $pkg->search_class_aliases->{$class} = [ grep { $_ ne $alias } @{$pkg->search_class_aliases->{$class}} ];
441
442     return { $class => $alias };
443 }
444
445 sub debug {
446     my $self = shift;
447     my $q = shift;
448     $self->{_debug} = $q if (defined $q);
449     return $self->{_debug};
450 }
451
452 sub query {
453     my $self = shift;
454     my $q = shift;
455     $self->{_query} = $q if (defined $q);
456     return $self->{_query};
457 }
458
459 sub parse_tree {
460     my $self = shift;
461     my $q = shift;
462     $self->{_parse_tree} = $q if (defined $q);
463     return $self->{_parse_tree};
464 }
465
466 sub parse {
467     my $self = shift;
468     my $pkg = ref($self) || $self;
469     warn " ** parse package is $pkg\n" if $self->debug;
470     $self->parse_tree(
471         $self->decompose(
472             $self->query( shift() )
473         )
474     );
475
476     return $self;
477 }
478
479 sub decompose {
480     my $self = shift;
481     my $pkg = ref($self) || $self;
482
483     warn " ** decompose package is $pkg\n" if $self->debug;
484
485     $_ = shift;
486     my $current_class = shift || $self->default_search_class;
487
488     my $recursing = shift || 0;
489     my $phrase_helper = shift || 0;
490
491     # Build the search class+field uber-regexp
492     my $search_class_re = '^\s*(';
493     my $first_class = 1;
494
495     my %seen_classes;
496     for my $class ( keys %{$pkg->search_field_aliases} ) {
497         warn " *** ... Looking for search fields in $class\n" if $self->debug;
498
499         for my $field ( keys %{$pkg->search_field_aliases->{$class}} ) {
500             warn " *** ... Looking for aliases of $field\n" if $self->debug;
501
502             for my $alias ( @{$pkg->search_field_aliases->{$class}{$field}} ) {
503                 my $aliasr = qr/$alias/;
504                 s/(^|\s+)$aliasr\|/$1$class\|$field#$alias\|/g;
505                 s/(^|\s+)$aliasr[:=]/$1$class\|$field#$alias:/g;
506                 warn " *** Rewriting: $alias ($aliasr) as $class\|$field\n" if $self->debug;
507             }
508         }
509
510         $search_class_re .= '|' unless ($first_class);
511         $first_class = 0;
512         $search_class_re .= $class . '(?:[|#][^:|]+)*';
513         $seen_classes{$class} = 1;
514     }
515
516     for my $class ( keys %{$pkg->search_class_aliases} ) {
517
518         for my $alias ( @{$pkg->search_class_aliases->{$class}} ) {
519             my $aliasr = qr/$alias/;
520             s/(^|[^|])\b$aliasr\|/$1$class#$alias\|/g;
521             s/(^|[^|])\b$aliasr[:=]/$1$class#$alias:/g;
522             warn " *** Rewriting: $alias ($aliasr) as $class\n" if $self->debug;
523         }
524
525         if (!$seen_classes{$class}) {
526             $search_class_re .= '|' unless ($first_class);
527             $first_class = 0;
528
529             $search_class_re .= $class . '(?:[|#][^:|]+)*';
530             $seen_classes{$class} = 1;
531         }
532     }
533     $search_class_re .= '):';
534
535     warn " ** Rewritten query: $_\n" if $self->debug;
536     warn " ** Search class RE: $search_class_re\n" if $self->debug;
537
538     my $required_re = $pkg->operator('required');
539     $required_re = qr/\Q$required_re\E/;
540
541     my $disallowed_re = $pkg->operator('disallowed');
542     $disallowed_re = qr/\Q$disallowed_re\E/;
543
544     my $and_re = $pkg->operator('and');
545     $and_re = qr/^\s*\Q$and_re\E/;
546
547     my $or_re = $pkg->operator('or');
548     $or_re = qr/^\s*\Q$or_re\E/;
549
550     my $group_start_re = $pkg->operator('group_start');
551     $group_start_re = qr/^\s*\Q$group_start_re\E/;
552
553     my $group_end = $pkg->operator('group_end');
554     my $group_end_re = qr/^\s*\Q$group_end\E/;
555
556     my $modifier_tag_re = $pkg->operator('modifier');
557     $modifier_tag_re = qr/^\s*\Q$modifier_tag_re\E/;
558
559
560     # Build the filter and modifier uber-regexps
561     my $facet_re = '^\s*(-?)((?:' . join( '|', @{$pkg->facet_classes}) . ')(?:\|\w+)*)\[(.+?)\]';
562     warn " ** Facet RE: $facet_re\n" if $self->debug;
563
564     my $filter_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . ')\(([^()]+)\)';
565     my $filter_as_class_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . '):\s*(\S+)';
566
567     my $modifier_re = '^\s*'.$modifier_tag_re.'(' . join( '|', @{$pkg->modifiers}) . ')\b';
568     my $modifier_as_class_re = '^\s*(' . join( '|', @{$pkg->modifiers}) . '):\s*(\S+)';
569
570     my $struct = $self->new_plan( level => $recursing );
571     my $remainder = '';
572
573     my $last_type = '';
574     while (!$remainder) {
575         if (/^\s*$/) { # end of an explicit group
576             last;
577         } elsif (/$group_end_re/) { # end of an explicit group
578             warn "Encountered explicit group end\n" if $self->debug;
579
580             $_ = $';
581             $remainder = $struct->top_plan ? '' : $';
582
583             $last_type = '';
584         } elsif ($self->filter_count && /$filter_re/) { # found a filter
585             warn "Encountered search filter: $1$2 set to $3\n" if $self->debug;
586
587             my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
588             $_ = $';
589
590             my $filter = $2;
591             my $params = [ split '[,]+', $3 ];
592
593             if ($pkg->filter_callbacks->{$filter}) {
594                 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
595                 $_ = "$replacement $_" if ($replacement);
596             } else {
597                 $struct->new_filter( $filter => $params, $negate );
598             }
599
600
601             $last_type = '';
602         } elsif ($self->filter_count && /$filter_as_class_re/) { # found a filter
603             warn "Encountered search filter: $1$2 set to $3\n" if $self->debug;
604
605             my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
606             $_ = $';
607
608             my $filter = $2;
609             my $params = [ split '[,]+', $3 ];
610
611             if ($pkg->filter_callbacks->{$filter}) {
612                 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
613                 $_ = "$replacement $_" if ($replacement);
614             } else {
615                 $struct->new_filter( $filter => $params, $negate );
616             }
617
618             $last_type = '';
619         } elsif ($self->modifier_count && /$modifier_re/) { # found a modifier
620             warn "Encountered search modifier: $1\n" if $self->debug;
621
622             $_ = $';
623             if (!$struct->top_plan) {
624                 warn "  Search modifiers only allowed at the top level of the query\n" if $self->debug;
625             } else {
626                 $struct->new_modifier($1);
627             }
628
629             $last_type = '';
630         } elsif ($self->modifier_count && /$modifier_as_class_re/) { # found a modifier
631             warn "Encountered search modifier: $1\n" if $self->debug;
632
633             my $mod = $1;
634
635             $_ = $';
636             if (!$struct->top_plan) {
637                 warn "  Search modifiers only allowed at the top level of the query\n" if $self->debug;
638             } elsif ($2 =~ /^[ty1]/i) {
639                 $struct->new_modifier($mod);
640             }
641
642             $last_type = '';
643         } elsif (/$group_start_re/) { # start of an explicit group
644             warn "Encountered explicit group start\n" if $self->debug;
645
646             my ($substruct, $subremainder) = $self->decompose( $', $current_class, $recursing + 1 );
647             $struct->add_node( $substruct ) if ($substruct);
648             $_ = $subremainder;
649
650             $last_type = '';
651         } elsif (/$and_re/) { # ANDed expression
652             $_ = $';
653             next if ($last_type eq 'AND');
654             next if ($last_type eq 'OR');
655             warn "Encountered AND\n" if $self->debug;
656
657             my $LHS = $struct;
658             my ($RHS, $subremainder) = $self->decompose( '('.$_.')', $current_class, $recursing + 1 );
659             $_ = $subremainder;
660
661             $struct = $self->new_plan( level => $recursing, joiner => '&' );
662             $struct->add_node($_) for ($LHS, $RHS);
663
664             $last_type = 'AND';
665         } elsif (/$or_re/) { # ORed expression
666             $_ = $';
667             next if ($last_type eq 'AND');
668             next if ($last_type eq 'OR');
669             warn "Encountered OR\n" if $self->debug;
670
671             my $LHS = $struct;
672             my ($RHS, $subremainder) = $self->decompose( '('.$_.')', $current_class, $recursing + 1 );
673             $_ = $subremainder;
674
675             $struct = $self->new_plan( level => $recursing, joiner => '|' );
676             $struct->add_node($_) for ($LHS, $RHS);
677
678             $last_type = 'OR';
679         } elsif ($self->facet_class_count && /$facet_re/) { # changing current class
680             warn "Encountered facet: $1$2 => $3\n" if $self->debug;
681
682             my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
683             my $facet = $2;
684             my $facet_value = [ split '\s*#\s*', $3 ];
685             $struct->new_facet( $facet => $facet_value, $negate );
686             $_ = $';
687
688             $last_type = '';
689         } elsif ($self->search_class_count && /$search_class_re/) { # changing current class
690
691             if ($last_type eq 'CLASS') {
692                 $struct->remove_last_node( $current_class );
693                 warn "Encountered class change with no searches!\n" if $self->debug;
694             }
695
696             warn "Encountered class change: $1\n" if $self->debug;
697
698             $current_class = $struct->classed_node( $1 )->requested_class();
699             $_ = $';
700
701             $last_type = 'CLASS';
702         } elsif (/^\s*($required_re|$disallowed_re)?"([^"]+)"/) { # phrase, always anded
703             warn 'Encountered' . ($1 ? " ['$1' modified]" : '') . " phrase: $2\n" if $self->debug;
704
705             my $req_ness = $1 || '';
706             my $phrase = $2;
707
708             if (!$phrase_helper) {
709                 warn "Recursing into decompose with the phrase as a subquery\n" if $self->debug;
710                 my $after = $';
711                 my ($substruct, $subremainder) = $self->decompose( qq/$req_ness"$phrase"/, $current_class, $recursing + 1, 1 );
712                 $struct->add_node( $substruct ) if ($substruct);
713                 $_ = $after;
714             } else {
715                 warn "Directly parsing the phrase subquery\n" if $self->debug;
716                 $struct->joiner( '&' );
717
718                 my $class_node = $struct->classed_node($current_class);
719
720                 if ($req_ness eq $pkg->operator('disallowed')) {
721                     $class_node->add_dummy_atom( node => $class_node );
722                     $class_node->add_unphrase( $phrase );
723                     $phrase = '';
724                     #$phrase =~ s/(^|\s)\b/$1-/g;
725                 } else { 
726                     $class_node->add_phrase( $phrase );
727                 }
728                 $_ = $phrase . $';
729
730             }
731
732             $last_type = '';
733
734 #        } elsif (/^\s*$required_re([^\s"]+)/) { # phrase, always anded
735 #            warn "Encountered required atom (mini phrase): $1\n" if $self->debug;
736 #
737 #            my $phrase = $1;
738 #
739 #            my $class_node = $struct->classed_node($current_class);
740 #            $class_node->add_phrase( $phrase );
741 #            $_ = $phrase . $';
742 #            $struct->joiner( '&' );
743 #
744 #            $last_type = '';
745         } elsif (/^\s*([^$group_end\s]+)/o) { # atom
746             warn "Encountered atom: $1\n" if $self->debug;
747             warn "Remainder: $'\n" if $self->debug;
748
749             my $atom = $1;
750             my $after = $';
751
752             $_ = $after;
753             $last_type = '';
754
755             my $class_node = $struct->classed_node($current_class);
756
757             my $prefix = ($atom =~ s/^$disallowed_re//o) ? '!' : '';
758             my $truncate = ($atom =~ s/\*$//o) ? '*' : '';
759
760             if ($atom ne '' and !grep { $atom =~ /^\Q$_\E+$/ } ('&','|','-','+')) { # throw away & and |, not allowed in tsquery, and not really useful anyway
761 #                $class_node->add_phrase( $atom ) if ($atom =~ s/^$required_re//o);
762 #                $class_node->add_unphrase( $atom ) if ($prefix eq '!');
763
764                 $class_node->add_fts_atom( $atom, suffix => $truncate, prefix => $prefix, node => $class_node );
765                 $struct->joiner( '&' );
766             }
767         } 
768
769         last unless ($_);
770
771     }
772
773     $struct = undef if 
774         scalar(@{$struct->query_nodes}) == 0 &&
775         scalar(@{$struct->filters}) == 0 &&
776         !$struct->top_plan;
777
778     return $struct if !wantarray;
779     return ($struct, $remainder);
780 }
781
782 sub find_class_index {
783     my $class = shift;
784     my $query = shift;
785
786     my ($class_part, @field_parts) = split '\|', $class;
787     $class_part ||= $class;
788
789     for my $idx ( 0 .. scalar(@$query) - 1 ) {
790         next unless ref($$query[$idx]);
791         return $idx if ( $$query[$idx]{requested_class} && $class eq $$query[$idx]{requested_class} );
792     }
793
794     push(@$query, { classname => $class_part, (@field_parts ? (fields => \@field_parts) : ()), requested_class => $class, ftsquery => [], phrases => [] });
795     return -1;
796 }
797
798 sub core_limit {
799     my $self = shift;
800     my $l = shift;
801     $self->{core_limit} = $l if ($l);
802     return $self->{core_limit};
803 }
804
805 sub superpage {
806     my $self = shift;
807     my $l = shift;
808     $self->{superpage} = $l if ($l);
809     return $self->{superpage};
810 }
811
812 sub superpage_size {
813     my $self = shift;
814     my $l = shift;
815     $self->{superpage_size} = $l if ($l);
816     return $self->{superpage_size};
817 }
818
819
820 #-------------------------------
821 package QueryParser::_util;
822
823 # At this level, joiners are always & or |.  This is not
824 # the external, configurable representation of joiners that
825 # defaults to # && and ||.
826 sub is_joiner {
827     my $str = shift;
828
829     return (not ref $str and ($str eq '&' or $str eq '|'));
830 }
831
832 sub default_joiner { '&' }
833
834 # 0 for different, 1 for the same.
835 sub compare_abstract_atoms {
836     my ($left, $right) = @_;
837
838     foreach (qw/prefix suffix content/) {
839         no warnings;    # undef can stand in for '' here
840         return 0 unless $left->{$_} eq $right->{$_};
841     }
842
843     return 1;
844 }
845
846 sub fake_abstract_atom_from_phrase {
847     my $phrase = shift;
848     my $neg = shift;
849     my $qp_class = shift || 'QueryParser';
850
851     my $prefix = '"';
852     if ($neg) {
853         $prefix =
854             $QueryParser::parser_config{$qp_class}{operators}{disallowed} .
855             $prefix;
856     }
857
858     return {
859         "type" => "atom", "prefix" => $prefix, "suffix" => '"',
860         "content" => $phrase
861     }
862 }
863
864 sub find_arrays_in_abstract {
865     my ($hash) = @_;
866
867     my @arrays;
868     foreach my $key (keys %$hash) {
869         if (ref $hash->{$key} eq "ARRAY") {
870             push @arrays, $hash->{$key};
871             foreach (@{$hash->{$key}}) {
872                 push @arrays, find_arrays_in_abstract($_);
873             }
874         }
875     }
876
877     return @arrays;
878 }
879
880 #-------------------------------
881 package QueryParser::Canonicalize;  # not OO
882
883 sub _abstract_query2str_filter {
884     my $f = shift;
885     my $qp_class = shift || 'QueryParser';
886     my $qpconfig = $QueryParser::parser_config{$qp_class};
887
888     return sprintf(
889         '%s%s(%s)',
890         $f->{negate} ? $qpconfig->{operators}{disallowed} : "",
891         $f->{name},
892         join(",", @{$f->{args}})
893     );
894 }
895
896 sub _abstract_query2str_modifier {
897     my $f = shift;
898     my $qp_class = shift || 'QueryParser';
899     my $qpconfig = $QueryParser::parser_config{$qp_class};
900
901     return $qpconfig->{operators}{modifier} . $f;
902 }
903
904 # This should produce an equivalent query to the original, given an
905 # abstract_query.
906 sub abstract_query2str_impl {
907     my $abstract_query  = shift;
908     my $depth = shift || 0;
909
910     my $qp_class ||= shift || 'QueryParser';
911     my $qpconfig = $QueryParser::parser_config{$qp_class};
912
913     my $gs = $qpconfig->{operators}{group_start};
914     my $ge = $qpconfig->{operators}{group_end};
915     my $and = $qpconfig->{operators}{and};
916     my $or = $qpconfig->{operators}{or};
917
918     my $needs_group = 0;
919     my $q = "";
920
921     if (exists $abstract_query->{type}) {
922         if ($abstract_query->{type} eq 'query_plan') {
923             $q .= join(" ", map { _abstract_query2str_filter($_, $qp_class) } @{$abstract_query->{filters}}) if
924                 exists $abstract_query->{filters};
925             $needs_group += scalar(@{$abstract_query->{filters}}) if exists $abstract_query->{filters};
926
927             $q .= " ";
928
929             $q .= join(" ", map { _abstract_query2str_modifier($_, $qp_class) } @{$abstract_query->{modifiers}}) if
930                 exists $abstract_query->{modifiers};
931             $needs_group += scalar(@{$abstract_query->{modifiers}}) if exists $abstract_query->{modifiers};
932         } elsif ($abstract_query->{type} eq 'node') {
933             if ($abstract_query->{alias}) {
934                 $q .= " " . $abstract_query->{alias};
935                 $q .= "|$_" foreach @{$abstract_query->{alias_fields}};
936             } else {
937                 $q .= " " . $abstract_query->{class};
938                 $q .= "|$_" foreach @{$abstract_query->{fields}};
939             }
940             $q .= ":";
941         } elsif ($abstract_query->{type} eq 'atom') {
942             my $prefix = $abstract_query->{prefix} || '';
943             $prefix = $qpconfig->{operators}{disallowed} if $prefix eq '!';
944             $q .= $prefix .
945                 ($abstract_query->{content} || '') .
946                 ($abstract_query->{suffix} || '');
947             $needs_group += 1;
948         } elsif ($abstract_query->{type} eq 'facet') {
949             # facet syntax [ # ] is hardcoded I guess?
950             my $prefix = $abstract_query->{negate} ? $qpconfig->{operators}{disallowed} : '';
951             $q .= $prefix . $abstract_query->{name} . "[" .
952                 join(" # ", @{$abstract_query->{values}}) . "]";
953             $needs_group += 1;
954         }
955     }
956
957     if (exists $abstract_query->{children}) {
958         my $op = (keys(%{$abstract_query->{children}}))[0];
959         $q .= join(
960             " " . ($op eq '&' ? '' : $or) . " ",
961             map {
962                 abstract_query2str_impl($_, $depth + 1, $qp_class)
963             } @{$abstract_query->{children}{$op}}
964         );
965         $needs_group += scalar(@{$abstract_query->{children}{$op}});
966     } elsif ($abstract_query->{'&'} or $abstract_query->{'|'}) {
967         my $op = (keys(%{$abstract_query}))[0];
968         $q .= join(
969             " " . ($op eq '&' ? $and : $or) . " ",
970             map {
971                 abstract_query2str_impl($_, $depth + 1, $qp_class)
972             } @{$abstract_query->{$op}}
973         );
974         $needs_group += scalar(@{$abstract_query->{$op}});
975     }
976     $q .= " ";
977
978     $q = $gs . $q . $ge if ($needs_group > 1 and $depth);
979
980     return $q;
981 }
982
983 #-------------------------------
984 package QueryParser::query_plan;
985
986 sub QueryParser {
987     my $self = shift;
988     return undef unless ref($self);
989     return $self->{QueryParser};
990 }
991
992 sub new {
993     my $pkg = shift;
994     $pkg = ref($pkg) || $pkg;
995     my %args = (query => [], joiner => '&', @_);
996
997     return bless \%args => $pkg;
998 }
999
1000 sub new_node {
1001     my $self = shift;
1002     my $pkg = ref($self) || $self;
1003     my $node = do{$pkg.'::node'}->new( plan => $self, @_ );
1004     $self->add_node( $node );
1005     return $node;
1006 }
1007
1008 sub new_facet {
1009     my $self = shift;
1010     my $pkg = ref($self) || $self;
1011     my $name = shift;
1012     my $args = shift;
1013     my $negate = shift;
1014
1015     my $node = do{$pkg.'::facet'}->new( plan => $self, name => $name, 'values' => $args, negate => $negate );
1016     $self->add_node( $node );
1017
1018     return $node;
1019 }
1020
1021 sub new_filter {
1022     my $self = shift;
1023     my $pkg = ref($self) || $self;
1024     my $name = shift;
1025     my $args = shift;
1026     my $negate = shift;
1027
1028     my $node = do{$pkg.'::filter'}->new( plan => $self, name => $name, args => $args, negate => $negate );
1029     $self->add_filter( $node );
1030
1031     return $node;
1032 }
1033
1034
1035 sub _merge_filters {
1036     my $left_filter = shift;
1037     my $right_filter = shift;
1038     my $join = shift;
1039
1040     return undef unless $left_filter or $right_filter;
1041     return $right_filter unless $left_filter;
1042     return $left_filter unless $right_filter;
1043
1044     my $args = $left_filter->{args} || [];
1045
1046     if ($join eq '|') {
1047         push(@$args, @{$right_filter->{args}});
1048
1049     } else {
1050         # find the intersect values
1051         my %new_vals;
1052         map { $new_vals{$_} = 1 } @{$right_filter->{args} || []};
1053         $args = [ grep { $new_vals{$_} } @$args ];
1054     }
1055
1056     $left_filter->{args} = $args;
1057     return $left_filter;
1058 }
1059
1060 sub collapse_filters {
1061     my $self = shift;
1062     my $name = shift;
1063
1064     # start by merging any filters at this level.
1065     # like-level filters are always ORed together
1066
1067     my $cur_filter;
1068     my @cur_filters = grep {$_->name eq $name } @{ $self->filters };
1069     if (@cur_filters) {
1070         $cur_filter = shift @cur_filters;
1071         my $args = $cur_filter->{args} || [];
1072         $cur_filter = _merge_filters($cur_filter, $_, '|') for @cur_filters;
1073     }
1074
1075     # next gather the collapsed filters from sub-plans and 
1076     # merge them with our own
1077
1078     my @subquery = @{$self->{query}};
1079
1080     while (@subquery) {
1081         my $blob = shift @subquery;
1082         shift @subquery; # joiner
1083         next unless $blob->isa('QueryParser::query_plan');
1084         my $sub_filter = $blob->collapse_filters($name);
1085         $cur_filter = _merge_filters($cur_filter, $sub_filter, $self->joiner);
1086     }
1087
1088     if ($self->QueryParser->debug) {
1089         my @args = ($cur_filter and $cur_filter->{args}) ? @{$cur_filter->{args}} : ();
1090         warn "collapse_filters($name) => [@args]\n";
1091     }
1092
1093     return $cur_filter;
1094 }
1095
1096 sub find_filter {
1097     my $self = shift;
1098     my $needle = shift;;
1099     return undef unless ($needle);
1100
1101     my $filter = $self->collapse_filters($needle);
1102
1103     warn "find_filter($needle) => " . 
1104         (($filter and $filter->{args}) ? "@{$filter->{args}}" : '[]') . "\n" 
1105         if $self->QueryParser->debug;
1106
1107     return $filter ? ($filter) : ();
1108 }
1109
1110 sub find_modifier {
1111     my $self = shift;
1112     my $needle = shift;;
1113     return undef unless ($needle);
1114     return grep { $_->name eq $needle } @{ $self->modifiers };
1115 }
1116
1117 sub new_modifier {
1118     my $self = shift;
1119     my $pkg = ref($self) || $self;
1120     my $name = shift;
1121
1122     my $node = do{$pkg.'::modifier'}->new( $name );
1123     $self->add_modifier( $node );
1124
1125     return $node;
1126 }
1127
1128 sub classed_node {
1129     my $self = shift;
1130     my $requested_class = shift;
1131
1132     my $node;
1133     for my $n (@{$self->{query}}) {
1134         next unless (ref($n) && $n->isa( 'QueryParser::query_plan::node' ));
1135         if ($n->requested_class eq $requested_class) {
1136             $node = $n;
1137             last;
1138         }
1139     }
1140
1141     if (!$node) {
1142         $node = $self->new_node;
1143         $node->requested_class( $requested_class );
1144     }
1145
1146     return $node;
1147 }
1148
1149 sub remove_last_node {
1150     my $self = shift;
1151     my $requested_class = shift;
1152
1153     my $old = pop(@{$self->query_nodes});
1154     pop(@{$self->query_nodes}) if (@{$self->query_nodes});
1155
1156     return $old;
1157 }
1158
1159 sub query_nodes {
1160     my $self = shift;
1161     return $self->{query};
1162 }
1163
1164 sub add_node {
1165     my $self = shift;
1166     my $node = shift;
1167
1168     $self->{query} ||= [];
1169     push(@{$self->{query}}, $self->joiner) if (@{$self->{query}});
1170     push(@{$self->{query}}, $node);
1171
1172     return $self;
1173 }
1174
1175 sub top_plan {
1176     my $self = shift;
1177
1178     return $self->{level} ? 0 : 1;
1179 }
1180
1181 sub plan_level {
1182     my $self = shift;
1183     return $self->{level};
1184 }
1185
1186 sub joiner {
1187     my $self = shift;
1188     my $joiner = shift;
1189
1190     $self->{joiner} = $joiner if ($joiner);
1191     return $self->{joiner};
1192 }
1193
1194 sub modifiers {
1195     my $self = shift;
1196     $self->{modifiers} ||= [];
1197     return $self->{modifiers};
1198 }
1199
1200 sub add_modifier {
1201     my $self = shift;
1202     my $modifier = shift;
1203
1204     $self->{modifiers} ||= [];
1205     $self->{modifiers} = [ grep {$_->name ne $modifier->name} @{$self->{modifiers}} ];
1206
1207     push(@{$self->{modifiers}}, $modifier);
1208
1209     return $self;
1210 }
1211
1212 sub facets {
1213     my $self = shift;
1214     $self->{facets} ||= [];
1215     return $self->{facets};
1216 }
1217
1218 sub add_facet {
1219     my $self = shift;
1220     my $facet = shift;
1221
1222     $self->{facets} ||= [];
1223     $self->{facets} = [ grep {$_->name ne $facet->name} @{$self->{facets}} ];
1224
1225     push(@{$self->{facets}}, $facet);
1226
1227     return $self;
1228 }
1229
1230 sub filters {
1231     my $self = shift;
1232     $self->{filters} ||= [];
1233     return $self->{filters};
1234 }
1235
1236 sub add_filter {
1237     my $self = shift;
1238     my $filter = shift;
1239
1240     $self->{filters} ||= [];
1241
1242     push(@{$self->{filters}}, $filter);
1243
1244     return $self;
1245 }
1246
1247 # %opts supports two options at this time:
1248 #   no_phrases :
1249 #       If true, do not do anything to the phrases and unphrases
1250 #       fields on any discovered nodes.
1251 #   with_config :
1252 #       If true, also return the query parser config as part of the blob.
1253 #       This will get set back to 0 before recursion to avoid repetition.
1254 sub to_abstract_query {
1255     my $self = shift;
1256     my %opts = @_;
1257
1258     my $pkg = ref $self->QueryParser || $self->QueryParser;
1259
1260     my $abstract_query = {
1261         type => "query_plan",
1262         filters => [map { $_->to_abstract_query } @{$self->filters}],
1263         modifiers => [map { $_->to_abstract_query } @{$self->modifiers}]
1264     };
1265
1266     if ($opts{with_config}) {
1267         $opts{with_config} = 0;
1268         $abstract_query->{config} = $QueryParser::parser_config{$pkg};
1269     }
1270
1271     my $kids = [];
1272
1273     for my $qnode (@{$self->query_nodes}) {
1274         # Remember: qnode can be a joiner string, a node, or another query_plan
1275
1276         if (QueryParser::_util::is_joiner($qnode)) {
1277             if ($abstract_query->{children}) {
1278                 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1279                 next if $open_joiner eq $qnode;
1280
1281                 my $oldroot = $abstract_query->{children};
1282                 $kids = [$oldroot];
1283                 $abstract_query->{children} = {$qnode => $kids};
1284             } else {
1285                 $abstract_query->{children} = {$qnode => $kids};
1286             }
1287         } else {
1288             push @$kids, $qnode->to_abstract_query(%opts);
1289         }
1290     }
1291
1292     $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1293     return $abstract_query;
1294 }
1295
1296
1297 #-------------------------------
1298 package QueryParser::query_plan::node;
1299 use Data::Dumper;
1300 $Data::Dumper::Indent = 0;
1301
1302 sub new {
1303     my $pkg = shift;
1304     $pkg = ref($pkg) || $pkg;
1305     my %args = @_;
1306
1307     return bless \%args => $pkg;
1308 }
1309
1310 sub new_atom {
1311     my $self = shift;
1312     my $pkg = ref($self) || $self;
1313     return do{$pkg.'::atom'}->new( @_ );
1314 }
1315
1316 sub requested_class { # also split into classname, fields and alias
1317     my $self = shift;
1318     my $class = shift;
1319
1320     if ($class) {
1321         my @afields;
1322         my (undef, $alias) = split '#', $class;
1323         if ($alias) {
1324             $class =~ s/#[^|]+//;
1325             ($alias, @afields) = split '\|', $alias;
1326         }
1327
1328         my @fields = @afields;
1329         my ($class_part, @field_parts) = split '\|', $class;
1330         for my $f (@field_parts) {
1331              push(@fields, $f) unless (grep { $f eq $_ } @fields);
1332         }
1333
1334         $class_part ||= $class;
1335
1336         $self->{requested_class} = $class;
1337         $self->{alias} = $alias if $alias;
1338         $self->{alias_fields} = \@afields if $alias;
1339         $self->{classname} = $class_part;
1340         $self->{fields} = \@fields;
1341     }
1342
1343     return $self->{requested_class};
1344 }
1345
1346 sub plan {
1347     my $self = shift;
1348     my $plan = shift;
1349
1350     $self->{plan} = $plan if ($plan);
1351     return $self->{plan};
1352 }
1353
1354 sub alias {
1355     my $self = shift;
1356     my $alias = shift;
1357
1358     $self->{alias} = $alias if ($alias);
1359     return $self->{alias};
1360 }
1361
1362 sub alias_fields {
1363     my $self = shift;
1364     my $alias = shift;
1365
1366     $self->{alias_fields} = $alias if ($alias);
1367     return $self->{alias_fields};
1368 }
1369
1370 sub classname {
1371     my $self = shift;
1372     my $class = shift;
1373
1374     $self->{classname} = $class if ($class);
1375     return $self->{classname};
1376 }
1377
1378 sub fields {
1379     my $self = shift;
1380     my @fields = @_;
1381
1382     $self->{fields} ||= [];
1383     $self->{fields} = \@fields if (@fields);
1384     return $self->{fields};
1385 }
1386
1387 sub phrases {
1388     my $self = shift;
1389     my @phrases = @_;
1390
1391     $self->{phrases} ||= [];
1392     $self->{phrases} = \@phrases if (@phrases);
1393     return $self->{phrases};
1394 }
1395
1396 sub unphrases {
1397     my $self = shift;
1398     my @phrases = @_;
1399
1400     $self->{unphrases} ||= [];
1401     $self->{unphrases} = \@phrases if (@phrases);
1402     return $self->{unphrases};
1403 }
1404
1405 sub add_phrase {
1406     my $self = shift;
1407     my $phrase = shift;
1408
1409     push(@{$self->phrases}, $phrase);
1410
1411     return $self;
1412 }
1413
1414 sub add_unphrase {
1415     my $self = shift;
1416     my $phrase = shift;
1417
1418     push(@{$self->unphrases}, $phrase);
1419
1420     return $self;
1421 }
1422
1423 sub query_atoms {
1424     my $self = shift;
1425     my @query_atoms = @_;
1426
1427     $self->{query_atoms} ||= [];
1428     $self->{query_atoms} = \@query_atoms if (@query_atoms);
1429     return $self->{query_atoms};
1430 }
1431
1432 sub add_fts_atom {
1433     my $self = shift;
1434     my $atom = shift;
1435
1436     if (!ref($atom)) {
1437         my $content = $atom;
1438         my @parts = @_;
1439
1440         $atom = $self->new_atom( content => $content, @parts );
1441     }
1442
1443     push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1444     push(@{$self->query_atoms}, $atom);
1445
1446     return $self;
1447 }
1448
1449 sub add_dummy_atom {
1450     my $self = shift;
1451     my @parts = @_;
1452
1453     my $atom = $self->new_atom( @parts, dummy => 1 );
1454
1455     push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1456     push(@{$self->query_atoms}, $atom);
1457
1458     return $self;
1459 }
1460
1461 # This will find up to one occurence of @$short_list within @$long_list, and
1462 # replace it with the single atom $replacement.
1463 sub replace_phrase_in_abstract_query {
1464     my ($self, $short_list, $long_list, $replacement) = @_;
1465
1466     my $success = 0;
1467     my @already = ();
1468     my $goal = scalar @$short_list;
1469
1470     for (my $i = 0; $i < scalar (@$long_list); $i++) {
1471         my $right = $long_list->[$i];
1472
1473         if (QueryParser::_util::compare_abstract_atoms(
1474             $short_list->[scalar @already], $right
1475         )) {
1476             push @already, $i;
1477         } elsif (scalar @already) {
1478             @already = ();
1479             next;
1480         }
1481
1482         if (scalar @already == $goal) {
1483             splice @$long_list, $already[0], scalar(@already), $replacement;
1484             $success = 1;
1485             last;
1486         }
1487     }
1488
1489     return $success;
1490 }
1491
1492 sub to_abstract_query {
1493     my $self = shift;
1494     my %opts = @_;
1495
1496     my $pkg = ref $self->plan->QueryParser || $self->plan->QueryParser;
1497
1498     my $abstract_query = {
1499         "type" => "node",
1500         "alias" => $self->alias,
1501         "alias_fields" => $self->alias_fields,
1502         "class" => $self->classname,
1503         "fields" => $self->fields
1504     };
1505
1506     my $kids = [];
1507
1508     for my $qatom (@{$self->query_atoms}) {
1509         if (QueryParser::_util::is_joiner($qatom)) {
1510             if ($abstract_query->{children}) {
1511                 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1512                 next if $open_joiner eq $qatom;
1513
1514                 my $oldroot = $abstract_query->{children};
1515                 $kids = [$oldroot];
1516                 $abstract_query->{children} = {$qatom => $kids};
1517             } else {
1518                 $abstract_query->{children} = {$qatom => $kids};
1519             }
1520         } else {
1521             push @$kids, $qatom->to_abstract_query;
1522         }
1523     }
1524
1525     if ($self->{phrases} and not $opts{no_phrases}) {
1526         for my $phrase (@{$self->{phrases}}) {
1527             # Phrases appear duplication in a real QP tree, and we don't want
1528             # that duplication in our abstract query.  So for all our phrases,
1529             # break them into atoms as QP would, and remove any matching
1530             # sequences of atoms from our abstract query.
1531
1532             my $tmptree = $self->{plan}->{QueryParser}->new(query => '"'.$phrase.'"')->parse->parse_tree;
1533             if ($tmptree) {
1534                 # For a well-behaved phrase, we should now have only one node
1535                 # in the $tmptree query plan, and that node should have an
1536                 # orderly list of atoms and joiners.
1537
1538                 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
1539                     my $tmplist;
1540
1541                     eval {
1542                         $tmplist = $tmptree->{query}->[0]->to_abstract_query(
1543                             no_phrases => 1
1544                         )->{children}->{'&'}->[0]->{children}->{'&'};
1545                     };
1546                     next if $@;
1547
1548                     foreach (
1549                         QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
1550                     ) {
1551                         last if $self->replace_phrase_in_abstract_query(
1552                             $tmplist,
1553                             $_,
1554                             QueryParser::_util::fake_abstract_atom_from_phrase($phrase, undef, $pkg)
1555                         );
1556                     }
1557                 }
1558             }
1559         }
1560     }
1561
1562     # Do the same as the preceding block for unphrases (negated phrases).
1563     if ($self->{unphrases} and not $opts{no_phrases}) {
1564         for my $phrase (@{$self->{unphrases}}) {
1565             my $tmptree = $self->{plan}->{QueryParser}->new(
1566                 query => $QueryParser::parser_config{$pkg}{operators}{disallowed}.
1567                     '"' . $phrase . '"'
1568             )->parse->parse_tree;
1569
1570             if ($tmptree) {
1571                 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
1572                     my $tmplist;
1573
1574                     eval {
1575                         $tmplist = $tmptree->{query}->[0]->to_abstract_query(
1576                             no_phrases => 1
1577                         )->{children}->{'&'}->[0]->{children}->{'&'};
1578                     };
1579                     next if $@;
1580
1581                     foreach (
1582                         QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
1583                     ) {
1584                         last if $self->replace_phrase_in_abstract_query(
1585                             $tmplist,
1586                             $_,
1587                             QueryParser::_util::fake_abstract_atom_from_phrase($phrase, 1, $pkg)
1588                         );
1589                     }
1590                 }
1591             }
1592         }
1593     }
1594
1595     $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1596     return $abstract_query;
1597 }
1598
1599 #-------------------------------
1600 package QueryParser::query_plan::node::atom;
1601
1602 sub new {
1603     my $pkg = shift;
1604     $pkg = ref($pkg) || $pkg;
1605     my %args = @_;
1606
1607     return bless \%args => $pkg;
1608 }
1609
1610 sub node {
1611     my $self = shift;
1612     return undef unless (ref $self);
1613     return $self->{node};
1614 }
1615
1616 sub content {
1617     my $self = shift;
1618     return undef unless (ref $self);
1619     return $self->{content};
1620 }
1621
1622 sub prefix {
1623     my $self = shift;
1624     return undef unless (ref $self);
1625     return $self->{prefix};
1626 }
1627
1628 sub suffix {
1629     my $self = shift;
1630     return undef unless (ref $self);
1631     return $self->{suffix};
1632 }
1633
1634 sub to_abstract_query {
1635     my ($self) = @_;
1636     
1637     return {
1638         (map { $_ => $self->$_ } qw/prefix suffix content/),
1639         "type" => "atom"
1640     };
1641 }
1642 #-------------------------------
1643 package QueryParser::query_plan::filter;
1644
1645 sub new {
1646     my $pkg = shift;
1647     $pkg = ref($pkg) || $pkg;
1648     my %args = @_;
1649
1650     return bless \%args => $pkg;
1651 }
1652
1653 sub plan {
1654     my $self = shift;
1655     return $self->{plan};
1656 }
1657
1658 sub name {
1659     my $self = shift;
1660     return $self->{name};
1661 }
1662
1663 sub negate {
1664     my $self = shift;
1665     return $self->{negate};
1666 }
1667
1668 sub args {
1669     my $self = shift;
1670     return $self->{args};
1671 }
1672
1673 sub to_abstract_query {
1674     my ($self) = @_;
1675     
1676     return {
1677         map { $_ => $self->$_ } qw/name negate args/
1678     };
1679 }
1680
1681 #-------------------------------
1682 package QueryParser::query_plan::facet;
1683
1684 sub new {
1685     my $pkg = shift;
1686     $pkg = ref($pkg) || $pkg;
1687     my %args = @_;
1688
1689     return bless \%args => $pkg;
1690 }
1691
1692 sub plan {
1693     my $self = shift;
1694     return $self->{plan};
1695 }
1696
1697 sub name {
1698     my $self = shift;
1699     return $self->{name};
1700 }
1701
1702 sub negate {
1703     my $self = shift;
1704     return $self->{negate};
1705 }
1706
1707 sub values {
1708     my $self = shift;
1709     return $self->{'values'};
1710 }
1711
1712 sub to_abstract_query {
1713     my ($self) = @_;
1714
1715     return {
1716         (map { $_ => $self->$_ } qw/name negate values/),
1717         "type" => "facet"
1718     };
1719 }
1720
1721 #-------------------------------
1722 package QueryParser::query_plan::modifier;
1723
1724 sub new {
1725     my $pkg = shift;
1726     $pkg = ref($pkg) || $pkg;
1727     my $modifier = shift;
1728     my $negate = shift;
1729
1730     return bless { name => $modifier, negate => $negate } => $pkg;
1731 }
1732
1733 sub name {
1734     my $self = shift;
1735     return $self->{name};
1736 }
1737
1738 sub negate {
1739     my $self = shift;
1740     return $self->{negate};
1741 }
1742
1743 sub to_abstract_query {
1744     my ($self) = @_;
1745     
1746     return $self->name;
1747 }
1748 1;
1749