LP # 1965447: adjust scoping of item tags Angular Holdings Editor
[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
7 =head1 NAME
8
9 QueryParser - basic QueryParser class
10
11 =head1 SYNOPSIS
12
13 use QueryParser;
14 my $QParser = QueryParser->new(%args);
15
16 =head1 DESCRIPTION
17
18 Main entrypoint into the QueryParser functionality.
19
20 =head1 FUNCTIONS
21
22 =cut
23
24 # Note that the first key must match the name of the package.
25 our %parser_config = (
26     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
44 sub canonicalize {
45     my $self = shift;
46     return QueryParser::Canonicalize::abstract_query2str_impl(
47         $self->parse_tree->to_abstract_query(@_)
48     );
49 }
50
51
52 =head2 facet_class_count
53
54     $count = $QParser->facet_class_count();
55 =cut
56
57 sub facet_class_count {
58     my $self = shift;
59     return @{$self->facet_classes};
60 }
61
62 =head2 search_class_count
63
64     $count = $QParser->search_class_count();
65 =cut
66
67 sub search_class_count {
68     my $self = shift;
69     return @{$self->search_classes};
70 }
71
72 =head2 filter_count
73
74     $count = $QParser->filter_count();
75 =cut
76
77 sub filter_count {
78     my $self = shift;
79     return @{$self->filters};
80 }
81
82 =head2 modifier_count
83
84     $count = $QParser->modifier_count();
85 =cut
86
87 sub modifier_count {
88     my $self = shift;
89     return @{$self->modifiers};
90 }
91
92 =head2 custom_data
93
94     $data = $QParser->custom_data($class);
95 =cut
96
97 sub 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
107     $operators = $QParser->operators();
108
109 Returns hashref of the configured operators.
110 =cut
111
112 sub operators {
113     my $class = shift;
114     $class = ref($class) || $class;
115
116     $parser_config{$class}{operators} ||= {};
117     return $parser_config{$class}{operators};
118 }
119
120 sub 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
131     $filters = $QParser->filters();
132
133 Returns arrayref of the configured filters.
134 =cut
135
136 sub 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
146     $filter_callbacks = $QParser->filter_callbacks();
147
148 Returns hashref of the configured filter callbacks.
149 =cut
150
151 sub 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
161     $modifiers = $QParser->modifiers();
162
163 Returns arrayref of the configured modifiers.
164 =cut
165
166 sub modifiers {
167     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
176     $QParser = QueryParser->new(%args);
177
178 Creates a new QueryParser object.
179 =cut
180
181 sub 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 %{QueryParser->operators}) {
190         $class->operator($o => 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
202     $query_plan = $QParser->new_plan();
203
204 Create a new query plan.
205 =cut
206
207 sub 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
215     $QParser->add_search_filter($filter, [$callback]);
216
217 Adds a filter with the specified name and an optional callback to the
218 QueryParser configuration.
219 =cut
220
221 sub 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
235     $QParser->add_search_modifier($modifier);
236
237 Adds a modifier with the specified name to the QueryParser configuration.
238 =cut
239
240 sub 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
252     $QParser->add_facet_class($facet_class);
253
254 Adds a facet class with the specified name to the QueryParser configuration.
255 =cut
256
257 sub 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
272     $QParser->add_search_class($class);
273
274 Adds a search class with the specified name to the QueryParser configuration.
275 =cut
276
277 sub 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
293     $op = $QParser->operator($operator, [$newvalue]);
294
295 Retrieves or sets value for the specified operator. Valid operators and
296 their defaults are as follows:
297
298 =over 4
299
300 =item * and => &&
301
302 =item * or => ||
303
304 =item * group_start => (
305
306 =item * group_end => )
307
308 =item * required => +
309
310 =item * disallowed => -
311
312 =item * modifier => #
313
314 =back
315
316 =cut
317
318 sub operator {
319     my $class = shift;
320     $class = ref($class) || $class;
321     my $opname = shift;
322     my $op = shift;
323
324     return undef 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
334     $classes = $QParser->facet_classes([\@newclasses]);
335
336 Returns arrayref of all configured facet classes after optionally
337 replacing configuration.
338 =cut
339
340 sub 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
352     $classes = $QParser->search_classes([\@newclasses]);
353
354 Returns arrayref of all configured search classes after optionally
355 replacing the previous configuration.
356 =cut
357
358 sub 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
370     $function = $QParser->add_query_normalizer($class, $field, $func, [\@params]);
371
372 =cut
373
374 sub 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         OpenSRF::Utils::JSON->perl2JSON($_->{params}) eq OpenSRF::Utils::JSON->perl2JSON($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
395     $normalizers = $QParser->query_normalizers($class, $field);
396
397 Returns a list of normalizers associated with the specified search class
398 and field
399 =cut
400
401 sub 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
423     $normalizer = $QParser->add_filter_normalizer($filter, $func, [\@params]);
424
425 Adds a normalizer function to the specified filter.
426 =cut
427
428 sub 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
444     $normalizers = $QParser->filter_normalizers($filter);
445
446 Return arrayref of normalizer functions associated with the specified filter.
447 =cut
448
449 sub 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
466     $default_class = $QParser->default_search_class([$class]);
467
468 Set or return the default search class.
469 =cut
470
471 sub default_search_class {
472     my $pkg = shift;
473     $pkg = ref($pkg) || $pkg;
474     my $class = shift;
475     $QueryParser::parser_config{$pkg}{default_class} = $pkg->add_search_class( $class ) if $class;
476
477     return $QueryParser::parser_config{$pkg}{default_class};
478 }
479
480 =head2 remove_facet_class
481
482     $QParser->remove_facet_class($class);
483
484 Remove the specified facet class from the configuration.
485 =cut
486
487 sub 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 $QueryParser::parser_config{$pkg}{facet_fields}{$class};
496
497     return $class;
498 }
499
500 =head2 remove_search_class
501
502     $QParser->remove_search_class($class);
503
504 Remove the specified search class from the configuration.
505 =cut
506
507 sub 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 $QueryParser::parser_config{$pkg}{fields}{$class};
516
517     return $class;
518 }
519
520 =head2 add_facet_field
521
522     $QParser->add_facet_field($class, $field);
523
524 Adds the specified field (and facet class if it doesn't already exist)
525 to the configuration.
526 =cut
527
528 sub 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
545     $fields = $QParser->facet_fields($class);
546
547 Returns arrayref with list of fields for specified facet class.
548 =cut
549
550 sub 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
560     $QParser->add_search_field($class, $field);
561
562 Adds the specified field (and facet class if it doesn't already exist)
563 to the configuration.
564 =cut
565
566 sub 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
583     $fields = $QParser->search_fields();
584
585 Returns arrayref with list of configured search fields.
586 =cut
587
588 sub 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
598     $QParser->add_search_class_alias($class, $alias);
599 =cut
600
601 sub 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
618     $aliases = $QParser->search_class_aliases($class);
619 =cut
620
621 sub 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
631     $QParser->add_search_field_alias($class, $field, $alias);
632 =cut
633
634 sub 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
650     $aliases = $QParser->search_field_aliases();
651 =cut
652
653 sub 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
663     $QParser->remove_facet_field($class, $field);
664 =cut
665
666 sub 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
681     $QParser->remove_search_field($class, $field);
682 =cut
683
684 sub 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
699     $QParser->remove_search_field_alias($class, $field, $alias);
700 =cut
701
702 sub 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
718     $QParser->remove_search_class_alias($class, $alias);
719 =cut
720
721 sub 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
736     $debug = $QParser->debug([$debug]);
737
738 Return or set whether debugging output is enabled.
739 =cut
740
741 sub 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
750     $query = $QParser->query([$query]);
751
752 Return or set the query.
753 =cut
754
755 sub 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
764     $parse_tree = $QParser->parse_tree([$parse_tree]);
765
766 Return or set the parse tree associated with the QueryParser.
767 =cut
768
769 sub 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
776 sub 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
785     $QParser->parse([$query]);
786
787 Parse the specified query, or the query already associated with the QueryParser
788 object.
789 =cut
790
791 our $last_type = '';
792 our $last_class = '';
793 our $floating = 0;
794 our $fstart;
795 sub parse {
796     my $self = shift;
797     my $pkg = ref($self) || $self;
798     warn " ** parse package is $pkg\n" if $self->debug;
799
800     # Reset at each top-level parsing request
801     $last_class = '';
802     $last_type = '';
803     $floating = 0;
804     $fstart = undef;
805
806     $self->decompose( $self->query( shift() ) );
807
808     if ($self->floating_plan) {
809         $self->floating_plan->add_node( $self->parse_tree );
810         $self->parse_tree( $self->floating_plan );
811     }
812
813     $self->parse_tree->plan_level(0);
814
815     return $self;
816 }
817
818 =head2 decompose
819
820     ($struct, $remainder) = $QParser->decompose($querystring, [$current_class], [$recursing], [$phrase_helper]);
821
822 This routine does the heavy work of parsing the query string recursively.
823 Returns the top level query plan, or the query plan from a lower level plus
824 the portion of the query string that needs to be processed at a higher level.
825 =cut
826
827 our $_compiled_decomposer = {};
828 sub decompose {
829     my $self = shift;
830     my $pkg = ref($self) || $self;
831
832     my $r = $$_compiled_decomposer{$pkg};
833     my $compiled = defined($r);
834
835     $_ = shift;
836     my $current_class = shift || $self->default_search_class;
837
838     my $recursing = shift || 0;
839     my $phrase_helper = shift || 0;
840
841     warn '  'x$recursing." ** QP: decompose package is $pkg" if $self->debug;
842
843     if (!$compiled) {
844         $r = $$_compiled_decomposer{$pkg} = {};
845         warn '  'x$recursing." ** Compiling decomposer\n" if $self->debug;
846
847         # Build the search class+field uber-regexp
848         $$r{search_class_re} = '^\s*(';
849     } else {
850         warn '  'x$recursing." ** Decomposer already compiled\n" if $self->debug;
851     }
852
853     my $first_class = 1;
854
855     my %seen_classes;
856     for my $class ( keys %{$pkg->search_field_aliases} ) {
857         warn '  'x$recursing." *** ... Looking for search fields in $class\n" if $self->debug;
858
859         for my $field ( keys %{$pkg->search_field_aliases->{$class}} ) {
860             warn '  'x$recursing." *** ... Looking for aliases of $field\n" if $self->debug;
861
862             for my $alias ( @{$pkg->search_field_aliases->{$class}{$field}} ) {
863                 my $aliasr = qr/$alias/;
864                 s/(^|\s+)$aliasr\|/$1$class\|$field#$alias\|/g;
865                 s/(^|\s+)$aliasr[:=]/$1$class\|$field#$alias:/g;
866                 warn '  'x$recursing." *** Rewriting: $alias ($aliasr) as $class\|$field\n" if $self->debug;
867             }
868         }
869
870         if (!$compiled) {
871             $$r{search_class_re} .= '|' unless ($first_class);
872             $first_class = 0;
873             $$r{search_class_re} .= $class . '(?:[|#][^:|]+)*';
874             $seen_classes{$class} = 1;
875         }
876     }
877
878     for my $class ( keys %{$pkg->search_class_aliases} ) {
879
880         for my $alias ( @{$pkg->search_class_aliases->{$class}} ) {
881             my $aliasr = qr/$alias/;
882             s/(^|[^|])\b$aliasr\|/$1$class#$alias\|/g;
883             s/(^|[^|])\b$aliasr[:=]/$1$class#$alias:/g;
884             warn '  'x$recursing." *** Rewriting: $alias ($aliasr) as $class\n" if $self->debug;
885         }
886
887         if (!$compiled and !$seen_classes{$class}) {
888             $$r{search_class_re} .= '|' unless ($first_class);
889             $first_class = 0;
890
891             $$r{search_class_re} .= $class . '(?:[|#][^:|]+)*';
892             $seen_classes{$class} = 1;
893         }
894     }
895     $$r{search_class_re} .= '):' if (!$compiled);
896
897     warn '  'x$recursing." ** Rewritten query: $_\n" if $self->debug;
898
899     my $group_start = $pkg->operator('group_start');
900     my $group_end = $pkg->operator('group_end');
901     if (!$compiled) {
902         warn '  'x$recursing." ** Search class RE: $$r{search_class_re}\n" if $self->debug;
903
904         my $required_op = $pkg->operator('required');
905         $$r{required_re} = qr/\Q$required_op\E/;
906
907         my $disallowed_op = $pkg->operator('disallowed');
908         $$r{disallowed_re} = qr/\Q$disallowed_op\E/;
909
910         my $negated_op = $pkg->operator('negated');
911         $$r{negated_re} = qr/\Q$negated_op\E/;
912
913         my $and_op = $pkg->operator('and');
914         $$r{and_re} = qr/^\s*\Q$and_op\E/;
915
916         my $or_op = $pkg->operator('or');
917         $$r{or_re} = qr/^\s*\Q$or_op\E/;
918
919         $$r{group_start_re} = qr/^\s*($$r{negated_re}|$$r{disallowed_re})?\Q$group_start\E/;
920
921         $$r{group_end_re} = qr/^\s*\Q$group_end\E/;
922
923         my $float_start = $pkg->operator('float_start');
924         $$r{float_start_re} = qr/^\s*\Q$float_start\E/;
925
926         my $float_end = $pkg->operator('float_end');
927         $$r{float_end_re} = qr/^\s*\Q$float_end\E/;
928
929         $$r{atom_re} = qr/.+?(?=\Q$float_start\E|\Q$group_start\E|\Q$float_end\E|\Q$group_end\E|\s|"|$)/;
930
931         my $modifier_tag = $pkg->operator('modifier');
932         $$r{modifier_tag_re} = qr/^\s*\Q$modifier_tag\E/;
933
934         # Group start/end normally are ( and ), but can be overridden.
935         # We thus include ( and ) specifically due to filters, as well as : for classes.
936         $$r{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|:|\(|\))/;
937
938         # Build the filter and modifier uber-regexps
939         $$r{facet_re} = '^\s*(-?)((?:' . join( '|', @{$pkg->facet_classes}) . ')(?:\|\w+)*)\[(.+?)\](?!\[)';
940
941         $$r{filter_re} = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . ')\(([^()]+)\)';
942         $$r{filter_as_class_re} = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . '):\s*(\S+)';
943
944         $$r{modifier_re} = '^\s*'.$$r{modifier_tag_re}.'(' . join( '|', @{$pkg->modifiers}) . ')\b';
945         $$r{modifier_as_class_re} = '^\s*(' . join( '|', @{$pkg->modifiers}) . '):\s*(\S+)';
946
947     }
948
949     my $struct = shift || $self->new_plan( level => $recursing );
950     $self->parse_tree( $struct ) if (!$self->parse_tree);
951
952     my $remainder = '';
953
954     while (!$remainder) {
955         warn '  'x$recursing."Start of the loop. last_type: $last_type, joiner: ".$struct->joiner.", struct: $struct\n" if $self->debug;
956         if ($last_type eq 'FEND' and $fstart and $fstart !=  $struct) { # fall back further
957             $remainder = $_;
958             last;
959         } elsif ($last_type eq 'FEND') {
960             $fstart = undef;
961             $last_type = '';
962         }
963
964         if (/^\s*$/) { # end of an explicit group
965             $last_type = '';
966             last;
967         } elsif (/$$r{float_end_re}/) { # end of an explicit group
968             warn '  'x$recursing."Encountered explicit float end, remainder: $'\n" if $self->debug;
969
970             $remainder = $';
971             $_ = '';
972
973             $floating = 0;
974             $last_type = 'FEND';
975             last;
976         } elsif (/$$r{group_end_re}/) { # end of an explicit group
977             warn '  'x$recursing."Encountered explicit group end, remainder: $'\n" if $self->debug;
978
979             $remainder = $';
980             $_ = '';
981
982             $last_type = '';
983         } elsif ($self->filter_count && /$$r{filter_re}/) { # found a filter
984             warn '  'x$recursing."Encountered search filter: $1$2 set to $3\n" if $self->debug;
985
986             my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
987             $_ = $';
988
989             my $filter = $2;
990             my $params = [ split '[,]+', $3 ];
991
992             if ($pkg->filter_callbacks->{$filter}) {
993                 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
994                 $_ = "$replacement $_" if ($replacement);
995             } else {
996                 $struct->new_filter( $filter => $params, $negate );
997             }
998
999
1000             $last_type = '';
1001         } elsif ($self->filter_count && /$$r{filter_as_class_re}/) { # found a filter
1002             warn '  'x$recursing."Encountered search filter: $1$2 set to $3\n" if $self->debug;
1003
1004             my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
1005             $_ = $';
1006
1007             my $filter = $2;
1008             my $params = [ split '[,]+', $3 ];
1009
1010             if ($pkg->filter_callbacks->{$filter}) {
1011                 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
1012                 $_ = "$replacement $_" if ($replacement);
1013             } else {
1014                 $struct->new_filter( $filter => $params, $negate );
1015             }
1016
1017             $last_type = '';
1018         } elsif ($self->modifier_count && /$$r{modifier_re}/) { # found a modifier
1019             warn '  'x$recursing."Encountered search modifier: $1\n" if $self->debug;
1020
1021             $_ = $';
1022             if (!($struct->top_plan || $parser_config{$pkg}->{allow_nested_modifiers})) {
1023                 warn '  'x$recursing."  Search modifiers only allowed at the top level of the query\n" if $self->debug;
1024             } else {
1025                 $struct->new_modifier($1);
1026             }
1027
1028             $last_type = '';
1029         } elsif ($self->modifier_count && /$$r{modifier_as_class_re}/) { # found a modifier
1030             warn '  'x$recursing."Encountered search modifier: $1\n" if $self->debug;
1031
1032             my $mod = $1;
1033
1034             $_ = $';
1035             if (!($struct->top_plan || $parser_config{$pkg}->{allow_nested_modifiers})) {
1036                 warn '  'x$recursing."  Search modifiers only allowed at the top level of the query\n" if $self->debug;
1037             } elsif ($2 =~ /^[ty1]/i) {
1038                 $struct->new_modifier($mod);
1039             }
1040
1041             $last_type = '';
1042         } elsif (/$$r{float_start_re}/) { # start of an explicit float
1043             warn '  'x$recursing."Encountered explicit float start\n" if $self->debug;
1044             $floating = 1;
1045             $fstart = $struct;
1046
1047             $last_class = $current_class;
1048             $current_class = undef;
1049
1050             $self->floating_plan( $self->new_plan( floating => 1 ) ) if (!$self->floating_plan);
1051
1052             # pass the floating_plan struct to be modified by the float'ed chunk
1053             my ($floating_plan, $subremainder) = $self->new( debug => $self->debug )->decompose( $', undef, undef, undef,  $self->floating_plan);
1054             $_ = $subremainder;
1055             warn '  'x$recursing."Remainder after explicit float: $_\n" if $self->debug;
1056
1057             $current_class = $last_class;
1058
1059             $last_type = '';
1060         } elsif (/$$r{group_start_re}/) { # start of an explicit group
1061             warn '  'x$recursing."Encountered explicit group start\n" if $self->debug;
1062             my $negate = $1;
1063             my ($substruct, $subremainder) = $self->decompose( $', $current_class, $recursing + 1 );
1064             $substruct->negate(1) if ($substruct && $negate);
1065             $struct->add_node( $substruct ) if ($substruct);
1066             $_ = $subremainder;
1067             warn '  'x$recursing."Query remainder after bool group: $_\n" if $self->debug;
1068
1069             $last_type = '';
1070
1071         } elsif (/$$r{and_re}/) { # ANDed expression
1072             $_ = $';
1073             warn '  'x$recursing."Encountered AND\n" if $self->debug;
1074             do {warn '  'x$recursing."!!! Already doing the bool dance for AND\n" if $self->debug; next} if ($last_type eq 'AND');
1075             do {warn '  'x$recursing."!!! Already doing the bool dance for OR\n" if $self->debug; next} if ($last_type eq 'OR');
1076             $last_type = 'AND';
1077
1078             warn '  'x$recursing."Saving LHS, building RHS\n" if $self->debug;
1079             my $LHS = $struct;
1080             #my ($RHS, $subremainder) = $self->decompose( "$group_start $_ $group_end", $current_class, $recursing + 1 );
1081             my ($RHS, $subremainder) = $self->decompose( $_, $current_class, $recursing + 1 );
1082             $_ = $subremainder;
1083
1084             warn '  'x$recursing."RHS built\n" if $self->debug;
1085             warn '  'x$recursing."Post-AND remainder: $subremainder\n" if $self->debug;
1086
1087             my $wrapper = $self->new_plan( level => $recursing + 1 );
1088
1089             if ($LHS->floating) {
1090                 $wrapper->{query} = $LHS->{query};
1091                 my $outer_wrapper = $self->new_plan( level => $recursing + 1 );
1092                 $outer_wrapper->add_node($_) for ($wrapper,$RHS);
1093                 $LHS->{query} = [$outer_wrapper];
1094                 $struct = $LHS;
1095             } else {
1096                 $wrapper->add_node($_) for ($LHS, $RHS);
1097                 $wrapper->plan_level($wrapper->plan_level); # reset levels all the way down
1098                 $struct = $self->new_plan( level => $recursing );
1099                 $struct->add_node($wrapper);
1100             }
1101
1102             $self->parse_tree( $struct ) if ($self->parse_tree == $LHS);
1103
1104             $last_type = '';
1105         } elsif (/$$r{or_re}/) { # ORed expression
1106             $_ = $';
1107             warn '  'x$recursing."Encountered OR\n" if $self->debug;
1108             do {warn '  'x$recursing."!!! Already doing the bool dance for AND\n" if $self->debug; next} if ($last_type eq 'AND');
1109             do {warn '  'x$recursing."!!! Already doing the bool dance for OR\n" if $self->debug; next} if ($last_type eq 'OR');
1110             $last_type = 'OR';
1111
1112             warn '  'x$recursing."Saving LHS, building RHS\n" if $self->debug;
1113             my $LHS = $struct;
1114             #my ($RHS, $subremainder) = $self->decompose( "$group_start $_ $group_end", $current_class, $recursing + 1 );
1115             my ($RHS, $subremainder) = $self->decompose( $_, $current_class, $recursing + 2 );
1116             $_ = $subremainder;
1117
1118             warn '  'x$recursing."RHS built\n" if $self->debug;
1119             warn '  'x$recursing."Post-OR remainder: $subremainder\n" if $self->debug;
1120
1121             my $wrapper = $self->new_plan( level => $recursing + 1, joiner => '|' );
1122
1123             if ($LHS->floating) {
1124                 $wrapper->{query} = $LHS->{query};
1125                 my $outer_wrapper = $self->new_plan( level => $recursing + 1, joiner => '|' );
1126                 $outer_wrapper->add_node($_) for ($wrapper,$RHS);
1127                 $LHS->{query} = [$outer_wrapper];
1128                 $struct = $LHS;
1129             } else {
1130                 $wrapper->add_node($_) for ($LHS, $RHS);
1131                 $wrapper->plan_level($wrapper->plan_level); # reset levels all the way down
1132                 $struct = $self->new_plan( level => $recursing );
1133                 $struct->add_node($wrapper);
1134             }
1135
1136             $self->parse_tree( $struct ) if ($self->parse_tree == $LHS);
1137
1138             $last_type = '';
1139         } elsif ($self->facet_class_count && /$$r{facet_re}/) { # changing current class
1140             warn '  'x$recursing."Encountered facet: $1$2 => $3\n" if $self->debug;
1141
1142             my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
1143             my $facet = $2;
1144             my $facet_value = [ split '\s*\]\[\s*', $3 ];
1145             $struct->new_facet( $facet => $facet_value, $negate );
1146             $_ = $';
1147
1148             $last_type = '';
1149         } elsif ($self->search_class_count && /$$r{search_class_re}/) { # changing current class
1150
1151             if ($last_type eq 'CLASS') {
1152                 $struct->remove_last_node( $current_class );
1153                 warn '  'x$recursing."Encountered class change with no searches!\n" if $self->debug;
1154             }
1155
1156             warn '  'x$recursing."Encountered class change: $1\n" if $self->debug;
1157
1158             $current_class = $struct->classed_node( $1 )->requested_class();
1159             $_ = $';
1160
1161             $last_type = 'CLASS';
1162         } elsif (/^\s*($$r{required_re}|$$r{disallowed_re}|$$r{negated_re})?"([^"]+)"/) { # phrase, always anded
1163             warn '  'x$recursing.'Encountered' . ($1 ? " ['$1' modified]" : '') . " phrase: $2\n" if $self->debug;
1164
1165             my $req_ness = $1 || '';
1166             $req_ness = $pkg->operator('disallowed') if ($req_ness eq $pkg->operator('negated'));
1167             my $phrase = $2;
1168
1169             if (!$phrase_helper) {
1170                 warn '  'x$recursing."Recursing into decompose with the phrase as a subquery\n" if $self->debug;
1171                 my $after = $';
1172                 my ($substruct, $subremainder) = $self->decompose( qq/$req_ness"$phrase"/, $current_class, $recursing + 1, 1 );
1173                 $struct->add_node( $substruct ) if ($substruct);
1174                 $_ = $after;
1175             } else {
1176                 warn '  'x$recursing."Directly parsing the phrase [ $phrase ] subquery\n" if $self->debug;
1177                 $struct->joiner( '&' );
1178
1179                 my $class_node = $struct->classed_node($current_class);
1180
1181                 if ($req_ness eq $pkg->operator('disallowed')) {
1182                     $class_node->negate(1);
1183                 }
1184                 $class_node->add_phrase( $phrase );
1185
1186                 # Save $' before we clean up $phrase
1187                 my $temp_val = $';
1188
1189                 # Cleanup the phrase to make it so that we don't parse things in it as anything other than atoms
1190                 $phrase =~ s/$$r{phrase_cleanup_re}/ /g;
1191
1192                 $_ = $phrase . $temp_val;
1193
1194             }
1195
1196             $last_type = '';
1197
1198         } elsif (/^\s*($$r{required_re}|$$r{disallowed_re})($$r{atom_re})/) { # convert require/disallow word to {un}phrase
1199             warn '  'x$recursing."Encountered required atom (mini phrase), transforming for phrase parse: $1\n" if $self->debug;
1200
1201             $_ = $1 . '"' . $2 . '"' . $';
1202
1203             $last_type = '';
1204         } elsif (/^\s*($$r{atom_re})/) { # atom
1205             warn '  'x$recursing."Encountered atom: $1\n" if $self->debug;
1206             warn '  'x$recursing."Remainder: $'\n" if $self->debug;
1207
1208             my $atom = $1;
1209             my $after = $';
1210
1211             $_ = $after;
1212             $last_type = '';
1213
1214             my $class_node = $struct->classed_node($current_class);
1215
1216             my $prefix = ($atom =~ s/^$$r{negated_re}//o) ? '!' : '';
1217             my $truncate = ($atom =~ s/\*$//o) ? '*' : '';
1218
1219             if ($atom ne '' and !grep { $atom =~ /^\Q$_\E+$/ } ('&','|')) { # throw away & and |, not allowed in tsquery, and not really useful anyway
1220 #                $class_node->add_phrase( $atom ) if ($atom =~ s/^$$r{required_re}//o);
1221
1222                 $class_node->add_fts_atom( $atom, suffix => $truncate, prefix => $prefix, node => $class_node );
1223                 $struct->joiner( '&' );
1224             }
1225
1226             $last_type = '';
1227         } else {
1228             warn '  'x$recursing."Cannot parse: $_\n" if $self->debug;
1229             $_ = '';
1230         }
1231
1232         last unless ($_);
1233
1234     }
1235
1236     $struct = undef if 
1237         scalar(@{$struct->query_nodes}) == 0 &&
1238         scalar(@{$struct->filters}) == 0 &&
1239         !$struct->top_plan;
1240
1241     return $struct if !wantarray;
1242     return ($struct, $remainder);
1243 }
1244
1245 =head2 find_class_index
1246
1247     $index = $QParser->find_class_index($class, $query);
1248 =cut
1249
1250 sub find_class_index {
1251     my $class = shift;
1252     my $query = shift;
1253
1254     my ($class_part, @field_parts) = split '\|', $class;
1255     $class_part ||= $class;
1256
1257     for my $idx ( 0 .. scalar(@$query) - 1 ) {
1258         next unless ref($$query[$idx]);
1259         return $idx if ( $$query[$idx]{requested_class} && $class eq $$query[$idx]{requested_class} );
1260     }
1261
1262     push(@$query, { classname => $class_part, (@field_parts ? (fields => \@field_parts) : ()), requested_class => $class, ftsquery => [], phrases => [] });
1263     return -1;
1264 }
1265
1266 =head2 core_limit
1267
1268     $limit = $QParser->core_limit([$limit]);
1269
1270 Return and/or set the core_limit.
1271 =cut
1272
1273 sub core_limit {
1274     my $self = shift;
1275     my $l = shift;
1276     $self->{core_limit} = $l if ($l);
1277     return $self->{core_limit};
1278 }
1279
1280 =head2 superpage
1281
1282     $superpage = $QParser->superpage([$superpage]);
1283
1284 Return and/or set the superpage.
1285 =cut
1286
1287 sub superpage {
1288     my $self = shift;
1289     my $l = shift;
1290     $self->{superpage} = $l if ($l);
1291     return $self->{superpage};
1292 }
1293
1294 =head2 superpage_size
1295
1296     $size = $QParser->superpage_size([$size]);
1297
1298 Return and/or set the superpage size.
1299 =cut
1300
1301 sub superpage_size {
1302     my $self = shift;
1303     my $l = shift;
1304     $self->{superpage_size} = $l if ($l);
1305     return $self->{superpage_size};
1306 }
1307
1308
1309 #-------------------------------
1310 package QueryParser::_util;
1311
1312 # At this level, joiners are always & or |.  This is not
1313 # the external, configurable representation of joiners that
1314 # defaults to # && and ||.
1315 sub is_joiner {
1316     my $str = shift;
1317
1318     return (not ref $str and ($str eq '&' or $str eq '|'));
1319 }
1320
1321 sub default_joiner { '&' }
1322
1323 # 0 for different, 1 for the same.
1324 sub compare_abstract_atoms {
1325     my ($left, $right) = @_;
1326
1327     foreach (qw/prefix suffix content/) {
1328         no warnings;    # undef can stand in for '' here
1329         return 0 unless $left->{$_} eq $right->{$_};
1330     }
1331
1332     return 1;
1333 }
1334
1335 sub fake_abstract_atom_from_phrase {
1336     my $phrase = shift;
1337     my $neg = shift;
1338     my $qp_class = shift || 'QueryParser';
1339
1340     my $prefix = '"';
1341     if ($neg) {
1342         $prefix =
1343             $QueryParser::parser_config{$qp_class}{operators}{disallowed} .
1344             $prefix;
1345     }
1346
1347     return {
1348         "type" => "atom", "prefix" => $prefix, "suffix" => '"',
1349         "content" => $phrase
1350     }
1351 }
1352
1353 sub find_arrays_in_abstract {
1354     my ($hash) = @_;
1355
1356     my @arrays;
1357     foreach my $key (keys %$hash) {
1358         if (ref $hash->{$key} eq "ARRAY") {
1359             push @arrays, $hash->{$key};
1360             foreach (@{$hash->{$key}}) {
1361                 push @arrays, find_arrays_in_abstract($_);
1362             }
1363         }
1364     }
1365
1366     return @arrays;
1367 }
1368
1369 #-------------------------------
1370 package QueryParser::Canonicalize;  # not OO
1371 use Data::Dumper;
1372
1373 sub _abstract_query2str_filter {
1374     my $f = shift;
1375     my $qp_class = shift || 'QueryParser';
1376     my $qpconfig = $QueryParser::parser_config{$qp_class};
1377
1378     return sprintf(
1379         '%s%s(%s)',
1380         $f->{negate} ? $qpconfig->{operators}{disallowed} : "",
1381         $f->{name},
1382         join(",", @{$f->{args}})
1383     );
1384 }
1385
1386 sub _abstract_query2str_modifier {
1387     my $f = shift;
1388     my $qp_class = shift || 'QueryParser';
1389     my $qpconfig = $QueryParser::parser_config{$qp_class};
1390
1391     return $qpconfig->{operators}{modifier} . $f;
1392 }
1393
1394 sub _kid_list {
1395     my $children = shift;
1396     my $op = (keys %$children)[0];
1397     return @{$$children{$op}};
1398 }
1399
1400
1401 # This should produce an equivalent query to the original, given an
1402 # abstract_query.
1403 sub abstract_query2str_impl {
1404     my $abstract_query  = shift;
1405     my $depth = shift || 0;
1406
1407     my $qp_class ||= shift || 'QueryParser';
1408     my $force_qp_node = shift || 0;
1409     my $qpconfig = $QueryParser::parser_config{$qp_class};
1410
1411     my $fs = $qpconfig->{operators}{float_start};
1412     my $fe = $qpconfig->{operators}{float_end};
1413     my $gs = $qpconfig->{operators}{group_start};
1414     my $ge = $qpconfig->{operators}{group_end};
1415     my $and = $qpconfig->{operators}{and};
1416     my $or = $qpconfig->{operators}{or};
1417     my $ng = $qpconfig->{operators}{negated};
1418
1419     my $isnode = 0;
1420     my $negate = '';
1421     my $size = 0;
1422     my $q = "";
1423
1424     if (exists $abstract_query->{type}) {
1425         if ($abstract_query->{type} eq 'query_plan') {
1426             $q .= join(" ", map { _abstract_query2str_filter($_, $qp_class) } @{$abstract_query->{filters}}) if
1427                 exists $abstract_query->{filters};
1428
1429             $q .= ($q ? ' ' : '') . join(" ", map { _abstract_query2str_modifier($_, $qp_class) } @{$abstract_query->{modifiers}}) if
1430                 exists $abstract_query->{modifiers};
1431
1432             $size = _kid_list($abstract_query->{children});
1433             if ($abstract_query->{negate}) {
1434                 $isnode = 1;
1435                 $negate = $ng;
1436             }
1437             $isnode = 1 if ($size > 1 and ($force_qp_node or $depth));
1438             #warn "size: $size, depth: $depth, isnode: $isnode, AQ: ".Dumper($abstract_query);
1439         } elsif ($abstract_query->{type} eq 'node') {
1440             if ($abstract_query->{alias}) {
1441                 $q .= ($q ? ' ' : '') . $abstract_query->{alias};
1442                 $q .= "|$_" foreach @{$abstract_query->{alias_fields}};
1443             } else {
1444                 $q .= ($q ? ' ' : '') . $abstract_query->{class};
1445                 $q .= "|$_" foreach @{$abstract_query->{fields}};
1446             }
1447             $q .= ":";
1448             $isnode = 1;
1449         } elsif ($abstract_query->{type} eq 'atom') {
1450             my $prefix = $abstract_query->{prefix} || '';
1451             $prefix = $qpconfig->{operators}{negated} if $prefix eq '!';
1452             $q .= ($q ? ' ' : '') . $prefix .
1453                 ($abstract_query->{content} || '') .
1454                 ($abstract_query->{suffix} || '');
1455         } elsif ($abstract_query->{type} eq 'facet') {
1456             # facet syntax [ # ] is hardcoded I guess?
1457             my $prefix = $abstract_query->{negate} ? $qpconfig->{operators}{disallowed} : '';
1458             $q .= ($q ? ' ' : '') . $prefix . $abstract_query->{name} . "[" .
1459                 join(" # ", @{$abstract_query->{values}}) . "]";
1460         }
1461     }
1462
1463     my $next_depth = int($size > 1);
1464
1465     if (exists $abstract_query->{children}) {
1466
1467         my $op = (keys(%{$abstract_query->{children}}))[0];
1468
1469         if ($abstract_query->{floating}) { # always the top node!
1470             my $sub_node = pop @{$abstract_query->{children}{$op}};
1471
1472             $abstract_query->{floating} = 0;
1473             $q = $fs . " " . abstract_query2str_impl($abstract_query,0,$qp_class, 1) . $fe. " ";
1474
1475             $abstract_query = $sub_node;
1476         }
1477
1478         if ($abstract_query && exists $abstract_query->{children}) {
1479             $op = (keys(%{$abstract_query->{children}}))[0];
1480             $q .= ($q ? ' ' : '') . join(
1481                 ($op eq '&' ? ' ' : " $or "),
1482                 map {
1483                     my $x = abstract_query2str_impl($_, $depth + $next_depth, $qp_class, $force_qp_node); $x =~ s/^\s+//; $x =~ s/\s+$//; $x;
1484                 } @{$abstract_query->{children}{$op}}
1485             );
1486         }
1487     } elsif ($abstract_query->{'&'} or $abstract_query->{'|'}) {
1488         my $op = (keys(%{$abstract_query}))[0];
1489         $q .= ($q ? ' ' : '') . join(
1490             ($op eq '&' ? ' ' : " $or "),
1491             map {
1492                     my $x = abstract_query2str_impl($_, $depth + $next_depth, $qp_class, $force_qp_node); $x =~ s/^\s+//; $x =~ s/\s+$//; $x;
1493             } @{$abstract_query->{$op}}
1494         );
1495     }
1496
1497     $q = "$gs$q$ge" if ($isnode);
1498     $q = $negate . $q if ($q);;
1499
1500     return $q;
1501 }
1502
1503 #-------------------------------
1504 package QueryParser::query_plan;
1505
1506 sub QueryParser {
1507     my $self = shift;
1508     return undef unless ref($self);
1509     return $self->{QueryParser};
1510 }
1511
1512 sub new {
1513     my $pkg = shift;
1514     $pkg = ref($pkg) || $pkg;
1515     my %args = (query => [], joiner => '&', @_);
1516
1517     return bless \%args => $pkg;
1518 }
1519
1520 sub new_node {
1521     my $self = shift;
1522     my $pkg = ref($self) || $self;
1523     my $node = do{$pkg.'::node'}->new( plan => $self, @_ );
1524     $self->add_node( $node );
1525     return $node;
1526 }
1527
1528 sub new_facet {
1529     my $self = shift;
1530     my $pkg = ref($self) || $self;
1531     my $name = shift;
1532     my $args = shift;
1533     my $negate = shift;
1534
1535     my $node = do{$pkg.'::facet'}->new( plan => $self, name => $name, 'values' => $args, negate => $negate );
1536     $self->add_node( $node );
1537
1538     return $node;
1539 }
1540
1541 sub new_filter {
1542     my $self = shift;
1543     my $pkg = ref($self) || $self;
1544     my $name = shift;
1545     my $args = shift;
1546     my $negate = shift;
1547
1548     my $node = do{$pkg.'::filter'}->new( plan => $self, name => $name, args => $args, negate => $negate );
1549     $self->add_filter( $node );
1550
1551     return $node;
1552 }
1553
1554
1555 sub _merge_filters {
1556     my $left_filter = shift;
1557     my $right_filter = shift;
1558     my $join = shift;
1559
1560     return undef unless $left_filter or $right_filter;
1561     return $right_filter unless $left_filter;
1562     return $left_filter unless $right_filter;
1563
1564     my $args = $left_filter->{args} || [];
1565
1566     if ($join eq '|') {
1567         push(@$args, @{$right_filter->{args}});
1568
1569     } else {
1570         # find the intersect values
1571         my %new_vals;
1572         map { $new_vals{$_} = 1 } @{$right_filter->{args} || []};
1573         $args = [ grep { $new_vals{$_} } @$args ];
1574     }
1575
1576     $left_filter->{args} = $args;
1577     return $left_filter;
1578 }
1579
1580 sub collapse_filters {
1581     my $self = shift;
1582     my $name = shift;
1583
1584     # start by merging any filters at this level.
1585     # like-level filters are always ORed together
1586
1587     my $cur_filter;
1588     my @cur_filters = grep {$_->name eq $name } @{ $self->filters };
1589     if (@cur_filters) {
1590         $cur_filter = shift @cur_filters;
1591         my $args = $cur_filter->{args} || [];
1592         $cur_filter = _merge_filters($cur_filter, $_, '|') for @cur_filters;
1593     }
1594
1595     # next gather the collapsed filters from sub-plans and 
1596     # merge them with our own
1597
1598     my @subquery = @{$self->{query}};
1599
1600     while (@subquery) {
1601         my $blob = shift @subquery;
1602         shift @subquery; # joiner
1603         next unless $blob->isa('QueryParser::query_plan');
1604         my $sub_filter = $blob->collapse_filters($name);
1605         $cur_filter = _merge_filters($cur_filter, $sub_filter, $self->joiner);
1606     }
1607
1608     if ($self->QueryParser->debug) {
1609         my @args = ($cur_filter and $cur_filter->{args}) ? @{$cur_filter->{args}} : ();
1610         warn "collapse_filters($name) => [@args]\n";
1611     }
1612
1613     return $cur_filter;
1614 }
1615
1616 sub find_filter {
1617     my $self = shift;
1618     my $needle = shift;;
1619     return undef unless ($needle);
1620
1621     my $filter = $self->collapse_filters($needle);
1622
1623     warn "find_filter($needle) => " . 
1624         (($filter and $filter->{args}) ? "@{$filter->{args}}" : '[]') . "\n" 
1625         if $self->QueryParser->debug;
1626
1627     return $filter ? ($filter) : ();
1628 }
1629
1630 sub find_modifier {
1631     my $self = shift;
1632     my $needle = shift;;
1633     return undef unless ($needle);
1634     return grep { $_->name eq $needle } @{ $self->modifiers };
1635 }
1636
1637 sub new_modifier {
1638     my $self = shift;
1639     my $pkg = ref($self) || $self;
1640     my $name = shift;
1641
1642     my $node = do{$pkg.'::modifier'}->new( $name );
1643     $self->add_modifier( $node );
1644
1645     return $node;
1646 }
1647
1648 sub classed_node {
1649     my $self = shift;
1650     my $requested_class = shift;
1651
1652     my $node;
1653     for my $n (@{$self->{query}}) {
1654         next unless (ref($n) && $n->isa( 'QueryParser::query_plan::node' ));
1655         if ($n->requested_class eq $requested_class) {
1656             $node = $n;
1657             last;
1658         }
1659     }
1660
1661     if (!$node) {
1662         $node = $self->new_node;
1663         $node->requested_class( $requested_class );
1664     }
1665
1666     return $node;
1667 }
1668
1669 sub remove_last_node {
1670     my $self = shift;
1671     my $requested_class = shift;
1672
1673     my $old = pop(@{$self->query_nodes});
1674     pop(@{$self->query_nodes}) if (@{$self->query_nodes});
1675
1676     return $old;
1677 }
1678
1679 sub query_nodes {
1680     my $self = shift;
1681     return $self->{query};
1682 }
1683
1684 sub floating {
1685     my $self = shift;
1686     my $f = shift;
1687     $self->{floating} = $f if (defined $f);
1688     return $self->{floating};
1689 }
1690
1691 sub add_node {
1692     my $self = shift;
1693     my $node = shift;
1694
1695     $self->{query} ||= [];
1696     if ($node) {
1697         push(@{$self->{query}}, $self->joiner) if (@{$self->{query}});
1698         push(@{$self->{query}}, $node);
1699     }
1700
1701     return $self;
1702 }
1703
1704 sub top_plan {
1705     my $self = shift;
1706
1707     return $self->{level} ? 0 : 1;
1708 }
1709
1710 sub plan_level {
1711     my $self = shift;
1712     my $level = shift;
1713
1714     if (defined $level) {
1715         $self->{level} = $level;
1716         for (@{$self->query_nodes}) {
1717             $_->plan_level($level + 1) if (ref and $_->isa('QueryParser::query_plan'));
1718         }
1719     }
1720             
1721     return $self->{level};
1722 }
1723
1724 sub joiner {
1725     my $self = shift;
1726     my $joiner = shift;
1727
1728     $self->{joiner} = $joiner if ($joiner);
1729     return $self->{joiner};
1730 }
1731
1732 sub modifiers {
1733     my $self = shift;
1734     $self->{modifiers} ||= [];
1735     return $self->{modifiers};
1736 }
1737
1738 sub add_modifier {
1739     my $self = shift;
1740     my $modifier = shift;
1741
1742     $self->{modifiers} ||= [];
1743     $self->{modifiers} = [ grep {$_->name ne $modifier->name} @{$self->{modifiers}} ];
1744
1745     push(@{$self->{modifiers}}, $modifier);
1746
1747     return $self;
1748 }
1749
1750 sub facets {
1751     my $self = shift;
1752     $self->{facets} ||= [];
1753     return $self->{facets};
1754 }
1755
1756 sub add_facet {
1757     my $self = shift;
1758     my $facet = shift;
1759
1760     $self->{facets} ||= [];
1761     $self->{facets} = [ grep {$_->name ne $facet->name} @{$self->{facets}} ];
1762
1763     push(@{$self->{facets}}, $facet);
1764
1765     return $self;
1766 }
1767
1768 sub filters {
1769     my $self = shift;
1770     $self->{filters} ||= [];
1771     return $self->{filters};
1772 }
1773
1774 sub add_filter {
1775     my $self = shift;
1776     my $filter = shift;
1777
1778     $self->{filters} ||= [];
1779
1780     push(@{$self->{filters}}, $filter);
1781
1782     return $self;
1783 }
1784
1785 sub negate {
1786     my $self = shift;
1787     my $negate = shift;
1788
1789     $self->{negate} = $negate if (defined $negate);
1790
1791     return $self->{negate};
1792 }
1793
1794 # %opts supports two options at this time:
1795 #   no_phrases :
1796 #       If true, do not do anything to the phrases
1797 #       fields on any discovered nodes.
1798 #   with_config :
1799 #       If true, also return the query parser config as part of the blob.
1800 #       This will get set back to 0 before recursion to avoid repetition.
1801 sub to_abstract_query {
1802     my $self = shift;
1803     my %opts = @_;
1804
1805     my $pkg = ref $self->QueryParser || $self->QueryParser;
1806
1807     my $abstract_query = {
1808         type => "query_plan",
1809         floating => $self->floating,
1810         level => $self->plan_level,
1811         filters => [map { $_->to_abstract_query } @{$self->filters}],
1812         modifiers => [map { $_->to_abstract_query } @{$self->modifiers}],
1813         negate => $self->negate
1814     };
1815
1816     if ($opts{with_config}) {
1817         $opts{with_config} = 0;
1818         $abstract_query->{config} = $QueryParser::parser_config{$pkg};
1819     }
1820
1821     my $kids = [];
1822
1823     for my $qnode (@{$self->query_nodes}) {
1824         # Remember: qnode can be a joiner string, a node, or another query_plan
1825
1826         if (QueryParser::_util::is_joiner($qnode)) {
1827             if ($abstract_query->{children}) {
1828                 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1829                 next if $open_joiner eq $qnode;
1830
1831                 my $oldroot = $abstract_query->{children};
1832                 $kids = [$oldroot];
1833                 $abstract_query->{children} = {$qnode => $kids};
1834             } else {
1835                 $abstract_query->{children} = {$qnode => $kids};
1836             }
1837         } else {
1838             push @$kids, $qnode->to_abstract_query(%opts);
1839         }
1840     }
1841
1842     $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1843     return $abstract_query;
1844 }
1845
1846
1847 #-------------------------------
1848 package QueryParser::query_plan::node;
1849 use Data::Dumper;
1850 $Data::Dumper::Indent = 0;
1851
1852 sub new {
1853     my $pkg = shift;
1854     $pkg = ref($pkg) || $pkg;
1855     my %args = @_;
1856
1857     return bless \%args => $pkg;
1858 }
1859
1860 sub new_atom {
1861     my $self = shift;
1862     my $pkg = ref($self) || $self;
1863     return do{$pkg.'::atom'}->new( @_ );
1864 }
1865
1866 sub requested_class { # also split into classname, fields and alias
1867     my $self = shift;
1868     my $class = shift;
1869
1870     if ($class) {
1871         my @afields;
1872         my (undef, $alias) = split '#', $class;
1873         if ($alias) {
1874             $class =~ s/#[^|]+//;
1875             ($alias, @afields) = split '\|', $alias;
1876         }
1877
1878         my @fields = @afields;
1879         my ($class_part, @field_parts) = split '\|', $class;
1880         for my $f (@field_parts) {
1881              push(@fields, $f) unless (grep { $f eq $_ } @fields);
1882         }
1883
1884         $class_part ||= $class;
1885
1886         $self->{requested_class} = $class;
1887         $self->{alias} = $alias if $alias;
1888         $self->{alias_fields} = \@afields if $alias;
1889         $self->{classname} = $class_part;
1890         $self->{fields} = \@fields;
1891     }
1892
1893     return $self->{requested_class};
1894 }
1895
1896 sub plan {
1897     my $self = shift;
1898     my $plan = shift;
1899
1900     $self->{plan} = $plan if ($plan);
1901     return $self->{plan};
1902 }
1903
1904 sub alias {
1905     my $self = shift;
1906     my $alias = shift;
1907
1908     $self->{alias} = $alias if ($alias);
1909     return $self->{alias};
1910 }
1911
1912 sub alias_fields {
1913     my $self = shift;
1914     my $alias = shift;
1915
1916     $self->{alias_fields} = $alias if ($alias);
1917     return $self->{alias_fields};
1918 }
1919
1920 sub classname {
1921     my $self = shift;
1922     my $class = shift;
1923
1924     $self->{classname} = $class if ($class);
1925     return $self->{classname};
1926 }
1927
1928 sub fields {
1929     my $self = shift;
1930     my @fields = @_;
1931
1932     $self->{fields} ||= [];
1933     $self->{fields} = \@fields if (@fields);
1934     return $self->{fields};
1935 }
1936
1937 sub phrases {
1938     my $self = shift;
1939     my @phrases = @_;
1940
1941     $self->{phrases} ||= [];
1942     $self->{phrases} = \@phrases if (@phrases);
1943     return $self->{phrases};
1944 }
1945
1946 sub add_phrase {
1947     my $self = shift;
1948     my $phrase = shift;
1949
1950     push(@{$self->phrases}, $phrase);
1951
1952     return $self;
1953 }
1954
1955 sub negate {
1956     my $self = shift;
1957     my $negate = shift;
1958
1959     $self->{negate} = $negate if (defined $negate);
1960
1961     return $self->{negate};
1962 }
1963
1964 sub query_atoms {
1965     my $self = shift;
1966     my @query_atoms = @_;
1967
1968     $self->{query_atoms} ||= [];
1969     $self->{query_atoms} = \@query_atoms if (@query_atoms);
1970     return $self->{query_atoms};
1971 }
1972
1973 sub add_fts_atom {
1974     my $self = shift;
1975     my $atom = shift;
1976
1977     if (!ref($atom)) {
1978         my $content = $atom;
1979         my @parts = @_;
1980
1981         $atom = $self->new_atom( content => $content, @parts );
1982     }
1983
1984     push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1985     push(@{$self->query_atoms}, $atom);
1986
1987     return $self;
1988 }
1989
1990 sub add_dummy_atom {
1991     my $self = shift;
1992     my @parts = @_;
1993
1994     my $atom = $self->new_atom( @parts, dummy => 1 );
1995
1996     push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1997     push(@{$self->query_atoms}, $atom);
1998
1999     return $self;
2000 }
2001
2002 # This will find up to one occurence of @$short_list within @$long_list, and
2003 # replace it with the single atom $replacement.
2004 sub replace_phrase_in_abstract_query {
2005     my ($self, $short_list, $long_list, $replacement) = @_;
2006
2007     my $success = 0;
2008     my @already = ();
2009     my $goal = scalar @$short_list;
2010
2011     for (my $i = 0; $i < scalar (@$long_list); $i++) {
2012         my $right = $long_list->[$i];
2013
2014         if (QueryParser::_util::compare_abstract_atoms(
2015             $short_list->[scalar @already], $right
2016         )) {
2017             push @already, $i;
2018         } elsif (scalar @already) {
2019             @already = ();
2020             next;
2021         }
2022
2023         if (scalar @already == $goal) {
2024             splice @$long_list, $already[0], scalar(@already), $replacement;
2025             $success = 1;
2026             last;
2027         }
2028     }
2029
2030     return $success;
2031 }
2032
2033 sub to_abstract_query {
2034     my $self = shift;
2035     my %opts = @_;
2036
2037     my $pkg = ref $self->plan->QueryParser || $self->plan->QueryParser;
2038
2039     my $abstract_query = {
2040         "type" => "node",
2041         "alias" => $self->alias,
2042         "alias_fields" => $self->alias_fields,
2043         "class" => $self->classname,
2044         "fields" => $self->fields
2045     };
2046
2047     my $kids = [];
2048
2049     for my $qatom (@{$self->query_atoms}) {
2050         if (QueryParser::_util::is_joiner($qatom)) {
2051             if ($abstract_query->{children}) {
2052                 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
2053                 next if $open_joiner eq $qatom;
2054
2055                 my $oldroot = $abstract_query->{children};
2056                 $kids = [$oldroot];
2057                 $abstract_query->{children} = {$qatom => $kids};
2058             } else {
2059                 $abstract_query->{children} = {$qatom => $kids};
2060             }
2061         } else {
2062             push @$kids, $qatom->to_abstract_query;
2063         }
2064     }
2065
2066     $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
2067
2068     if ($self->{phrases} and not $opts{no_phrases}) {
2069         for my $phrase (@{$self->{phrases}}) {
2070             # Phrases appear duplication in a real QP tree, and we don't want
2071             # that duplication in our abstract query.  So for all our phrases,
2072             # break them into atoms as QP would, and remove any matching
2073             # sequences of atoms from our abstract query.
2074
2075             my $tmp_prefix = '';
2076             $tmp_prefix = $QueryParser::parser_config{$pkg}{operators}{disallowed} if ($self->{negate});
2077
2078             my $tmptree = $self->{plan}->{QueryParser}->new(query => $tmp_prefix.'"'.$phrase.'"')->parse->parse_tree;
2079             if ($tmptree) {
2080                 # For a well-behaved phrase, we should now have only one node
2081                 # in the $tmptree query plan, and that node should have an
2082                 # orderly list of atoms and joiners.
2083
2084                 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
2085                     my $tmplist;
2086
2087                     eval {
2088                         $tmplist = $tmptree->{query}->[0]->to_abstract_query(
2089                             no_phrases => 1
2090                         )->{children}->{'&'}->[0]->{children}->{'&'};
2091                     };
2092                     next if $@;
2093
2094                     foreach (
2095                         QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
2096                     ) {
2097                         last if $self->replace_phrase_in_abstract_query(
2098                             $tmplist,
2099                             $_,
2100                             QueryParser::_util::fake_abstract_atom_from_phrase($phrase, $self->{negate}, $pkg)
2101                         );
2102                     }
2103                 }
2104             }
2105         }
2106     }
2107
2108     $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
2109     return $abstract_query;
2110 }
2111
2112 #-------------------------------
2113 package QueryParser::query_plan::node::atom;
2114
2115 sub new {
2116     my $pkg = shift;
2117     $pkg = ref($pkg) || $pkg;
2118     my %args = @_;
2119
2120     return bless \%args => $pkg;
2121 }
2122
2123 sub node {
2124     my $self = shift;
2125     return undef unless (ref $self);
2126     return $self->{node};
2127 }
2128
2129 sub content {
2130     my $self = shift;
2131     return undef unless (ref $self);
2132     return $self->{content};
2133 }
2134
2135 sub prefix {
2136     my $self = shift;
2137     return undef unless (ref $self);
2138     return $self->{prefix};
2139 }
2140
2141 sub suffix {
2142     my $self = shift;
2143     return undef unless (ref $self);
2144     return $self->{suffix};
2145 }
2146
2147 sub to_abstract_query {
2148     my ($self) = @_;
2149     
2150     return {
2151         (map { $_ => $self->$_ } qw/prefix suffix content/),
2152         "type" => "atom"
2153     };
2154 }
2155 #-------------------------------
2156 package QueryParser::query_plan::filter;
2157
2158 sub new {
2159     my $pkg = shift;
2160     $pkg = ref($pkg) || $pkg;
2161     my %args = @_;
2162
2163     return bless \%args => $pkg;
2164 }
2165
2166 sub plan {
2167     my $self = shift;
2168     return $self->{plan};
2169 }
2170
2171 sub name {
2172     my $self = shift;
2173     return $self->{name};
2174 }
2175
2176 sub negate {
2177     my $self = shift;
2178     return $self->{negate};
2179 }
2180
2181 sub args {
2182     my $self = shift;
2183     return $self->{args};
2184 }
2185
2186 sub to_abstract_query {
2187     my ($self) = @_;
2188     
2189     return {
2190         map { $_ => $self->$_ } qw/name negate args/
2191     };
2192 }
2193
2194 #-------------------------------
2195 package QueryParser::query_plan::facet;
2196
2197 sub new {
2198     my $pkg = shift;
2199     $pkg = ref($pkg) || $pkg;
2200     my %args = @_;
2201
2202     return bless \%args => $pkg;
2203 }
2204
2205 sub plan {
2206     my $self = shift;
2207     return $self->{plan};
2208 }
2209
2210 sub name {
2211     my $self = shift;
2212     return $self->{name};
2213 }
2214
2215 sub negate {
2216     my $self = shift;
2217     return $self->{negate};
2218 }
2219
2220 sub values {
2221     my $self = shift;
2222     return $self->{'values'};
2223 }
2224
2225 sub to_abstract_query {
2226     my ($self) = @_;
2227
2228     return {
2229         (map { $_ => $self->$_ } qw/name negate values/),
2230         "type" => "facet"
2231     };
2232 }
2233
2234 #-------------------------------
2235 package QueryParser::query_plan::modifier;
2236
2237 sub new {
2238     my $pkg = shift;
2239     $pkg = ref($pkg) || $pkg;
2240     my $modifier = shift;
2241     my $negate = shift;
2242
2243     return bless { name => $modifier, negate => $negate } => $pkg;
2244 }
2245
2246 sub name {
2247     my $self = shift;
2248     return $self->{name};
2249 }
2250
2251 sub negate {
2252     my $self = shift;
2253     return $self->{negate};
2254 }
2255
2256 sub to_abstract_query {
2257     my ($self) = @_;
2258     
2259     return $self->name;
2260 }
2261 1;
2262