5 use OpenSRF::Utils::JSON;
22 sub facet_class_count {
24 return @{$self->facet_classes};
27 sub search_class_count {
29 return @{$self->search_classes};
34 return @{$self->filters};
39 return @{$self->modifiers};
44 $class = ref($class) || $class;
46 $parser_config{$class}{custom_data} ||= {};
47 return $parser_config{$class}{custom_data};
52 $class = ref($class) || $class;
54 $parser_config{$class}{operators} ||= {};
55 return $parser_config{$class}{operators};
60 $class = ref($class) || $class;
62 $parser_config{$class}{filters} ||= [];
63 return $parser_config{$class}{filters};
68 $class = ref($class) || $class;
70 $parser_config{$class}{modifiers} ||= [];
71 return $parser_config{$class}{modifiers};
76 $class = ref($class) || $class;
80 my $self = bless {} => $class;
82 for my $o (keys %{QueryParser->operators}) {
83 $class->operator($o => QueryParser->operator($o)) unless ($class->operator($o));
86 for my $opt ( keys %opts) {
87 $self->$opt( $opts{$opt} ) if ($self->can($opt));
95 my $pkg = ref($self) || $self;
96 return do{$pkg.'::query_plan'}->new( QueryParser => $self, @_ );
99 sub add_search_filter {
101 $pkg = ref($pkg) || $pkg;
104 return $filter if (grep { $_ eq $filter } @{$pkg->filters});
105 push @{$pkg->filters}, $filter;
109 sub add_search_modifier {
111 $pkg = ref($pkg) || $pkg;
112 my $modifier = shift;
114 return $modifier if (grep { $_ eq $modifier } @{$pkg->modifiers});
115 push @{$pkg->modifiers}, $modifier;
119 sub add_facet_class {
121 $pkg = ref($pkg) || $pkg;
124 return $class if (grep { $_ eq $class } @{$pkg->facet_classes});
126 push @{$pkg->facet_classes}, $class;
127 $pkg->facet_fields->{$class} = [];
132 sub add_search_class {
134 $pkg = ref($pkg) || $pkg;
137 return $class if (grep { $_ eq $class } @{$pkg->search_classes});
139 push @{$pkg->search_classes}, $class;
140 $pkg->search_fields->{$class} = [];
141 $pkg->default_search_class( $pkg->search_classes->[0] ) if (@{$pkg->search_classes} == 1);
148 $class = ref($class) || $class;
152 return undef unless ($opname);
154 $parser_config{$class}{operators} ||= {};
155 $parser_config{$class}{operators}{$opname} = $op if ($op);
157 return $parser_config{$class}{operators}{$opname};
162 $class = ref($class) || $class;
165 $parser_config{$class}{facet_classes} ||= [];
166 $parser_config{$class}{facet_classes} = $classes if (ref($classes) && @$classes);
167 return $parser_config{$class}{facet_classes};
172 $class = ref($class) || $class;
175 $parser_config{$class}{classes} ||= [];
176 $parser_config{$class}{classes} = $classes if (ref($classes) && @$classes);
177 return $parser_config{$class}{classes};
180 sub add_query_normalizer {
182 $pkg = ref($pkg) || $pkg;
186 my $params = shift || [];
188 # do not add if function AND params are identical to existing member
189 return $func if (grep {
190 $_->{function} eq $func and
191 OpenSRF::Utils::JSON->perl2JSON($_->{params}) eq OpenSRF::Utils::JSON->perl2JSON($params)
192 } @{$pkg->query_normalizers->{$class}->{$field}});
194 push(@{$pkg->query_normalizers->{$class}->{$field}}, { function => $func, params => $params });
199 sub query_normalizers {
201 $pkg = ref($pkg) || $pkg;
206 $parser_config{$pkg}{normalizers} ||= {};
209 $parser_config{$pkg}{normalizers}{$class}{$field} ||= [];
210 return $parser_config{$pkg}{normalizers}{$class}{$field};
212 return $parser_config{$pkg}{normalizers}{$class};
216 return $parser_config{$pkg}{normalizers};
219 sub add_filter_normalizer {
221 $pkg = ref($pkg) || $pkg;
224 my $params = shift || [];
226 return $func if (grep { $_ eq $func } @{$pkg->filter_normalizers->{$filter}});
228 push(@{$pkg->filter_normalizers->{$filter}}, { function => $func, params => $params });
233 sub filter_normalizers {
235 $pkg = ref($pkg) || $pkg;
239 $parser_config{$pkg}{filter_normalizers} ||= {};
241 $parser_config{$pkg}{filter_normalizers}{$filter} ||= [];
242 return $parser_config{$pkg}{filter_normalizers}{$filter};
245 return $parser_config{$pkg}{filter_normalizers};
248 sub default_search_class {
250 $pkg = ref($pkg) || $pkg;
252 $QueryParser::parser_config{$pkg}{default_class} = $pkg->add_search_class( $class ) if $class;
254 return $QueryParser::parser_config{$pkg}{default_class};
257 sub remove_facet_class {
259 $pkg = ref($pkg) || $pkg;
262 return $class if (!grep { $_ eq $class } @{$pkg->facet_classes});
264 $pkg->facet_classes( [ grep { $_ ne $class } @{$pkg->facet_classes} ] );
265 delete $QueryParser::parser_config{$pkg}{facet_fields}{$class};
270 sub remove_search_class {
272 $pkg = ref($pkg) || $pkg;
275 return $class if (!grep { $_ eq $class } @{$pkg->search_classes});
277 $pkg->search_classes( [ grep { $_ ne $class } @{$pkg->search_classes} ] );
278 delete $QueryParser::parser_config{$pkg}{fields}{$class};
283 sub add_facet_field {
285 $pkg = ref($pkg) || $pkg;
289 $pkg->add_facet_class( $class );
291 return { $class => $field } if (grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
293 push @{$pkg->facet_fields->{$class}}, $field;
295 return { $class => $field };
300 $class = ref($class) || $class;
302 $parser_config{$class}{facet_fields} ||= {};
303 return $parser_config{$class}{facet_fields};
306 sub add_search_field {
308 $pkg = ref($pkg) || $pkg;
312 $pkg->add_search_class( $class );
314 return { $class => $field } if (grep { $_ eq $field } @{$pkg->search_fields->{$class}});
316 push @{$pkg->search_fields->{$class}}, $field;
318 return { $class => $field };
323 $class = ref($class) || $class;
325 $parser_config{$class}{fields} ||= {};
326 return $parser_config{$class}{fields};
329 sub add_search_class_alias {
331 $pkg = ref($pkg) || $pkg;
335 $pkg->add_search_class( $class );
337 return { $class => $alias } if (grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
339 push @{$pkg->search_class_aliases->{$class}}, $alias;
341 return { $class => $alias };
344 sub search_class_aliases {
346 $class = ref($class) || $class;
348 $parser_config{$class}{class_map} ||= {};
349 return $parser_config{$class}{class_map};
352 sub add_search_field_alias {
354 $pkg = ref($pkg) || $pkg;
359 return { $class => { $field => $alias } } if (grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
361 push @{$pkg->search_field_aliases->{$class}{$field}}, $alias;
363 return { $class => { $field => $alias } };
366 sub search_field_aliases {
368 $class = ref($class) || $class;
370 $parser_config{$class}{field_alias_map} ||= {};
371 return $parser_config{$class}{field_alias_map};
374 sub remove_facet_field {
376 $pkg = ref($pkg) || $pkg;
380 return { $class => $field } if (!$pkg->facet_fields->{$class} || !grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
382 $pkg->facet_fields->{$class} = [ grep { $_ ne $field } @{$pkg->facet_fields->{$class}} ];
384 return { $class => $field };
387 sub remove_search_field {
389 $pkg = ref($pkg) || $pkg;
393 return { $class => $field } if (!$pkg->search_fields->{$class} || !grep { $_ eq $field } @{$pkg->search_fields->{$class}});
395 $pkg->search_fields->{$class} = [ grep { $_ ne $field } @{$pkg->search_fields->{$class}} ];
397 return { $class => $field };
400 sub remove_search_field_alias {
402 $pkg = ref($pkg) || $pkg;
407 return { $class => { $field => $alias } } if (!$pkg->search_field_aliases->{$class}{$field} || !grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
409 $pkg->search_field_aliases->{$class}{$field} = [ grep { $_ ne $alias } @{$pkg->search_field_aliases->{$class}{$field}} ];
411 return { $class => { $field => $alias } };
414 sub remove_search_class_alias {
416 $pkg = ref($pkg) || $pkg;
420 return { $class => $alias } if (!$pkg->search_class_aliases->{$class} || !grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
422 $pkg->search_class_aliases->{$class} = [ grep { $_ ne $alias } @{$pkg->search_class_aliases->{$class}} ];
424 return { $class => $alias };
430 $self->{_debug} = $q if (defined $q);
431 return $self->{_debug};
437 $self->{_query} = $q if (defined $q);
438 return $self->{_query};
444 $self->{_parse_tree} = $q if (defined $q);
445 return $self->{_parse_tree};
450 my $pkg = ref($self) || $self;
451 warn " ** parse package is $pkg\n" if $self->debug;
454 $self->query( shift() )
463 my $pkg = ref($self) || $self;
465 warn " ** decompose package is $pkg\n" if $self->debug;
468 my $current_class = shift || $self->default_search_class;
470 my $recursing = shift || 0;
471 my $phrase_helper = shift || 0;
473 # Build the search class+field uber-regexp
474 my $search_class_re = '^\s*(';
478 for my $class ( keys %{$pkg->search_field_aliases} ) {
479 warn " *** ... Looking for search fields in $class\n" if $self->debug;
481 for my $field ( keys %{$pkg->search_field_aliases->{$class}} ) {
482 warn " *** ... Looking for aliases of $field\n" if $self->debug;
484 for my $alias ( @{$pkg->search_field_aliases->{$class}{$field}} ) {
485 my $aliasr = qr/$alias/;
486 s/(^|\s+)$aliasr\|/$1$class\|$field#$alias\|/g;
487 s/(^|\s+)$aliasr[:=]/$1$class\|$field#$alias:/g;
488 warn " *** Rewriting: $alias ($aliasr) as $class\|$field\n" if $self->debug;
492 $search_class_re .= '|' unless ($first_class);
494 $search_class_re .= $class . '(?:[|#][^:|]+)*';
495 $seen_classes{$class} = 1;
498 for my $class ( keys %{$pkg->search_class_aliases} ) {
500 for my $alias ( @{$pkg->search_class_aliases->{$class}} ) {
501 my $aliasr = qr/$alias/;
502 s/(^|[^|])\b$aliasr\|/$1$class#$alias\|/g;
503 s/(^|[^|])\b$aliasr[:=]/$1$class#$alias:/g;
504 warn " *** Rewriting: $alias ($aliasr) as $class\n" if $self->debug;
507 if (!$seen_classes{$class}) {
508 $search_class_re .= '|' unless ($first_class);
511 $search_class_re .= $class . '(?:[|#][^:|]+)*';
512 $seen_classes{$class} = 1;
515 $search_class_re .= '):';
517 warn " ** Rewritten query: $_\n" if $self->debug;
518 warn " ** Search class RE: $search_class_re\n" if $self->debug;
520 my $required_re = $pkg->operator('required');
521 $required_re = qr/\Q$required_re\E/;
523 my $disallowed_re = $pkg->operator('disallowed');
524 $disallowed_re = qr/\Q$disallowed_re\E/;
526 my $and_re = $pkg->operator('and');
527 $and_re = qr/^\s*\Q$and_re\E/;
529 my $or_re = $pkg->operator('or');
530 $or_re = qr/^\s*\Q$or_re\E/;
532 my $group_start_re = $pkg->operator('group_start');
533 $group_start_re = qr/^\s*\Q$group_start_re\E/;
535 my $group_end = $pkg->operator('group_end');
536 my $group_end_re = qr/^\s*\Q$group_end\E/;
538 my $modifier_tag_re = $pkg->operator('modifier');
539 $modifier_tag_re = qr/^\s*\Q$modifier_tag_re\E/;
542 # Build the filter and modifier uber-regexps
543 my $facet_re = '^\s*(-?)((?:' . join( '|', @{$pkg->facet_classes}) . ')(?:\|\w+)*)\[(.+?)\]';
544 warn " ** Facet RE: $facet_re\n" if $self->debug;
546 my $filter_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . ')\(([^()]+)\)';
547 my $filter_as_class_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . '):\s*(\S+)';
549 my $modifier_re = '^\s*'.$modifier_tag_re.'(' . join( '|', @{$pkg->modifiers}) . ')\b';
550 my $modifier_as_class_re = '^\s*(' . join( '|', @{$pkg->modifiers}) . '):\s*(\S+)';
552 my $struct = $self->new_plan( level => $recursing );
556 while (!$remainder) {
557 if (/^\s*$/) { # end of an explicit group
559 } elsif (/$group_end_re/) { # end of an explicit group
560 warn "Encountered explicit group end\n" if $self->debug;
563 $remainder = $struct->top_plan ? '' : $';
566 } elsif ($self->filter_count && /$filter_re/) { # found a filter
567 warn "Encountered search filter: $1$2 set to $3\n" if $self->debug;
569 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
571 $struct->new_filter( $2 => [ split '[,]+', $3 ], $negate );
574 } elsif ($self->filter_count && /$filter_as_class_re/) { # found a filter
575 warn "Encountered search filter: $1$2 set to $3\n" if $self->debug;
577 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
579 $struct->new_filter( $2 => [ split '[,]+', $3 ], $negate );
582 } elsif ($self->modifier_count && /$modifier_re/) { # found a modifier
583 warn "Encountered search modifier: $1\n" if $self->debug;
586 if (!$struct->top_plan) {
587 warn " Search modifiers only allowed at the top level of the query\n" if $self->debug;
589 $struct->new_modifier($1);
593 } elsif ($self->modifier_count && /$modifier_as_class_re/) { # found a modifier
594 warn "Encountered search modifier: $1\n" if $self->debug;
599 if (!$struct->top_plan) {
600 warn " Search modifiers only allowed at the top level of the query\n" if $self->debug;
601 } elsif ($2 =~ /^[ty1]/i) {
602 $struct->new_modifier($mod);
606 } elsif (/$group_start_re/) { # start of an explicit group
607 warn "Encountered explicit group start\n" if $self->debug;
609 my ($substruct, $subremainder) = $self->decompose( $', $current_class, $recursing + 1 );
610 $struct->add_node( $substruct ) if ($substruct);
614 } elsif (/$and_re/) { # ANDed expression
616 next if ($last_type eq 'AND');
617 next if ($last_type eq 'OR');
618 warn "Encountered AND\n" if $self->debug;
620 $struct->joiner( '&' );
623 } elsif (/$or_re/) { # ORed expression
625 next if ($last_type eq 'AND');
626 next if ($last_type eq 'OR');
627 warn "Encountered OR\n" if $self->debug;
629 $struct->joiner( '|' );
632 } elsif ($self->facet_class_count && /$facet_re/) { # changing current class
633 warn "Encountered facet: $1$2 => $3\n" if $self->debug;
635 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
637 my $facet_value = [ split '\s*#\s*', $3 ];
638 $struct->new_facet( $facet => $facet_value, $negate );
642 } elsif ($self->search_class_count && /$search_class_re/) { # changing current class
644 if ($last_type eq 'CLASS') {
645 $struct->remove_last_node( $current_class );
646 warn "Encountered class change with no searches!\n" if $self->debug;
649 warn "Encountered class change: $1\n" if $self->debug;
651 $current_class = $struct->classed_node( $1 )->requested_class();
654 $last_type = 'CLASS';
655 } elsif (/^\s*($required_re|$disallowed_re)?"([^"]+)"/) { # phrase, always anded
656 warn 'Encountered' . ($1 ? " ['$1' modified]" : '') . " phrase: $2\n" if $self->debug;
658 my $req_ness = $1 || '';
661 if (!$phrase_helper) {
662 warn "Recursing into decompose with the phrase as a subquery\n" if $self->debug;
664 my ($substruct, $subremainder) = $self->decompose( qq/$req_ness"$phrase"/, $current_class, $recursing + 1, 1 );
665 $struct->add_node( $substruct ) if ($substruct);
668 warn "Directly parsing the phrase subquery\n" if $self->debug;
669 $struct->joiner( '&' );
671 my $class_node = $struct->classed_node($current_class);
673 if ($req_ness eq $pkg->operator('disallowed')) {
674 $class_node->add_dummy_atom( node => $class_node );
675 $class_node->add_unphrase( $phrase );
677 #$phrase =~ s/(^|\s)\b/$1-/g;
679 $class_node->add_phrase( $phrase );
687 # } elsif (/^\s*$required_re([^\s"]+)/) { # phrase, always anded
688 # warn "Encountered required atom (mini phrase): $1\n" if $self->debug;
692 # my $class_node = $struct->classed_node($current_class);
693 # $class_node->add_phrase( $phrase );
695 # $struct->joiner( '&' );
698 } elsif (/^\s*([^$group_end\s]+)/o) { # atom
699 warn "Encountered atom: $1\n" if $self->debug;
700 warn "Remainder: $'\n" if $self->debug;
708 my $class_node = $struct->classed_node($current_class);
710 my $prefix = ($atom =~ s/^$disallowed_re//o) ? '!' : '';
711 my $truncate = ($atom =~ s/\*$//o) ? '*' : '';
713 if ($atom ne '' and !grep { $atom =~ /^\Q$_\E+$/ } ('&','|','-','+')) { # throw away & and |, not allowed in tsquery, and not really useful anyway
714 # $class_node->add_phrase( $atom ) if ($atom =~ s/^$required_re//o);
715 # $class_node->add_unphrase( $atom ) if ($prefix eq '!');
717 $class_node->add_fts_atom( $atom, suffix => $truncate, prefix => $prefix, node => $class_node );
718 $struct->joiner( '&' );
727 scalar(@{$struct->query_nodes}) == 0 &&
728 scalar(@{$struct->filters}) == 0 &&
731 return $struct if !wantarray;
732 return ($struct, $remainder);
735 sub find_class_index {
739 my ($class_part, @field_parts) = split '\|', $class;
740 $class_part ||= $class;
742 for my $idx ( 0 .. scalar(@$query) - 1 ) {
743 next unless ref($$query[$idx]);
744 return $idx if ( $$query[$idx]{requested_class} && $class eq $$query[$idx]{requested_class} );
747 push(@$query, { classname => $class_part, (@field_parts ? (fields => \@field_parts) : ()), requested_class => $class, ftsquery => [], phrases => [] });
754 $self->{core_limit} = $l if ($l);
755 return $self->{core_limit};
761 $self->{superpage} = $l if ($l);
762 return $self->{superpage};
768 $self->{superpage_size} = $l if ($l);
769 return $self->{superpage_size};
773 #-------------------------------
774 package QueryParser::_util;
776 # At this level, joiners are always & or |. This is not
777 # the external, configurable representation of joiners that
778 # defaults to # && and ||.
782 return (not ref $str and ($str eq '&' or $str eq '|'));
785 sub default_joiner { '&' }
787 # 0 for different, 1 for the same.
788 sub compare_abstract_atoms {
789 my ($left, $right) = @_;
791 foreach (qw/prefix suffix content/) {
792 no warnings; # undef can stand in for '' here
793 return 0 unless $left->{$_} eq $right->{$_};
799 sub fake_abstract_atom_from_phrase {
800 my ($phrase, $neg) = @_;
805 $QueryParser::parser_config{QueryParser}{operators}{disallowed} .
810 "type" => "atom", "prefix" => $prefix, "suffix" => '"',
815 sub find_arrays_in_abstract {
819 foreach my $key (keys %$hash) {
820 if (ref $hash->{$key} eq "ARRAY") {
821 push @arrays, $hash->{$key};
822 foreach (@{$hash->{$key}}) {
823 push @arrays, find_arrays_in_abstract($_);
831 #-------------------------------
832 package QueryParser::Canonicalize; # not OO
834 sub _abstract_query2str_filter {
836 my $qpconfig = $parser_config{QueryParser};
840 $f->{negate} ? $qpconfig->{operators}{disallowed} : "",
842 join(",", @{$f->{args}})
846 sub _abstract_query2str_modifier {
848 my $qpconfig = $parser_config{QueryParser};
850 return $qpconfig->{operators}{modifier} . $f;
853 # This should produce an equivalent query to the original, given an
855 sub abstract_query2str_impl {
856 my ($abstract_query, $depth) = @_;
858 my $qpconfig = $parser_config{QueryParser};
860 my $gs = $qpconfig->{operators}{group_start};
861 my $ge = $qpconfig->{operators}{group_end};
862 my $and = $qpconfig->{operators}{and};
863 my $or = $qpconfig->{operators}{or};
866 $q .= $gs if $abstract_query->{type} and $abstract_query->{type} eq "query_plan" and $depth;
868 if (exists $abstract_query->{type}) {
869 if ($abstract_query->{type} eq 'query_plan') {
870 $q .= join(" ", map { _abstract_query2str_filter($_) } @{$abstract_query->{filters}}) if
871 exists $abstract_query->{filters};
874 $q .= join(" ", map { _abstract_query2str_modifier($_) } @{$abstract_query->{modifiers}}) if
875 exists $abstract_query->{modifiers};
876 } elsif ($abstract_query->{type} eq 'node') {
877 if ($abstract_query->{alias}) {
878 $q .= " " . $abstract_query->{alias};
879 $q .= "|$_" foreach @{$abstract_query->{alias_fields}};
881 $q .= " " . $abstract_query->{class};
882 $q .= "|$_" foreach @{$abstract_query->{fields}};
885 } elsif ($abstract_query->{type} eq 'atom') {
886 my $prefix = $abstract_query->{prefix} || '';
887 $prefix = $qpconfig->{operators}{disallowed} if $prefix eq '!';
889 ($abstract_query->{content} || '') .
890 ($abstract_query->{suffix} || '');
891 } elsif ($abstract_query->{type} eq 'facet') {
892 # facet syntax [ # ] is hardcoded I guess?
893 my $prefix = $abstract_query->{negate} ? $qpconfig->{operators}{disallowed} : '';
894 $q .= $prefix . $abstract_query->{name} . "[" .
895 join(" # ", @{$abstract_query->{values}}) . "]";
899 if (exists $abstract_query->{children}) {
900 my $op = (keys(%{$abstract_query->{children}}))[0];
902 " " . ($op eq '&' ? $and : $or) . " ",
904 abstract_query2str_impl($_, $depth + 1)
905 } @{$abstract_query->{children}{$op}}
907 } elsif ($abstract_query->{'&'} or $abstract_query->{'|'}) {
908 my $op = (keys(%{$abstract_query}))[0];
910 " " . ($op eq '&' ? $and : $or) . " ",
912 abstract_query2str_impl($_, $depth + 1)
913 } @{$abstract_query->{$op}}
918 $q .= $ge if $abstract_query->{type} and $abstract_query->{type} eq "query_plan" and $depth;
923 #-------------------------------
924 package QueryParser::query_plan;
928 return undef unless ref($self);
929 return $self->{QueryParser};
934 $pkg = ref($pkg) || $pkg;
935 my %args = (query => [], joiner => '&', @_);
937 return bless \%args => $pkg;
942 my $pkg = ref($self) || $self;
943 my $node = do{$pkg.'::node'}->new( plan => $self, @_ );
944 $self->add_node( $node );
950 my $pkg = ref($self) || $self;
955 my $node = do{$pkg.'::facet'}->new( plan => $self, name => $name, 'values' => $args, negate => $negate );
956 $self->add_node( $node );
963 my $pkg = ref($self) || $self;
968 my $node = do{$pkg.'::filter'}->new( plan => $self, name => $name, args => $args, negate => $negate );
969 $self->add_filter( $node );
977 return undef unless ($needle);
978 return grep { $_->name eq $needle } @{ $self->filters };
984 return undef unless ($needle);
985 return grep { $_->name eq $needle } @{ $self->modifiers };
990 my $pkg = ref($self) || $self;
993 my $node = do{$pkg.'::modifier'}->new( $name );
994 $self->add_modifier( $node );
1001 my $requested_class = shift;
1004 for my $n (@{$self->{query}}) {
1005 next unless (ref($n) && $n->isa( 'QueryParser::query_plan::node' ));
1006 if ($n->requested_class eq $requested_class) {
1013 $node = $self->new_node;
1014 $node->requested_class( $requested_class );
1020 sub remove_last_node {
1022 my $requested_class = shift;
1024 my $old = pop(@{$self->query_nodes});
1025 pop(@{$self->query_nodes}) if (@{$self->query_nodes});
1032 return $self->{query};
1039 $self->{query} ||= [];
1040 push(@{$self->{query}}, $self->joiner) if (@{$self->{query}});
1041 push(@{$self->{query}}, $node);
1049 return $self->{level} ? 0 : 1;
1054 return $self->{level};
1061 $self->{joiner} = $joiner if ($joiner);
1062 return $self->{joiner};
1067 $self->{modifiers} ||= [];
1068 return $self->{modifiers};
1073 my $modifier = shift;
1075 $self->{modifiers} ||= [];
1076 $self->{modifiers} = [ grep {$_->name ne $modifier->name} @{$self->{modifiers}} ];
1078 push(@{$self->{modifiers}}, $modifier);
1085 $self->{facets} ||= [];
1086 return $self->{facets};
1093 $self->{facets} ||= [];
1094 $self->{facets} = [ grep {$_->name ne $facet->name} @{$self->{facets}} ];
1096 push(@{$self->{facets}}, $facet);
1103 $self->{filters} ||= [];
1104 return $self->{filters};
1111 $self->{filters} ||= [];
1112 $self->{filters} = [ grep {$_->name ne $filter->name} @{$self->{filters}} ];
1114 push(@{$self->{filters}}, $filter);
1119 # %opts supports two options at this time:
1121 # If true, do not do anything to the phrases and unphrases
1122 # fields on any discovered nodes.
1124 # If true, also return the query parser config as part of the blob.
1125 # This will get set back to 0 before recursion to avoid repetition.
1126 sub to_abstract_query {
1130 my $pkg = ref $self->QueryParser || $self->QueryParser;
1132 my $abstract_query = {
1133 type => "query_plan",
1134 filters => [map { $_->to_abstract_query } @{$self->filters}],
1135 modifiers => [map { $_->to_abstract_query } @{$self->modifiers}]
1138 if ($opts{with_config}) {
1139 $opts{with_config} = 0;
1140 $abstract_query->{config} = $QueryParser::parser_config{$pkg};
1145 for my $qnode (@{$self->query_nodes}) {
1146 # Remember: qnode can be a joiner string, a node, or another query_plan
1148 if (QueryParser::_util::is_joiner($qnode)) {
1149 if ($abstract_query->{children}) {
1150 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1151 next if $open_joiner eq $qnode;
1153 my $oldroot = $abstract_query->{children};
1155 $abstract_query->{children} = {$qnode => $kids};
1157 $abstract_query->{children} = {$qnode => $kids};
1160 push @$kids, $qnode->to_abstract_query(%opts);
1164 $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1165 return $abstract_query;
1169 #-------------------------------
1170 package QueryParser::query_plan::node;
1172 $Data::Dumper::Indent = 0;
1176 $pkg = ref($pkg) || $pkg;
1179 return bless \%args => $pkg;
1184 my $pkg = ref($self) || $self;
1185 return do{$pkg.'::atom'}->new( @_ );
1188 sub requested_class { # also split into classname, fields and alias
1194 my (undef, $alias) = split '#', $class;
1196 $class =~ s/#[^|]+//;
1197 ($alias, @afields) = split '\|', $alias;
1200 my @fields = @afields;
1201 my ($class_part, @field_parts) = split '\|', $class;
1202 for my $f (@field_parts) {
1203 push(@fields, $f) unless (grep { $f eq $_ } @fields);
1206 $class_part ||= $class;
1208 $self->{requested_class} = $class;
1209 $self->{alias} = $alias if $alias;
1210 $self->{alias_fields} = \@afields if $alias;
1211 $self->{classname} = $class_part;
1212 $self->{fields} = \@fields;
1215 return $self->{requested_class};
1222 $self->{plan} = $plan if ($plan);
1223 return $self->{plan};
1230 $self->{alias} = $alias if ($alias);
1231 return $self->{alias};
1238 $self->{alias_fields} = $alias if ($alias);
1239 return $self->{alias_fields};
1246 $self->{classname} = $class if ($class);
1247 return $self->{classname};
1254 $self->{fields} ||= [];
1255 $self->{fields} = \@fields if (@fields);
1256 return $self->{fields};
1263 $self->{phrases} ||= [];
1264 $self->{phrases} = \@phrases if (@phrases);
1265 return $self->{phrases};
1272 $self->{unphrases} ||= [];
1273 $self->{unphrases} = \@phrases if (@phrases);
1274 return $self->{unphrases};
1281 push(@{$self->phrases}, $phrase);
1290 push(@{$self->unphrases}, $phrase);
1297 my @query_atoms = @_;
1299 $self->{query_atoms} ||= [];
1300 $self->{query_atoms} = \@query_atoms if (@query_atoms);
1301 return $self->{query_atoms};
1309 my $content = $atom;
1312 $atom = $self->new_atom( content => $content, @parts );
1315 push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1316 push(@{$self->query_atoms}, $atom);
1321 sub add_dummy_atom {
1325 my $atom = $self->new_atom( @parts, dummy => 1 );
1327 push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1328 push(@{$self->query_atoms}, $atom);
1333 # This will find up to one occurence of @$short_list within @$long_list, and
1334 # replace it with the single atom $replacement.
1335 sub replace_phrase_in_abstract_query {
1336 my ($self, $short_list, $long_list, $replacement) = @_;
1340 my $goal = scalar @$short_list;
1342 for (my $i = 0; $i < scalar (@$long_list); $i++) {
1343 my $right = $long_list->[$i];
1345 if (QueryParser::_util::compare_abstract_atoms(
1346 $short_list->[scalar @already], $right
1349 } elsif (scalar @already) {
1354 if (scalar @already == $goal) {
1355 splice @$long_list, $already[0], scalar(@already), $replacement;
1364 sub to_abstract_query {
1368 my $pkg = ref $self->plan->QueryParser || $self->plan->QueryParser;
1370 my $abstract_query = {
1372 "alias" => $self->alias,
1373 "alias_fields" => $self->alias_fields,
1374 "class" => $self->classname,
1375 "fields" => $self->fields
1380 for my $qatom (@{$self->query_atoms}) {
1381 if (QueryParser::_util::is_joiner($qatom)) {
1382 if ($abstract_query->{children}) {
1383 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1384 next if $open_joiner eq $qatom;
1386 my $oldroot = $abstract_query->{children};
1388 $abstract_query->{children} = {$qatom => $kids};
1390 $abstract_query->{children} = {$qatom => $kids};
1393 push @$kids, $qatom->to_abstract_query;
1397 if ($self->{phrases} and not $opts{no_phrases}) {
1398 for my $phrase (@{$self->{phrases}}) {
1399 # Phrases appear duplication in a real QP tree, and we don't want
1400 # that duplication in our abstract query. So for all our phrases,
1401 # break them into atoms as QP would, and remove any matching
1402 # sequences of atoms from our abstract query.
1404 my $tmptree = $self->{plan}->{QueryParser}->new(query => '"'.$phrase.'"')->parse->parse_tree;
1406 # For a well-behaved phrase, we should now have only one node
1407 # in the $tmptree query plan, and that node should have an
1408 # orderly list of atoms and joiners.
1410 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
1414 $tmplist = $tmptree->{query}->[0]->to_abstract_query(
1416 )->{children}->{'&'}->[0]->{children}->{'&'};
1421 QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
1423 last if $self->replace_phrase_in_abstract_query(
1426 QueryParser::_util::fake_abstract_atom_from_phrase($phrase)
1434 # Do the same as the preceding block for unphrases (negated phrases).
1435 if ($self->{unphrases} and not $opts{no_phrases}) {
1436 for my $phrase (@{$self->{unphrases}}) {
1437 my $tmptree = $self->{plan}->{QueryParser}->new(
1438 query => $QueryParser::parser_config{$pkg}{operators}{disallowed}.
1440 )->parse->parse_tree;
1443 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
1447 $tmplist = $tmptree->{query}->[0]->to_abstract_query(
1449 )->{children}->{'&'}->[0]->{children}->{'&'};
1454 QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
1456 last if $self->replace_phrase_in_abstract_query(
1459 QueryParser::_util::fake_abstract_atom_from_phrase($phrase, 1)
1467 $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1468 return $abstract_query;
1471 #-------------------------------
1472 package QueryParser::query_plan::node::atom;
1476 $pkg = ref($pkg) || $pkg;
1479 return bless \%args => $pkg;
1484 return undef unless (ref $self);
1485 return $self->{node};
1490 return undef unless (ref $self);
1491 return $self->{content};
1496 return undef unless (ref $self);
1497 return $self->{prefix};
1502 return undef unless (ref $self);
1503 return $self->{suffix};
1506 sub to_abstract_query {
1510 (map { $_ => $self->$_ } qw/prefix suffix content/),
1514 #-------------------------------
1515 package QueryParser::query_plan::filter;
1519 $pkg = ref($pkg) || $pkg;
1522 return bless \%args => $pkg;
1527 return $self->{plan};
1532 return $self->{name};
1537 return $self->{negate};
1542 return $self->{args};
1545 sub to_abstract_query {
1549 map { $_ => $self->$_ } qw/name negate args/
1553 #-------------------------------
1554 package QueryParser::query_plan::facet;
1558 $pkg = ref($pkg) || $pkg;
1561 return bless \%args => $pkg;
1566 return $self->{plan};
1571 return $self->{name};
1576 return $self->{negate};
1581 return $self->{'values'};
1584 sub to_abstract_query {
1588 (map { $_ => $self->$_ } qw/name negate values/),
1593 #-------------------------------
1594 package QueryParser::query_plan::modifier;
1598 $pkg = ref($pkg) || $pkg;
1599 my $modifier = shift;
1602 return bless { name => $modifier, negate => $negate } => $pkg;
1607 return $self->{name};
1612 return $self->{negate};
1615 sub to_abstract_query {