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};
66 sub filter_callbacks {
68 $class = ref($class) || $class;
70 $parser_config{$class}{filter_callbacks} ||= {};
71 return $parser_config{$class}{filter_callbacks};
76 $class = ref($class) || $class;
78 $parser_config{$class}{modifiers} ||= [];
79 return $parser_config{$class}{modifiers};
84 $class = ref($class) || $class;
88 my $self = bless {} => $class;
90 for my $o (keys %{QueryParser->operators}) {
91 $class->operator($o => QueryParser->operator($o)) unless ($class->operator($o));
94 for my $opt ( keys %opts) {
95 $self->$opt( $opts{$opt} ) if ($self->can($opt));
103 my $pkg = ref($self) || $self;
104 return do{$pkg.'::query_plan'}->new( QueryParser => $self, @_ );
107 sub add_search_filter {
109 $pkg = ref($pkg) || $pkg;
111 my $callback = shift;
113 return $filter if (grep { $_ eq $filter } @{$pkg->filters});
114 push @{$pkg->filters}, $filter;
115 $pkg->filter_callbacks->{$filter} = $callback if ($callback);
119 sub add_search_modifier {
121 $pkg = ref($pkg) || $pkg;
122 my $modifier = shift;
124 return $modifier if (grep { $_ eq $modifier } @{$pkg->modifiers});
125 push @{$pkg->modifiers}, $modifier;
129 sub add_facet_class {
131 $pkg = ref($pkg) || $pkg;
134 return $class if (grep { $_ eq $class } @{$pkg->facet_classes});
136 push @{$pkg->facet_classes}, $class;
137 $pkg->facet_fields->{$class} = [];
142 sub add_search_class {
144 $pkg = ref($pkg) || $pkg;
147 return $class if (grep { $_ eq $class } @{$pkg->search_classes});
149 push @{$pkg->search_classes}, $class;
150 $pkg->search_fields->{$class} = [];
151 $pkg->default_search_class( $pkg->search_classes->[0] ) if (@{$pkg->search_classes} == 1);
158 $class = ref($class) || $class;
162 return undef unless ($opname);
164 $parser_config{$class}{operators} ||= {};
165 $parser_config{$class}{operators}{$opname} = $op if ($op);
167 return $parser_config{$class}{operators}{$opname};
172 $class = ref($class) || $class;
175 $parser_config{$class}{facet_classes} ||= [];
176 $parser_config{$class}{facet_classes} = $classes if (ref($classes) && @$classes);
177 return $parser_config{$class}{facet_classes};
182 $class = ref($class) || $class;
185 $parser_config{$class}{classes} ||= [];
186 $parser_config{$class}{classes} = $classes if (ref($classes) && @$classes);
187 return $parser_config{$class}{classes};
190 sub add_query_normalizer {
192 $pkg = ref($pkg) || $pkg;
196 my $params = shift || [];
198 # do not add if function AND params are identical to existing member
199 return $func if (grep {
200 $_->{function} eq $func and
201 OpenSRF::Utils::JSON->perl2JSON($_->{params}) eq OpenSRF::Utils::JSON->perl2JSON($params)
202 } @{$pkg->query_normalizers->{$class}->{$field}});
204 push(@{$pkg->query_normalizers->{$class}->{$field}}, { function => $func, params => $params });
209 sub query_normalizers {
211 $pkg = ref($pkg) || $pkg;
216 $parser_config{$pkg}{normalizers} ||= {};
219 $parser_config{$pkg}{normalizers}{$class}{$field} ||= [];
220 return $parser_config{$pkg}{normalizers}{$class}{$field};
222 return $parser_config{$pkg}{normalizers}{$class};
226 return $parser_config{$pkg}{normalizers};
229 sub add_filter_normalizer {
231 $pkg = ref($pkg) || $pkg;
234 my $params = shift || [];
236 return $func if (grep { $_ eq $func } @{$pkg->filter_normalizers->{$filter}});
238 push(@{$pkg->filter_normalizers->{$filter}}, { function => $func, params => $params });
243 sub filter_normalizers {
245 $pkg = ref($pkg) || $pkg;
249 $parser_config{$pkg}{filter_normalizers} ||= {};
251 $parser_config{$pkg}{filter_normalizers}{$filter} ||= [];
252 return $parser_config{$pkg}{filter_normalizers}{$filter};
255 return $parser_config{$pkg}{filter_normalizers};
258 sub default_search_class {
260 $pkg = ref($pkg) || $pkg;
262 $QueryParser::parser_config{$pkg}{default_class} = $pkg->add_search_class( $class ) if $class;
264 return $QueryParser::parser_config{$pkg}{default_class};
267 sub remove_facet_class {
269 $pkg = ref($pkg) || $pkg;
272 return $class if (!grep { $_ eq $class } @{$pkg->facet_classes});
274 $pkg->facet_classes( [ grep { $_ ne $class } @{$pkg->facet_classes} ] );
275 delete $QueryParser::parser_config{$pkg}{facet_fields}{$class};
280 sub remove_search_class {
282 $pkg = ref($pkg) || $pkg;
285 return $class if (!grep { $_ eq $class } @{$pkg->search_classes});
287 $pkg->search_classes( [ grep { $_ ne $class } @{$pkg->search_classes} ] );
288 delete $QueryParser::parser_config{$pkg}{fields}{$class};
293 sub add_facet_field {
295 $pkg = ref($pkg) || $pkg;
299 $pkg->add_facet_class( $class );
301 return { $class => $field } if (grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
303 push @{$pkg->facet_fields->{$class}}, $field;
305 return { $class => $field };
310 $class = ref($class) || $class;
312 $parser_config{$class}{facet_fields} ||= {};
313 return $parser_config{$class}{facet_fields};
316 sub add_search_field {
318 $pkg = ref($pkg) || $pkg;
322 $pkg->add_search_class( $class );
324 return { $class => $field } if (grep { $_ eq $field } @{$pkg->search_fields->{$class}});
326 push @{$pkg->search_fields->{$class}}, $field;
328 return { $class => $field };
333 $class = ref($class) || $class;
335 $parser_config{$class}{fields} ||= {};
336 return $parser_config{$class}{fields};
339 sub add_search_class_alias {
341 $pkg = ref($pkg) || $pkg;
345 $pkg->add_search_class( $class );
347 return { $class => $alias } if (grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
349 push @{$pkg->search_class_aliases->{$class}}, $alias;
351 return { $class => $alias };
354 sub search_class_aliases {
356 $class = ref($class) || $class;
358 $parser_config{$class}{class_map} ||= {};
359 return $parser_config{$class}{class_map};
362 sub add_search_field_alias {
364 $pkg = ref($pkg) || $pkg;
369 return { $class => { $field => $alias } } if (grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
371 push @{$pkg->search_field_aliases->{$class}{$field}}, $alias;
373 return { $class => { $field => $alias } };
376 sub search_field_aliases {
378 $class = ref($class) || $class;
380 $parser_config{$class}{field_alias_map} ||= {};
381 return $parser_config{$class}{field_alias_map};
384 sub remove_facet_field {
386 $pkg = ref($pkg) || $pkg;
390 return { $class => $field } if (!$pkg->facet_fields->{$class} || !grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
392 $pkg->facet_fields->{$class} = [ grep { $_ ne $field } @{$pkg->facet_fields->{$class}} ];
394 return { $class => $field };
397 sub remove_search_field {
399 $pkg = ref($pkg) || $pkg;
403 return { $class => $field } if (!$pkg->search_fields->{$class} || !grep { $_ eq $field } @{$pkg->search_fields->{$class}});
405 $pkg->search_fields->{$class} = [ grep { $_ ne $field } @{$pkg->search_fields->{$class}} ];
407 return { $class => $field };
410 sub remove_search_field_alias {
412 $pkg = ref($pkg) || $pkg;
417 return { $class => { $field => $alias } } if (!$pkg->search_field_aliases->{$class}{$field} || !grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
419 $pkg->search_field_aliases->{$class}{$field} = [ grep { $_ ne $alias } @{$pkg->search_field_aliases->{$class}{$field}} ];
421 return { $class => { $field => $alias } };
424 sub remove_search_class_alias {
426 $pkg = ref($pkg) || $pkg;
430 return { $class => $alias } if (!$pkg->search_class_aliases->{$class} || !grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
432 $pkg->search_class_aliases->{$class} = [ grep { $_ ne $alias } @{$pkg->search_class_aliases->{$class}} ];
434 return { $class => $alias };
440 $self->{_debug} = $q if (defined $q);
441 return $self->{_debug};
447 $self->{_query} = $q if (defined $q);
448 return $self->{_query};
454 $self->{_parse_tree} = $q if (defined $q);
455 return $self->{_parse_tree};
460 my $pkg = ref($self) || $self;
461 warn " ** parse package is $pkg\n" if $self->debug;
464 $self->query( shift() )
473 my $pkg = ref($self) || $self;
475 warn " ** decompose package is $pkg\n" if $self->debug;
478 my $current_class = shift || $self->default_search_class;
480 my $recursing = shift || 0;
481 my $phrase_helper = shift || 0;
483 # Build the search class+field uber-regexp
484 my $search_class_re = '^\s*(';
488 for my $class ( keys %{$pkg->search_field_aliases} ) {
489 warn " *** ... Looking for search fields in $class\n" if $self->debug;
491 for my $field ( keys %{$pkg->search_field_aliases->{$class}} ) {
492 warn " *** ... Looking for aliases of $field\n" if $self->debug;
494 for my $alias ( @{$pkg->search_field_aliases->{$class}{$field}} ) {
495 my $aliasr = qr/$alias/;
496 s/(^|\s+)$aliasr\|/$1$class\|$field#$alias\|/g;
497 s/(^|\s+)$aliasr[:=]/$1$class\|$field#$alias:/g;
498 warn " *** Rewriting: $alias ($aliasr) as $class\|$field\n" if $self->debug;
502 $search_class_re .= '|' unless ($first_class);
504 $search_class_re .= $class . '(?:[|#][^:|]+)*';
505 $seen_classes{$class} = 1;
508 for my $class ( keys %{$pkg->search_class_aliases} ) {
510 for my $alias ( @{$pkg->search_class_aliases->{$class}} ) {
511 my $aliasr = qr/$alias/;
512 s/(^|[^|])\b$aliasr\|/$1$class#$alias\|/g;
513 s/(^|[^|])\b$aliasr[:=]/$1$class#$alias:/g;
514 warn " *** Rewriting: $alias ($aliasr) as $class\n" if $self->debug;
517 if (!$seen_classes{$class}) {
518 $search_class_re .= '|' unless ($first_class);
521 $search_class_re .= $class . '(?:[|#][^:|]+)*';
522 $seen_classes{$class} = 1;
525 $search_class_re .= '):';
527 warn " ** Rewritten query: $_\n" if $self->debug;
528 warn " ** Search class RE: $search_class_re\n" if $self->debug;
530 my $required_re = $pkg->operator('required');
531 $required_re = qr/\Q$required_re\E/;
533 my $disallowed_re = $pkg->operator('disallowed');
534 $disallowed_re = qr/\Q$disallowed_re\E/;
536 my $and_re = $pkg->operator('and');
537 $and_re = qr/^\s*\Q$and_re\E/;
539 my $or_re = $pkg->operator('or');
540 $or_re = qr/^\s*\Q$or_re\E/;
542 my $group_start_re = $pkg->operator('group_start');
543 $group_start_re = qr/^\s*\Q$group_start_re\E/;
545 my $group_end = $pkg->operator('group_end');
546 my $group_end_re = qr/^\s*\Q$group_end\E/;
548 my $modifier_tag_re = $pkg->operator('modifier');
549 $modifier_tag_re = qr/^\s*\Q$modifier_tag_re\E/;
552 # Build the filter and modifier uber-regexps
553 my $facet_re = '^\s*(-?)((?:' . join( '|', @{$pkg->facet_classes}) . ')(?:\|\w+)*)\[(.+?)\]';
554 warn " ** Facet RE: $facet_re\n" if $self->debug;
556 my $filter_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . ')\(([^()]+)\)';
557 my $filter_as_class_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . '):\s*(\S+)';
559 my $modifier_re = '^\s*'.$modifier_tag_re.'(' . join( '|', @{$pkg->modifiers}) . ')\b';
560 my $modifier_as_class_re = '^\s*(' . join( '|', @{$pkg->modifiers}) . '):\s*(\S+)';
562 my $struct = $self->new_plan( level => $recursing );
566 while (!$remainder) {
567 if (/^\s*$/) { # end of an explicit group
569 } elsif (/$group_end_re/) { # end of an explicit group
570 warn "Encountered explicit group end\n" if $self->debug;
573 $remainder = $struct->top_plan ? '' : $';
576 } elsif ($self->filter_count && /$filter_re/) { # found a filter
577 warn "Encountered search filter: $1$2 set to $3\n" if $self->debug;
579 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
583 my $params = [ split '[,]+', $3 ];
585 if ($pkg->filter_callbacks->{$filter}) {
586 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
587 $_ = "$replacement $_" if ($replacement);
589 $struct->new_filter( $filter => $params, $negate );
594 } elsif ($self->filter_count && /$filter_as_class_re/) { # found a filter
595 warn "Encountered search filter: $1$2 set to $3\n" if $self->debug;
597 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
601 my $params = [ split '[,]+', $3 ];
603 if ($pkg->filter_callbacks->{$filter}) {
604 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
605 $_ = "$replacement $_" if ($replacement);
607 $struct->new_filter( $filter => $params, $negate );
611 } elsif ($self->modifier_count && /$modifier_re/) { # found a modifier
612 warn "Encountered search modifier: $1\n" if $self->debug;
615 if (!$struct->top_plan) {
616 warn " Search modifiers only allowed at the top level of the query\n" if $self->debug;
618 $struct->new_modifier($1);
622 } elsif ($self->modifier_count && /$modifier_as_class_re/) { # found a modifier
623 warn "Encountered search modifier: $1\n" if $self->debug;
628 if (!$struct->top_plan) {
629 warn " Search modifiers only allowed at the top level of the query\n" if $self->debug;
630 } elsif ($2 =~ /^[ty1]/i) {
631 $struct->new_modifier($mod);
635 } elsif (/$group_start_re/) { # start of an explicit group
636 warn "Encountered explicit group start\n" if $self->debug;
638 my ($substruct, $subremainder) = $self->decompose( $', $current_class, $recursing + 1 );
639 $struct->add_node( $substruct ) if ($substruct);
643 } elsif (/$and_re/) { # ANDed expression
645 next if ($last_type eq 'AND');
646 next if ($last_type eq 'OR');
647 warn "Encountered AND\n" if $self->debug;
650 my ($RHS, $subremainder) = $self->decompose( $_, $current_class, $recursing + 1 );
653 $struct = $self->new_plan( level => $recursing, joiner => '&' );
654 $struct->add_node($_) for ($LHS, $RHS);
657 } elsif (/$or_re/) { # ORed expression
659 next if ($last_type eq 'AND');
660 next if ($last_type eq 'OR');
661 warn "Encountered OR\n" if $self->debug;
664 my ($RHS, $subremainder) = $self->decompose( $_, $current_class, $recursing + 1 );
667 $struct = $self->new_plan( level => $recursing, joiner => '|' );
668 $struct->add_node($_) for ($LHS, $RHS);
671 } elsif ($self->facet_class_count && /$facet_re/) { # changing current class
672 warn "Encountered facet: $1$2 => $3\n" if $self->debug;
674 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
676 my $facet_value = [ split '\s*#\s*', $3 ];
677 $struct->new_facet( $facet => $facet_value, $negate );
681 } elsif ($self->search_class_count && /$search_class_re/) { # changing current class
683 if ($last_type eq 'CLASS') {
684 $struct->remove_last_node( $current_class );
685 warn "Encountered class change with no searches!\n" if $self->debug;
688 warn "Encountered class change: $1\n" if $self->debug;
690 $current_class = $struct->classed_node( $1 )->requested_class();
693 $last_type = 'CLASS';
694 } elsif (/^\s*($required_re|$disallowed_re)?"([^"]+)"/) { # phrase, always anded
695 warn 'Encountered' . ($1 ? " ['$1' modified]" : '') . " phrase: $2\n" if $self->debug;
697 my $req_ness = $1 || '';
700 if (!$phrase_helper) {
701 warn "Recursing into decompose with the phrase as a subquery\n" if $self->debug;
703 my ($substruct, $subremainder) = $self->decompose( qq/$req_ness"$phrase"/, $current_class, $recursing + 1, 1 );
704 $struct->add_node( $substruct ) if ($substruct);
707 warn "Directly parsing the phrase subquery\n" if $self->debug;
708 $struct->joiner( '&' );
710 my $class_node = $struct->classed_node($current_class);
712 if ($req_ness eq $pkg->operator('disallowed')) {
713 $class_node->add_dummy_atom( node => $class_node );
714 $class_node->add_unphrase( $phrase );
716 #$phrase =~ s/(^|\s)\b/$1-/g;
718 $class_node->add_phrase( $phrase );
726 # } elsif (/^\s*$required_re([^\s"]+)/) { # phrase, always anded
727 # warn "Encountered required atom (mini phrase): $1\n" if $self->debug;
731 # my $class_node = $struct->classed_node($current_class);
732 # $class_node->add_phrase( $phrase );
734 # $struct->joiner( '&' );
737 } elsif (/^\s*([^$group_end\s]+)/o) { # atom
738 warn "Encountered atom: $1\n" if $self->debug;
739 warn "Remainder: $'\n" if $self->debug;
747 my $class_node = $struct->classed_node($current_class);
749 my $prefix = ($atom =~ s/^$disallowed_re//o) ? '!' : '';
750 my $truncate = ($atom =~ s/\*$//o) ? '*' : '';
752 if ($atom ne '' and !grep { $atom =~ /^\Q$_\E+$/ } ('&','|','-','+')) { # throw away & and |, not allowed in tsquery, and not really useful anyway
753 # $class_node->add_phrase( $atom ) if ($atom =~ s/^$required_re//o);
754 # $class_node->add_unphrase( $atom ) if ($prefix eq '!');
756 $class_node->add_fts_atom( $atom, suffix => $truncate, prefix => $prefix, node => $class_node );
757 $struct->joiner( '&' );
766 scalar(@{$struct->query_nodes}) == 0 &&
767 scalar(@{$struct->filters}) == 0 &&
770 return $struct if !wantarray;
771 return ($struct, $remainder);
774 sub find_class_index {
778 my ($class_part, @field_parts) = split '\|', $class;
779 $class_part ||= $class;
781 for my $idx ( 0 .. scalar(@$query) - 1 ) {
782 next unless ref($$query[$idx]);
783 return $idx if ( $$query[$idx]{requested_class} && $class eq $$query[$idx]{requested_class} );
786 push(@$query, { classname => $class_part, (@field_parts ? (fields => \@field_parts) : ()), requested_class => $class, ftsquery => [], phrases => [] });
793 $self->{core_limit} = $l if ($l);
794 return $self->{core_limit};
800 $self->{superpage} = $l if ($l);
801 return $self->{superpage};
807 $self->{superpage_size} = $l if ($l);
808 return $self->{superpage_size};
812 #-------------------------------
813 package QueryParser::_util;
815 # At this level, joiners are always & or |. This is not
816 # the external, configurable representation of joiners that
817 # defaults to # && and ||.
821 return (not ref $str and ($str eq '&' or $str eq '|'));
824 sub default_joiner { '&' }
826 # 0 for different, 1 for the same.
827 sub compare_abstract_atoms {
828 my ($left, $right) = @_;
830 foreach (qw/prefix suffix content/) {
831 no warnings; # undef can stand in for '' here
832 return 0 unless $left->{$_} eq $right->{$_};
838 sub fake_abstract_atom_from_phrase {
839 my ($phrase, $neg) = @_;
844 $QueryParser::parser_config{QueryParser}{operators}{disallowed} .
849 "type" => "atom", "prefix" => $prefix, "suffix" => '"',
854 sub find_arrays_in_abstract {
858 foreach my $key (keys %$hash) {
859 if (ref $hash->{$key} eq "ARRAY") {
860 push @arrays, $hash->{$key};
861 foreach (@{$hash->{$key}}) {
862 push @arrays, find_arrays_in_abstract($_);
870 #-------------------------------
871 package QueryParser::Canonicalize; # not OO
873 sub _abstract_query2str_filter {
875 my $qpconfig = $parser_config{QueryParser};
879 $f->{negate} ? $qpconfig->{operators}{disallowed} : "",
881 join(",", @{$f->{args}})
885 sub _abstract_query2str_modifier {
887 my $qpconfig = $parser_config{QueryParser};
889 return $qpconfig->{operators}{modifier} . $f;
892 # This should produce an equivalent query to the original, given an
894 sub abstract_query2str_impl {
895 my ($abstract_query, $depth) = @_;
897 my $qpconfig = $parser_config{QueryParser};
899 my $gs = $qpconfig->{operators}{group_start};
900 my $ge = $qpconfig->{operators}{group_end};
901 my $and = $qpconfig->{operators}{and};
902 my $or = $qpconfig->{operators}{or};
905 $q .= $gs if $abstract_query->{type} and $abstract_query->{type} eq "query_plan" and $depth;
907 if (exists $abstract_query->{type}) {
908 if ($abstract_query->{type} eq 'query_plan') {
909 $q .= join(" ", map { _abstract_query2str_filter($_) } @{$abstract_query->{filters}}) if
910 exists $abstract_query->{filters};
913 $q .= join(" ", map { _abstract_query2str_modifier($_) } @{$abstract_query->{modifiers}}) if
914 exists $abstract_query->{modifiers};
915 } elsif ($abstract_query->{type} eq 'node') {
916 if ($abstract_query->{alias}) {
917 $q .= " " . $abstract_query->{alias};
918 $q .= "|$_" foreach @{$abstract_query->{alias_fields}};
920 $q .= " " . $abstract_query->{class};
921 $q .= "|$_" foreach @{$abstract_query->{fields}};
924 } elsif ($abstract_query->{type} eq 'atom') {
925 my $prefix = $abstract_query->{prefix} || '';
926 $prefix = $qpconfig->{operators}{disallowed} if $prefix eq '!';
928 ($abstract_query->{content} || '') .
929 ($abstract_query->{suffix} || '');
930 } elsif ($abstract_query->{type} eq 'facet') {
931 # facet syntax [ # ] is hardcoded I guess?
932 my $prefix = $abstract_query->{negate} ? $qpconfig->{operators}{disallowed} : '';
933 $q .= $prefix . $abstract_query->{name} . "[" .
934 join(" # ", @{$abstract_query->{values}}) . "]";
938 if (exists $abstract_query->{children}) {
939 my $op = (keys(%{$abstract_query->{children}}))[0];
941 " " . ($op eq '&' ? $and : $or) . " ",
943 abstract_query2str_impl($_, $depth + 1)
944 } @{$abstract_query->{children}{$op}}
946 } elsif ($abstract_query->{'&'} or $abstract_query->{'|'}) {
947 my $op = (keys(%{$abstract_query}))[0];
949 " " . ($op eq '&' ? $and : $or) . " ",
951 abstract_query2str_impl($_, $depth + 1)
952 } @{$abstract_query->{$op}}
957 $q .= $ge if $abstract_query->{type} and $abstract_query->{type} eq "query_plan" and $depth;
962 #-------------------------------
963 package QueryParser::query_plan;
967 return undef unless ref($self);
968 return $self->{QueryParser};
973 $pkg = ref($pkg) || $pkg;
974 my %args = (query => [], joiner => '&', @_);
976 return bless \%args => $pkg;
981 my $pkg = ref($self) || $self;
982 my $node = do{$pkg.'::node'}->new( plan => $self, @_ );
983 $self->add_node( $node );
989 my $pkg = ref($self) || $self;
994 my $node = do{$pkg.'::facet'}->new( plan => $self, name => $name, 'values' => $args, negate => $negate );
995 $self->add_node( $node );
1002 my $pkg = ref($self) || $self;
1007 my $node = do{$pkg.'::filter'}->new( plan => $self, name => $name, args => $args, negate => $negate );
1008 $self->add_filter( $node );
1014 sub _merge_filters {
1015 my $left_filter = shift;
1016 my $right_filter = shift;
1019 return undef unless $left_filter or $right_filter;
1020 return $right_filter unless $left_filter;
1021 return $left_filter unless $right_filter;
1023 my $args = $left_filter->{args} || [];
1026 push(@$args, @{$right_filter->{args}});
1029 # find the intersect values
1031 map { $new_vals{$_} = 1 } @{$right_filter->{args} || []};
1032 $args = [ grep { $new_vals{$_} } @$args ];
1035 $left_filter->{args} = $args;
1036 return $left_filter;
1039 sub collapse_filters {
1043 # start by merging any filters at this level.
1044 # like-level filters are always ORed together
1047 my @cur_filters = grep {$_->name eq $name } @{ $self->filters };
1049 $cur_filter = shift @cur_filters;
1050 my $args = $cur_filter->{args} || [];
1051 $cur_filter = _merge_filters($cur_filter, $_, '|') for @cur_filters;
1054 # next gather the collapsed filters from sub-plans and
1055 # merge them with our own
1057 my @subquery = @{$self->{query}};
1060 my $blob = shift @subquery;
1061 shift @subquery; # joiner
1062 next unless $blob->isa('QueryParser::query_plan');
1063 my $sub_filter = $blob->collapse_filters($name);
1064 $cur_filter = _merge_filters($cur_filter, $sub_filter, $self->joiner);
1067 if ($self->QueryParser->debug) {
1068 my @args = ($cur_filter and $cur_filter->{args}) ? @{$cur_filter->{args}} : ();
1069 warn "collapse_filters($name) => [@args]\n";
1077 my $needle = shift;;
1078 return undef unless ($needle);
1080 my $filter = $self->collapse_filters($needle);
1082 warn "find_filter($needle) => " .
1083 (($filter and $filter->{args}) ? "@{$filter->{args}}" : '[]') . "\n"
1084 if $self->QueryParser->debug;
1086 return $filter ? ($filter) : ();
1091 my $needle = shift;;
1092 return undef unless ($needle);
1093 return grep { $_->name eq $needle } @{ $self->modifiers };
1098 my $pkg = ref($self) || $self;
1101 my $node = do{$pkg.'::modifier'}->new( $name );
1102 $self->add_modifier( $node );
1109 my $requested_class = shift;
1112 for my $n (@{$self->{query}}) {
1113 next unless (ref($n) && $n->isa( 'QueryParser::query_plan::node' ));
1114 if ($n->requested_class eq $requested_class) {
1121 $node = $self->new_node;
1122 $node->requested_class( $requested_class );
1128 sub remove_last_node {
1130 my $requested_class = shift;
1132 my $old = pop(@{$self->query_nodes});
1133 pop(@{$self->query_nodes}) if (@{$self->query_nodes});
1140 return $self->{query};
1147 $self->{query} ||= [];
1148 push(@{$self->{query}}, $self->joiner) if (@{$self->{query}});
1149 push(@{$self->{query}}, $node);
1157 return $self->{level} ? 0 : 1;
1162 return $self->{level};
1169 $self->{joiner} = $joiner if ($joiner);
1170 return $self->{joiner};
1175 $self->{modifiers} ||= [];
1176 return $self->{modifiers};
1181 my $modifier = shift;
1183 $self->{modifiers} ||= [];
1184 $self->{modifiers} = [ grep {$_->name ne $modifier->name} @{$self->{modifiers}} ];
1186 push(@{$self->{modifiers}}, $modifier);
1193 $self->{facets} ||= [];
1194 return $self->{facets};
1201 $self->{facets} ||= [];
1202 $self->{facets} = [ grep {$_->name ne $facet->name} @{$self->{facets}} ];
1204 push(@{$self->{facets}}, $facet);
1211 $self->{filters} ||= [];
1212 return $self->{filters};
1219 $self->{filters} ||= [];
1221 push(@{$self->{filters}}, $filter);
1226 # %opts supports two options at this time:
1228 # If true, do not do anything to the phrases and unphrases
1229 # fields on any discovered nodes.
1231 # If true, also return the query parser config as part of the blob.
1232 # This will get set back to 0 before recursion to avoid repetition.
1233 sub to_abstract_query {
1237 my $pkg = ref $self->QueryParser || $self->QueryParser;
1239 my $abstract_query = {
1240 type => "query_plan",
1241 filters => [map { $_->to_abstract_query } @{$self->filters}],
1242 modifiers => [map { $_->to_abstract_query } @{$self->modifiers}]
1245 if ($opts{with_config}) {
1246 $opts{with_config} = 0;
1247 $abstract_query->{config} = $QueryParser::parser_config{$pkg};
1252 for my $qnode (@{$self->query_nodes}) {
1253 # Remember: qnode can be a joiner string, a node, or another query_plan
1255 if (QueryParser::_util::is_joiner($qnode)) {
1256 if ($abstract_query->{children}) {
1257 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1258 next if $open_joiner eq $qnode;
1260 my $oldroot = $abstract_query->{children};
1262 $abstract_query->{children} = {$qnode => $kids};
1264 $abstract_query->{children} = {$qnode => $kids};
1267 push @$kids, $qnode->to_abstract_query(%opts);
1271 $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1272 return $abstract_query;
1276 #-------------------------------
1277 package QueryParser::query_plan::node;
1279 $Data::Dumper::Indent = 0;
1283 $pkg = ref($pkg) || $pkg;
1286 return bless \%args => $pkg;
1291 my $pkg = ref($self) || $self;
1292 return do{$pkg.'::atom'}->new( @_ );
1295 sub requested_class { # also split into classname, fields and alias
1301 my (undef, $alias) = split '#', $class;
1303 $class =~ s/#[^|]+//;
1304 ($alias, @afields) = split '\|', $alias;
1307 my @fields = @afields;
1308 my ($class_part, @field_parts) = split '\|', $class;
1309 for my $f (@field_parts) {
1310 push(@fields, $f) unless (grep { $f eq $_ } @fields);
1313 $class_part ||= $class;
1315 $self->{requested_class} = $class;
1316 $self->{alias} = $alias if $alias;
1317 $self->{alias_fields} = \@afields if $alias;
1318 $self->{classname} = $class_part;
1319 $self->{fields} = \@fields;
1322 return $self->{requested_class};
1329 $self->{plan} = $plan if ($plan);
1330 return $self->{plan};
1337 $self->{alias} = $alias if ($alias);
1338 return $self->{alias};
1345 $self->{alias_fields} = $alias if ($alias);
1346 return $self->{alias_fields};
1353 $self->{classname} = $class if ($class);
1354 return $self->{classname};
1361 $self->{fields} ||= [];
1362 $self->{fields} = \@fields if (@fields);
1363 return $self->{fields};
1370 $self->{phrases} ||= [];
1371 $self->{phrases} = \@phrases if (@phrases);
1372 return $self->{phrases};
1379 $self->{unphrases} ||= [];
1380 $self->{unphrases} = \@phrases if (@phrases);
1381 return $self->{unphrases};
1388 push(@{$self->phrases}, $phrase);
1397 push(@{$self->unphrases}, $phrase);
1404 my @query_atoms = @_;
1406 $self->{query_atoms} ||= [];
1407 $self->{query_atoms} = \@query_atoms if (@query_atoms);
1408 return $self->{query_atoms};
1416 my $content = $atom;
1419 $atom = $self->new_atom( content => $content, @parts );
1422 push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1423 push(@{$self->query_atoms}, $atom);
1428 sub add_dummy_atom {
1432 my $atom = $self->new_atom( @parts, dummy => 1 );
1434 push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1435 push(@{$self->query_atoms}, $atom);
1440 # This will find up to one occurence of @$short_list within @$long_list, and
1441 # replace it with the single atom $replacement.
1442 sub replace_phrase_in_abstract_query {
1443 my ($self, $short_list, $long_list, $replacement) = @_;
1447 my $goal = scalar @$short_list;
1449 for (my $i = 0; $i < scalar (@$long_list); $i++) {
1450 my $right = $long_list->[$i];
1452 if (QueryParser::_util::compare_abstract_atoms(
1453 $short_list->[scalar @already], $right
1456 } elsif (scalar @already) {
1461 if (scalar @already == $goal) {
1462 splice @$long_list, $already[0], scalar(@already), $replacement;
1471 sub to_abstract_query {
1475 my $pkg = ref $self->plan->QueryParser || $self->plan->QueryParser;
1477 my $abstract_query = {
1479 "alias" => $self->alias,
1480 "alias_fields" => $self->alias_fields,
1481 "class" => $self->classname,
1482 "fields" => $self->fields
1487 for my $qatom (@{$self->query_atoms}) {
1488 if (QueryParser::_util::is_joiner($qatom)) {
1489 if ($abstract_query->{children}) {
1490 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1491 next if $open_joiner eq $qatom;
1493 my $oldroot = $abstract_query->{children};
1495 $abstract_query->{children} = {$qatom => $kids};
1497 $abstract_query->{children} = {$qatom => $kids};
1500 push @$kids, $qatom->to_abstract_query;
1504 if ($self->{phrases} and not $opts{no_phrases}) {
1505 for my $phrase (@{$self->{phrases}}) {
1506 # Phrases appear duplication in a real QP tree, and we don't want
1507 # that duplication in our abstract query. So for all our phrases,
1508 # break them into atoms as QP would, and remove any matching
1509 # sequences of atoms from our abstract query.
1511 my $tmptree = $self->{plan}->{QueryParser}->new(query => '"'.$phrase.'"')->parse->parse_tree;
1513 # For a well-behaved phrase, we should now have only one node
1514 # in the $tmptree query plan, and that node should have an
1515 # orderly list of atoms and joiners.
1517 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
1521 $tmplist = $tmptree->{query}->[0]->to_abstract_query(
1523 )->{children}->{'&'}->[0]->{children}->{'&'};
1528 QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
1530 last if $self->replace_phrase_in_abstract_query(
1533 QueryParser::_util::fake_abstract_atom_from_phrase($phrase)
1541 # Do the same as the preceding block for unphrases (negated phrases).
1542 if ($self->{unphrases} and not $opts{no_phrases}) {
1543 for my $phrase (@{$self->{unphrases}}) {
1544 my $tmptree = $self->{plan}->{QueryParser}->new(
1545 query => $QueryParser::parser_config{$pkg}{operators}{disallowed}.
1547 )->parse->parse_tree;
1550 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
1554 $tmplist = $tmptree->{query}->[0]->to_abstract_query(
1556 )->{children}->{'&'}->[0]->{children}->{'&'};
1561 QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
1563 last if $self->replace_phrase_in_abstract_query(
1566 QueryParser::_util::fake_abstract_atom_from_phrase($phrase, 1)
1574 $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1575 return $abstract_query;
1578 #-------------------------------
1579 package QueryParser::query_plan::node::atom;
1583 $pkg = ref($pkg) || $pkg;
1586 return bless \%args => $pkg;
1591 return undef unless (ref $self);
1592 return $self->{node};
1597 return undef unless (ref $self);
1598 return $self->{content};
1603 return undef unless (ref $self);
1604 return $self->{prefix};
1609 return undef unless (ref $self);
1610 return $self->{suffix};
1613 sub to_abstract_query {
1617 (map { $_ => $self->$_ } qw/prefix suffix content/),
1621 #-------------------------------
1622 package QueryParser::query_plan::filter;
1626 $pkg = ref($pkg) || $pkg;
1629 return bless \%args => $pkg;
1634 return $self->{plan};
1639 return $self->{name};
1644 return $self->{negate};
1649 return $self->{args};
1652 sub to_abstract_query {
1656 map { $_ => $self->$_ } qw/name negate args/
1660 #-------------------------------
1661 package QueryParser::query_plan::facet;
1665 $pkg = ref($pkg) || $pkg;
1668 return bless \%args => $pkg;
1673 return $self->{plan};
1678 return $self->{name};
1683 return $self->{negate};
1688 return $self->{'values'};
1691 sub to_abstract_query {
1695 (map { $_ => $self->$_ } qw/name negate values/),
1700 #-------------------------------
1701 package QueryParser::query_plan::modifier;
1705 $pkg = ref($pkg) || $pkg;
1706 my $modifier = shift;
1709 return bless { name => $modifier, negate => $negate } => $pkg;
1714 return $self->{name};
1719 return $self->{negate};
1722 sub to_abstract_query {