5 use OpenSRF::Utils::JSON;
26 return QueryParser::Canonicalize::abstract_query2str_impl(
27 $self->parse_tree->to_abstract_query(@_)
32 sub facet_class_count {
34 return @{$self->facet_classes};
37 sub search_class_count {
39 return @{$self->search_classes};
44 return @{$self->filters};
49 return @{$self->modifiers};
54 $class = ref($class) || $class;
56 $parser_config{$class}{custom_data} ||= {};
57 return $parser_config{$class}{custom_data};
62 $class = ref($class) || $class;
64 $parser_config{$class}{operators} ||= {};
65 return $parser_config{$class}{operators};
70 $class = ref($class) || $class;
72 $parser_config{$class}{filters} ||= [];
73 return $parser_config{$class}{filters};
76 sub filter_callbacks {
78 $class = ref($class) || $class;
80 $parser_config{$class}{filter_callbacks} ||= {};
81 return $parser_config{$class}{filter_callbacks};
86 $class = ref($class) || $class;
88 $parser_config{$class}{modifiers} ||= [];
89 return $parser_config{$class}{modifiers};
94 $class = ref($class) || $class;
98 my $self = bless {} => $class;
100 for my $o (keys %{QueryParser->operators}) {
101 $class->operator($o => QueryParser->operator($o)) unless ($class->operator($o));
104 for my $opt ( keys %opts) {
105 $self->$opt( $opts{$opt} ) if ($self->can($opt));
113 my $pkg = ref($self) || $self;
114 return do{$pkg.'::query_plan'}->new( QueryParser => $self, @_ );
117 sub add_search_filter {
119 $pkg = ref($pkg) || $pkg;
121 my $callback = shift;
123 return $filter if (grep { $_ eq $filter } @{$pkg->filters});
124 push @{$pkg->filters}, $filter;
125 $pkg->filter_callbacks->{$filter} = $callback if ($callback);
129 sub add_search_modifier {
131 $pkg = ref($pkg) || $pkg;
132 my $modifier = shift;
134 return $modifier if (grep { $_ eq $modifier } @{$pkg->modifiers});
135 push @{$pkg->modifiers}, $modifier;
139 sub add_facet_class {
141 $pkg = ref($pkg) || $pkg;
144 return $class if (grep { $_ eq $class } @{$pkg->facet_classes});
146 push @{$pkg->facet_classes}, $class;
147 $pkg->facet_fields->{$class} = [];
152 sub add_search_class {
154 $pkg = ref($pkg) || $pkg;
157 return $class if (grep { $_ eq $class } @{$pkg->search_classes});
159 push @{$pkg->search_classes}, $class;
160 $pkg->search_fields->{$class} = [];
161 $pkg->default_search_class( $pkg->search_classes->[0] ) if (@{$pkg->search_classes} == 1);
168 $class = ref($class) || $class;
172 return undef unless ($opname);
174 $parser_config{$class}{operators} ||= {};
175 $parser_config{$class}{operators}{$opname} = $op if ($op);
177 return $parser_config{$class}{operators}{$opname};
182 $class = ref($class) || $class;
185 $parser_config{$class}{facet_classes} ||= [];
186 $parser_config{$class}{facet_classes} = $classes if (ref($classes) && @$classes);
187 return $parser_config{$class}{facet_classes};
192 $class = ref($class) || $class;
195 $parser_config{$class}{classes} ||= [];
196 $parser_config{$class}{classes} = $classes if (ref($classes) && @$classes);
197 return $parser_config{$class}{classes};
200 sub add_query_normalizer {
202 $pkg = ref($pkg) || $pkg;
206 my $params = shift || [];
208 # do not add if function AND params are identical to existing member
209 return $func if (grep {
210 $_->{function} eq $func and
211 OpenSRF::Utils::JSON->perl2JSON($_->{params}) eq OpenSRF::Utils::JSON->perl2JSON($params)
212 } @{$pkg->query_normalizers->{$class}->{$field}});
214 push(@{$pkg->query_normalizers->{$class}->{$field}}, { function => $func, params => $params });
219 sub query_normalizers {
221 $pkg = ref($pkg) || $pkg;
226 $parser_config{$pkg}{normalizers} ||= {};
229 $parser_config{$pkg}{normalizers}{$class}{$field} ||= [];
230 return $parser_config{$pkg}{normalizers}{$class}{$field};
232 return $parser_config{$pkg}{normalizers}{$class};
236 return $parser_config{$pkg}{normalizers};
239 sub add_filter_normalizer {
241 $pkg = ref($pkg) || $pkg;
244 my $params = shift || [];
246 return $func if (grep { $_ eq $func } @{$pkg->filter_normalizers->{$filter}});
248 push(@{$pkg->filter_normalizers->{$filter}}, { function => $func, params => $params });
253 sub filter_normalizers {
255 $pkg = ref($pkg) || $pkg;
259 $parser_config{$pkg}{filter_normalizers} ||= {};
261 $parser_config{$pkg}{filter_normalizers}{$filter} ||= [];
262 return $parser_config{$pkg}{filter_normalizers}{$filter};
265 return $parser_config{$pkg}{filter_normalizers};
268 sub default_search_class {
270 $pkg = ref($pkg) || $pkg;
272 $QueryParser::parser_config{$pkg}{default_class} = $pkg->add_search_class( $class ) if $class;
274 return $QueryParser::parser_config{$pkg}{default_class};
277 sub remove_facet_class {
279 $pkg = ref($pkg) || $pkg;
282 return $class if (!grep { $_ eq $class } @{$pkg->facet_classes});
284 $pkg->facet_classes( [ grep { $_ ne $class } @{$pkg->facet_classes} ] );
285 delete $QueryParser::parser_config{$pkg}{facet_fields}{$class};
290 sub remove_search_class {
292 $pkg = ref($pkg) || $pkg;
295 return $class if (!grep { $_ eq $class } @{$pkg->search_classes});
297 $pkg->search_classes( [ grep { $_ ne $class } @{$pkg->search_classes} ] );
298 delete $QueryParser::parser_config{$pkg}{fields}{$class};
303 sub add_facet_field {
305 $pkg = ref($pkg) || $pkg;
309 $pkg->add_facet_class( $class );
311 return { $class => $field } if (grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
313 push @{$pkg->facet_fields->{$class}}, $field;
315 return { $class => $field };
320 $class = ref($class) || $class;
322 $parser_config{$class}{facet_fields} ||= {};
323 return $parser_config{$class}{facet_fields};
326 sub add_search_field {
328 $pkg = ref($pkg) || $pkg;
332 $pkg->add_search_class( $class );
334 return { $class => $field } if (grep { $_ eq $field } @{$pkg->search_fields->{$class}});
336 push @{$pkg->search_fields->{$class}}, $field;
338 return { $class => $field };
343 $class = ref($class) || $class;
345 $parser_config{$class}{fields} ||= {};
346 return $parser_config{$class}{fields};
349 sub add_search_class_alias {
351 $pkg = ref($pkg) || $pkg;
355 $pkg->add_search_class( $class );
357 return { $class => $alias } if (grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
359 push @{$pkg->search_class_aliases->{$class}}, $alias;
361 return { $class => $alias };
364 sub search_class_aliases {
366 $class = ref($class) || $class;
368 $parser_config{$class}{class_map} ||= {};
369 return $parser_config{$class}{class_map};
372 sub add_search_field_alias {
374 $pkg = ref($pkg) || $pkg;
379 return { $class => { $field => $alias } } if (grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
381 push @{$pkg->search_field_aliases->{$class}{$field}}, $alias;
383 return { $class => { $field => $alias } };
386 sub search_field_aliases {
388 $class = ref($class) || $class;
390 $parser_config{$class}{field_alias_map} ||= {};
391 return $parser_config{$class}{field_alias_map};
394 sub remove_facet_field {
396 $pkg = ref($pkg) || $pkg;
400 return { $class => $field } if (!$pkg->facet_fields->{$class} || !grep { $_ eq $field } @{$pkg->facet_fields->{$class}});
402 $pkg->facet_fields->{$class} = [ grep { $_ ne $field } @{$pkg->facet_fields->{$class}} ];
404 return { $class => $field };
407 sub remove_search_field {
409 $pkg = ref($pkg) || $pkg;
413 return { $class => $field } if (!$pkg->search_fields->{$class} || !grep { $_ eq $field } @{$pkg->search_fields->{$class}});
415 $pkg->search_fields->{$class} = [ grep { $_ ne $field } @{$pkg->search_fields->{$class}} ];
417 return { $class => $field };
420 sub remove_search_field_alias {
422 $pkg = ref($pkg) || $pkg;
427 return { $class => { $field => $alias } } if (!$pkg->search_field_aliases->{$class}{$field} || !grep { $_ eq $alias } @{$pkg->search_field_aliases->{$class}{$field}});
429 $pkg->search_field_aliases->{$class}{$field} = [ grep { $_ ne $alias } @{$pkg->search_field_aliases->{$class}{$field}} ];
431 return { $class => { $field => $alias } };
434 sub remove_search_class_alias {
436 $pkg = ref($pkg) || $pkg;
440 return { $class => $alias } if (!$pkg->search_class_aliases->{$class} || !grep { $_ eq $alias } @{$pkg->search_class_aliases->{$class}});
442 $pkg->search_class_aliases->{$class} = [ grep { $_ ne $alias } @{$pkg->search_class_aliases->{$class}} ];
444 return { $class => $alias };
450 $self->{_debug} = $q if (defined $q);
451 return $self->{_debug};
457 $self->{_query} = " $q " if (defined $q);
458 return $self->{_query};
464 $self->{_parse_tree} = $q if (defined $q);
465 return $self->{_parse_tree};
471 $self->{_top} = $q if (defined $q);
472 return $self->{_top};
477 my $pkg = ref($self) || $self;
478 warn " ** parse package is $pkg\n" if $self->debug;
481 # $self->query( shift() )
485 $self->decompose( $self->query( shift() ) );
487 if ($self->floating_plan) {
488 $self->floating_plan->add_node( $self->parse_tree );
489 $self->parse_tree( $self->floating_plan );
496 my $pkg = ref($self) || $self;
498 warn " ** decompose package is $pkg\n" if $self->debug;
501 my $current_class = shift || $self->default_search_class;
503 my $recursing = shift || 0;
504 my $phrase_helper = shift || 0;
506 # Build the search class+field uber-regexp
507 my $search_class_re = '^\s*(';
511 for my $class ( keys %{$pkg->search_field_aliases} ) {
512 warn " *** ... Looking for search fields in $class\n" if $self->debug;
514 for my $field ( keys %{$pkg->search_field_aliases->{$class}} ) {
515 warn " *** ... Looking for aliases of $field\n" if $self->debug;
517 for my $alias ( @{$pkg->search_field_aliases->{$class}{$field}} ) {
518 my $aliasr = qr/$alias/;
519 s/(^|\s+)$aliasr\|/$1$class\|$field#$alias\|/g;
520 s/(^|\s+)$aliasr[:=]/$1$class\|$field#$alias:/g;
521 warn " *** Rewriting: $alias ($aliasr) as $class\|$field\n" if $self->debug;
525 $search_class_re .= '|' unless ($first_class);
527 $search_class_re .= $class . '(?:[|#][^:|]+)*';
528 $seen_classes{$class} = 1;
531 for my $class ( keys %{$pkg->search_class_aliases} ) {
533 for my $alias ( @{$pkg->search_class_aliases->{$class}} ) {
534 my $aliasr = qr/$alias/;
535 s/(^|[^|])\b$aliasr\|/$1$class#$alias\|/g;
536 s/(^|[^|])\b$aliasr[:=]/$1$class#$alias:/g;
537 warn " *** Rewriting: $alias ($aliasr) as $class\n" if $self->debug;
540 if (!$seen_classes{$class}) {
541 $search_class_re .= '|' unless ($first_class);
544 $search_class_re .= $class . '(?:[|#][^:|]+)*';
545 $seen_classes{$class} = 1;
548 $search_class_re .= '):';
550 warn " ** Rewritten query: $_\n" if $self->debug;
551 warn " ** Search class RE: $search_class_re\n" if $self->debug;
553 my $required_re = $pkg->operator('required');
554 $required_re = qr/\Q$required_re\E/;
556 my $disallowed_re = $pkg->operator('disallowed');
557 $disallowed_re = qr/\Q$disallowed_re\E/;
559 my $and_re = $pkg->operator('and');
560 $and_re = qr/^\s*\Q$and_re\E/;
562 my $or_re = $pkg->operator('or');
563 $or_re = qr/^\s*\Q$or_re\E/;
565 my $group_start = $pkg->operator('group_start');
566 my $group_start_re = qr/^\s*\Q$group_start\E/;
568 my $group_end = $pkg->operator('group_end');
569 my $group_end_re = qr/^\s*\Q$group_end\E/;
571 my $float_start = $pkg->operator('float_start');
572 my $float_start_re = qr/^\s*\Q$float_start\E/;
574 my $float_end = $pkg->operator('float_end');
575 my $float_end_re = qr/^\s*\Q$float_end\E/;
577 my $modifier_tag_re = $pkg->operator('modifier');
578 $modifier_tag_re = qr/^\s*\Q$modifier_tag_re\E/;
581 # Build the filter and modifier uber-regexps
582 my $facet_re = '^\s*(-?)((?:' . join( '|', @{$pkg->facet_classes}) . ')(?:\|\w+)*)\[(.+?)\]';
583 warn " ** Facet RE: $facet_re\n" if $self->debug;
585 my $filter_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . ')\(([^()]+)\)';
586 my $filter_as_class_re = '^\s*(-?)(' . join( '|', @{$pkg->filters}) . '):\s*(\S+)';
588 my $modifier_re = '^\s*'.$modifier_tag_re.'(' . join( '|', @{$pkg->modifiers}) . ')\b';
589 my $modifier_as_class_re = '^\s*(' . join( '|', @{$pkg->modifiers}) . '):\s*(\S+)';
591 my $struct = shift || $self->new_plan( level => $recursing );
592 $self->parse_tree( $struct ) if (!$self->parse_tree);
597 while (!$remainder) {
598 if (/^\s*$/) { # end of an explicit group
600 } elsif (/$float_end_re/) { # end of an explicit group
601 warn "Encountered explicit float end\n" if $self->debug;
607 } elsif (/$group_end_re/) { # end of an explicit group
608 warn "Encountered explicit group end\n" if $self->debug;
611 $remainder = $struct->top_plan ? '' : $';
614 } elsif ($self->filter_count && /$filter_re/) { # found a filter
615 warn "Encountered search filter: $1$2 set to $3\n" if $self->debug;
617 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
621 my $params = [ split '[,]+', $3 ];
623 if ($pkg->filter_callbacks->{$filter}) {
624 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
625 $_ = "$replacement $_" if ($replacement);
627 $struct->new_filter( $filter => $params, $negate );
632 } elsif ($self->filter_count && /$filter_as_class_re/) { # found a filter
633 warn "Encountered search filter: $1$2 set to $3\n" if $self->debug;
635 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
639 my $params = [ split '[,]+', $3 ];
641 if ($pkg->filter_callbacks->{$filter}) {
642 my $replacement = $pkg->filter_callbacks->{$filter}->($self, $struct, $filter, $params, $negate);
643 $_ = "$replacement $_" if ($replacement);
645 $struct->new_filter( $filter => $params, $negate );
649 } elsif ($self->modifier_count && /$modifier_re/) { # found a modifier
650 warn "Encountered search modifier: $1\n" if $self->debug;
653 if (!($struct->top_plan || $parser_config{QueryParser}->{allow_nested_modifiers})) {
654 warn " Search modifiers only allowed at the top level of the query\n" if $self->debug;
656 $struct->new_modifier($1);
660 } elsif ($self->modifier_count && /$modifier_as_class_re/) { # found a modifier
661 warn "Encountered search modifier: $1\n" if $self->debug;
666 if (!($struct->top_plan || $parser_config{QueryParser}->{allow_nested_modifiers})) {
667 warn " Search modifiers only allowed at the top level of the query\n" if $self->debug;
668 } elsif ($2 =~ /^[ty1]/i) {
669 $struct->new_modifier($mod);
673 } elsif (/$float_start_re/) { # start of an explicit float
674 warn "Encountered explicit float start\n" if $self->debug;
676 $self->floating_plan( $self->new_plan( floating => 1 ) ) if (!$self->floating_plan);
677 # pass the floating_plan struct to be modified by the float'ed chunk
678 my ($floating_plan, $subremainder) = $self->new->decompose( $', undef, undef, undef, $self->floating_plan);
682 } elsif (/$group_start_re/) { # start of an explicit group
683 warn "Encountered explicit group start\n" if $self->debug;
685 my ($substruct, $subremainder) = $self->decompose( $', $current_class, $recursing + 1 );
686 $struct->add_node( $substruct ) if ($substruct);
690 } elsif (/$and_re/) { # ANDed expression
692 next if ($last_type eq 'AND');
693 next if ($last_type eq 'OR');
694 warn "Encountered AND\n" if $self->debug;
697 my ($RHS, $subremainder) = $self->decompose( "$group_start $_ $group_end", $current_class, $recursing + 1 );
700 $struct = $self->new_plan( level => $recursing, joiner => '&', floating => $LHS->floating );
701 if ($LHS->floating) {
702 $self->floating_plan($struct);
706 $struct->add_node($_) for ($LHS, $RHS);
708 $self->parse_tree( $struct ) if ($self->parse_tree == $LHS);
711 } elsif (/$or_re/) { # ORed expression
713 next if ($last_type eq 'AND');
714 next if ($last_type eq 'OR');
715 warn "Encountered OR\n" if $self->debug;
718 my ($RHS, $subremainder) = $self->decompose( "$group_start $_ $group_end", $current_class, $recursing + 1 );
721 $struct = $self->new_plan( level => $recursing, joiner => '|' );
722 $struct->add_node($_) for ($LHS, $RHS);
724 $self->parse_tree( $struct ) if ($self->parse_tree == $LHS);
727 } elsif ($self->facet_class_count && /$facet_re/) { # changing current class
728 warn "Encountered facet: $1$2 => $3\n" if $self->debug;
730 my $negate = ($1 eq $pkg->operator('disallowed')) ? 1 : 0;
732 my $facet_value = [ split '\s*#\s*', $3 ];
733 $struct->new_facet( $facet => $facet_value, $negate );
737 } elsif ($self->search_class_count && /$search_class_re/) { # changing current class
739 if ($last_type eq 'CLASS') {
740 $struct->remove_last_node( $current_class );
741 warn "Encountered class change with no searches!\n" if $self->debug;
744 warn "Encountered class change: $1\n" if $self->debug;
746 $current_class = $struct->classed_node( $1 )->requested_class();
749 $last_type = 'CLASS';
750 } elsif (/^\s*($required_re|$disallowed_re)?"([^"]+)"/) { # phrase, always anded
751 warn 'Encountered' . ($1 ? " ['$1' modified]" : '') . " phrase: $2\n" if $self->debug;
753 my $req_ness = $1 || '';
756 if (!$phrase_helper) {
757 warn "Recursing into decompose with the phrase as a subquery\n" if $self->debug;
759 my ($substruct, $subremainder) = $self->decompose( qq/$req_ness"$phrase"/, $current_class, $recursing + 1, 1 );
760 $struct->add_node( $substruct ) if ($substruct);
763 warn "Directly parsing the phrase subquery\n" if $self->debug;
764 $struct->joiner( '&' );
766 my $class_node = $struct->classed_node($current_class);
768 if ($req_ness eq $pkg->operator('disallowed')) {
769 $class_node->add_dummy_atom( node => $class_node );
770 $class_node->add_unphrase( $phrase );
772 #$phrase =~ s/(^|\s)\b/$1-/g;
774 $class_node->add_phrase( $phrase );
782 # } elsif (/^\s*$required_re([^\s"]+)/) { # phrase, always anded
783 # warn "Encountered required atom (mini phrase): $1\n" if $self->debug;
787 # my $class_node = $struct->classed_node($current_class);
788 # $class_node->add_phrase( $phrase );
790 # $struct->joiner( '&' );
793 } elsif (/^\s*([^${group_end}${float_end}\s]+)/o) { # atom
794 warn "Encountered atom: $1\n" if $self->debug;
795 warn "Remainder: $'\n" if $self->debug;
803 my $class_node = $struct->classed_node($current_class);
805 my $prefix = ($atom =~ s/^$disallowed_re//o) ? '!' : '';
806 my $truncate = ($atom =~ s/\*$//o) ? '*' : '';
808 if ($atom ne '' and !grep { $atom =~ /^\Q$_\E+$/ } ('&','|','-','+')) { # throw away & and |, not allowed in tsquery, and not really useful anyway
809 # $class_node->add_phrase( $atom ) if ($atom =~ s/^$required_re//o);
810 # $class_node->add_unphrase( $atom ) if ($prefix eq '!');
812 $class_node->add_fts_atom( $atom, suffix => $truncate, prefix => $prefix, node => $class_node );
813 $struct->joiner( '&' );
822 scalar(@{$struct->query_nodes}) == 0 &&
823 scalar(@{$struct->filters}) == 0 &&
826 return $struct if !wantarray;
827 return ($struct, $remainder);
830 sub find_class_index {
834 my ($class_part, @field_parts) = split '\|', $class;
835 $class_part ||= $class;
837 for my $idx ( 0 .. scalar(@$query) - 1 ) {
838 next unless ref($$query[$idx]);
839 return $idx if ( $$query[$idx]{requested_class} && $class eq $$query[$idx]{requested_class} );
842 push(@$query, { classname => $class_part, (@field_parts ? (fields => \@field_parts) : ()), requested_class => $class, ftsquery => [], phrases => [] });
849 $self->{core_limit} = $l if ($l);
850 return $self->{core_limit};
856 $self->{superpage} = $l if ($l);
857 return $self->{superpage};
863 $self->{superpage_size} = $l if ($l);
864 return $self->{superpage_size};
868 #-------------------------------
869 package QueryParser::_util;
871 # At this level, joiners are always & or |. This is not
872 # the external, configurable representation of joiners that
873 # defaults to # && and ||.
877 return (not ref $str and ($str eq '&' or $str eq '|'));
880 sub default_joiner { '&' }
882 # 0 for different, 1 for the same.
883 sub compare_abstract_atoms {
884 my ($left, $right) = @_;
886 foreach (qw/prefix suffix content/) {
887 no warnings; # undef can stand in for '' here
888 return 0 unless $left->{$_} eq $right->{$_};
894 sub fake_abstract_atom_from_phrase {
897 my $qp_class = shift || 'QueryParser';
902 $QueryParser::parser_config{$qp_class}{operators}{disallowed} .
907 "type" => "atom", "prefix" => $prefix, "suffix" => '"',
912 sub find_arrays_in_abstract {
916 foreach my $key (keys %$hash) {
917 if (ref $hash->{$key} eq "ARRAY") {
918 push @arrays, $hash->{$key};
919 foreach (@{$hash->{$key}}) {
920 push @arrays, find_arrays_in_abstract($_);
928 #-------------------------------
929 package QueryParser::Canonicalize; # not OO
931 sub _abstract_query2str_filter {
933 my $qp_class = shift || 'QueryParser';
934 my $qpconfig = $QueryParser::parser_config{$qp_class};
938 $f->{negate} ? $qpconfig->{operators}{disallowed} : "",
940 join(",", @{$f->{args}})
944 sub _abstract_query2str_modifier {
946 my $qp_class = shift || 'QueryParser';
947 my $qpconfig = $QueryParser::parser_config{$qp_class};
949 return $qpconfig->{operators}{modifier} . $f;
953 my $children = shift;
954 my $op = (keys %$children)[0];
955 return @{$$children{$op}};
958 # This should produce an equivalent query to the original, given an
960 sub abstract_query2str_impl {
961 my $abstract_query = shift;
962 my $depth = shift || 0;
964 my $qp_class ||= shift || 'QueryParser';
965 my $qpconfig = $QueryParser::parser_config{$qp_class};
967 my $fs = $qpconfig->{operators}{float_start};
968 my $fe = $qpconfig->{operators}{float_end};
969 my $gs = $qpconfig->{operators}{group_start};
970 my $ge = $qpconfig->{operators}{group_end};
971 my $and = $qpconfig->{operators}{and};
972 my $or = $qpconfig->{operators}{or};
977 if (exists $abstract_query->{type}) {
978 if ($abstract_query->{type} eq 'query_plan') {
979 $q .= join(" ", map { _abstract_query2str_filter($_, $qp_class) } @{$abstract_query->{filters}}) if
980 exists $abstract_query->{filters};
982 $q .= ($q ? ' ' : '') . join(" ", map { _abstract_query2str_modifier($_, $qp_class) } @{$abstract_query->{modifiers}}) if
983 exists $abstract_query->{modifiers};
985 if (!$abstract_query->{floating} && exists $abstract_query->{children} && _kid_list($abstract_query->{children}) > 1);
986 } elsif ($abstract_query->{type} eq 'node') {
987 if ($abstract_query->{alias}) {
988 $q .= ($q ? ' ' : '') . $abstract_query->{alias};
989 $q .= "|$_" foreach @{$abstract_query->{alias_fields}};
991 $q .= ($q ? ' ' : '') . $abstract_query->{class};
992 $q .= "|$_" foreach @{$abstract_query->{fields}};
996 } elsif ($abstract_query->{type} eq 'atom') {
997 my $prefix = $abstract_query->{prefix} || '';
998 $prefix = $qpconfig->{operators}{disallowed} if $prefix eq '!';
999 $q .= ($q ? ' ' : '') . $prefix .
1000 ($abstract_query->{content} || '') .
1001 ($abstract_query->{suffix} || '');
1002 } elsif ($abstract_query->{type} eq 'facet') {
1003 # facet syntax [ # ] is hardcoded I guess?
1004 my $prefix = $abstract_query->{negate} ? $qpconfig->{operators}{disallowed} : '';
1005 $q .= ($q ? ' ' : '') . $prefix . $abstract_query->{name} . "[" .
1006 join(" # ", @{$abstract_query->{values}}) . "]";
1010 if (exists $abstract_query->{children}) {
1012 my $op = (keys(%{$abstract_query->{children}}))[0];
1014 if ($abstract_query->{floating}) { # always the top node!
1015 my $sub_node = pop @{$abstract_query->{children}{$op}};
1017 $abstract_query->{floating} = 0;
1018 $q = $fs . " " . abstract_query2str_impl($abstract_query,0,$qp_class) . $fe. " ";
1020 $abstract_query = $sub_node;
1023 if ($abstract_query && exists $abstract_query->{children}) {
1024 $op = (keys(%{$abstract_query->{children}}))[0];
1025 $q .= ($q ? ' ' : '') . join(
1026 ($op eq '&' ? ' ' : " $or "),
1028 my $x = abstract_query2str_impl($_, $depth + 1, $qp_class); $x =~ s/^\s+//; $x =~ s/\s+$//; $x;
1029 } @{$abstract_query->{children}{$op}}
1032 } elsif ($abstract_query->{'&'} or $abstract_query->{'|'}) {
1033 my $op = (keys(%{$abstract_query}))[0];
1034 $q .= ($q ? ' ' : '') . join(
1035 ($op eq '&' ? ' ' : " $or "),
1037 my $x = abstract_query2str_impl($_, $depth + 1, $qp_class); $x =~ s/^\s+//; $x =~ s/\s+$//; $x;
1038 } @{$abstract_query->{$op}}
1042 $q = "$gs$q$ge" if ($isnode);
1047 #-------------------------------
1048 package QueryParser::query_plan;
1052 return undef unless ref($self);
1053 return $self->{QueryParser};
1058 $pkg = ref($pkg) || $pkg;
1059 my %args = (query => [], joiner => '&', @_);
1061 return bless \%args => $pkg;
1066 my $pkg = ref($self) || $self;
1067 my $node = do{$pkg.'::node'}->new( plan => $self, @_ );
1068 $self->add_node( $node );
1074 my $pkg = ref($self) || $self;
1079 my $node = do{$pkg.'::facet'}->new( plan => $self, name => $name, 'values' => $args, negate => $negate );
1080 $self->add_node( $node );
1087 my $pkg = ref($self) || $self;
1092 my $node = do{$pkg.'::filter'}->new( plan => $self, name => $name, args => $args, negate => $negate );
1093 $self->add_filter( $node );
1099 sub _merge_filters {
1100 my $left_filter = shift;
1101 my $right_filter = shift;
1104 return undef unless $left_filter or $right_filter;
1105 return $right_filter unless $left_filter;
1106 return $left_filter unless $right_filter;
1108 my $args = $left_filter->{args} || [];
1111 push(@$args, @{$right_filter->{args}});
1114 # find the intersect values
1116 map { $new_vals{$_} = 1 } @{$right_filter->{args} || []};
1117 $args = [ grep { $new_vals{$_} } @$args ];
1120 $left_filter->{args} = $args;
1121 return $left_filter;
1124 sub collapse_filters {
1128 # start by merging any filters at this level.
1129 # like-level filters are always ORed together
1132 my @cur_filters = grep {$_->name eq $name } @{ $self->filters };
1134 $cur_filter = shift @cur_filters;
1135 my $args = $cur_filter->{args} || [];
1136 $cur_filter = _merge_filters($cur_filter, $_, '|') for @cur_filters;
1139 # next gather the collapsed filters from sub-plans and
1140 # merge them with our own
1142 my @subquery = @{$self->{query}};
1145 my $blob = shift @subquery;
1146 shift @subquery; # joiner
1147 next unless $blob->isa('QueryParser::query_plan');
1148 my $sub_filter = $blob->collapse_filters($name);
1149 $cur_filter = _merge_filters($cur_filter, $sub_filter, $self->joiner);
1152 if ($self->QueryParser->debug) {
1153 my @args = ($cur_filter and $cur_filter->{args}) ? @{$cur_filter->{args}} : ();
1154 warn "collapse_filters($name) => [@args]\n";
1162 my $needle = shift;;
1163 return undef unless ($needle);
1165 my $filter = $self->collapse_filters($needle);
1167 warn "find_filter($needle) => " .
1168 (($filter and $filter->{args}) ? "@{$filter->{args}}" : '[]') . "\n"
1169 if $self->QueryParser->debug;
1171 return $filter ? ($filter) : ();
1176 my $needle = shift;;
1177 return undef unless ($needle);
1178 return grep { $_->name eq $needle } @{ $self->modifiers };
1183 my $pkg = ref($self) || $self;
1186 my $node = do{$pkg.'::modifier'}->new( $name );
1187 $self->add_modifier( $node );
1194 my $requested_class = shift;
1197 for my $n (@{$self->{query}}) {
1198 next unless (ref($n) && $n->isa( 'QueryParser::query_plan::node' ));
1199 if ($n->requested_class eq $requested_class) {
1206 $node = $self->new_node;
1207 $node->requested_class( $requested_class );
1213 sub remove_last_node {
1215 my $requested_class = shift;
1217 my $old = pop(@{$self->query_nodes});
1218 pop(@{$self->query_nodes}) if (@{$self->query_nodes});
1225 return $self->{query};
1231 $self->{floating} = $f if (defined $f);
1232 return $self->{floating};
1239 $self->{query} ||= [];
1240 push(@{$self->{query}}, $self->joiner) if (@{$self->{query}});
1241 push(@{$self->{query}}, $node);
1249 return $self->{level} ? 0 : 1;
1254 return $self->{level};
1261 $self->{joiner} = $joiner if ($joiner);
1262 return $self->{joiner};
1267 $self->{modifiers} ||= [];
1268 return $self->{modifiers};
1273 my $modifier = shift;
1275 $self->{modifiers} ||= [];
1276 $self->{modifiers} = [ grep {$_->name ne $modifier->name} @{$self->{modifiers}} ];
1278 push(@{$self->{modifiers}}, $modifier);
1285 $self->{facets} ||= [];
1286 return $self->{facets};
1293 $self->{facets} ||= [];
1294 $self->{facets} = [ grep {$_->name ne $facet->name} @{$self->{facets}} ];
1296 push(@{$self->{facets}}, $facet);
1303 $self->{filters} ||= [];
1304 return $self->{filters};
1311 $self->{filters} ||= [];
1313 push(@{$self->{filters}}, $filter);
1318 # %opts supports two options at this time:
1320 # If true, do not do anything to the phrases and unphrases
1321 # fields on any discovered nodes.
1323 # If true, also return the query parser config as part of the blob.
1324 # This will get set back to 0 before recursion to avoid repetition.
1325 sub to_abstract_query {
1329 my $pkg = ref $self->QueryParser || $self->QueryParser;
1331 my $abstract_query = {
1332 type => "query_plan",
1333 floating => $self->floating,
1334 filters => [map { $_->to_abstract_query } @{$self->filters}],
1335 modifiers => [map { $_->to_abstract_query } @{$self->modifiers}]
1338 if ($opts{with_config}) {
1339 $opts{with_config} = 0;
1340 $abstract_query->{config} = $QueryParser::parser_config{$pkg};
1345 for my $qnode (@{$self->query_nodes}) {
1346 # Remember: qnode can be a joiner string, a node, or another query_plan
1348 if (QueryParser::_util::is_joiner($qnode)) {
1349 if ($abstract_query->{children}) {
1350 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1351 next if $open_joiner eq $qnode;
1353 my $oldroot = $abstract_query->{children};
1355 $abstract_query->{children} = {$qnode => $kids};
1357 $abstract_query->{children} = {$qnode => $kids};
1360 push @$kids, $qnode->to_abstract_query(%opts);
1364 $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1365 return $abstract_query;
1369 #-------------------------------
1370 package QueryParser::query_plan::node;
1372 $Data::Dumper::Indent = 0;
1376 $pkg = ref($pkg) || $pkg;
1379 return bless \%args => $pkg;
1384 my $pkg = ref($self) || $self;
1385 return do{$pkg.'::atom'}->new( @_ );
1388 sub requested_class { # also split into classname, fields and alias
1394 my (undef, $alias) = split '#', $class;
1396 $class =~ s/#[^|]+//;
1397 ($alias, @afields) = split '\|', $alias;
1400 my @fields = @afields;
1401 my ($class_part, @field_parts) = split '\|', $class;
1402 for my $f (@field_parts) {
1403 push(@fields, $f) unless (grep { $f eq $_ } @fields);
1406 $class_part ||= $class;
1408 $self->{requested_class} = $class;
1409 $self->{alias} = $alias if $alias;
1410 $self->{alias_fields} = \@afields if $alias;
1411 $self->{classname} = $class_part;
1412 $self->{fields} = \@fields;
1415 return $self->{requested_class};
1422 $self->{plan} = $plan if ($plan);
1423 return $self->{plan};
1430 $self->{alias} = $alias if ($alias);
1431 return $self->{alias};
1438 $self->{alias_fields} = $alias if ($alias);
1439 return $self->{alias_fields};
1446 $self->{classname} = $class if ($class);
1447 return $self->{classname};
1454 $self->{fields} ||= [];
1455 $self->{fields} = \@fields if (@fields);
1456 return $self->{fields};
1463 $self->{phrases} ||= [];
1464 $self->{phrases} = \@phrases if (@phrases);
1465 return $self->{phrases};
1472 $self->{unphrases} ||= [];
1473 $self->{unphrases} = \@phrases if (@phrases);
1474 return $self->{unphrases};
1481 push(@{$self->phrases}, $phrase);
1490 push(@{$self->unphrases}, $phrase);
1497 my @query_atoms = @_;
1499 $self->{query_atoms} ||= [];
1500 $self->{query_atoms} = \@query_atoms if (@query_atoms);
1501 return $self->{query_atoms};
1509 my $content = $atom;
1512 $atom = $self->new_atom( content => $content, @parts );
1515 push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1516 push(@{$self->query_atoms}, $atom);
1521 sub add_dummy_atom {
1525 my $atom = $self->new_atom( @parts, dummy => 1 );
1527 push(@{$self->query_atoms}, $self->plan->joiner) if (@{$self->query_atoms});
1528 push(@{$self->query_atoms}, $atom);
1533 # This will find up to one occurence of @$short_list within @$long_list, and
1534 # replace it with the single atom $replacement.
1535 sub replace_phrase_in_abstract_query {
1536 my ($self, $short_list, $long_list, $replacement) = @_;
1540 my $goal = scalar @$short_list;
1542 for (my $i = 0; $i < scalar (@$long_list); $i++) {
1543 my $right = $long_list->[$i];
1545 if (QueryParser::_util::compare_abstract_atoms(
1546 $short_list->[scalar @already], $right
1549 } elsif (scalar @already) {
1554 if (scalar @already == $goal) {
1555 splice @$long_list, $already[0], scalar(@already), $replacement;
1564 sub to_abstract_query {
1568 my $pkg = ref $self->plan->QueryParser || $self->plan->QueryParser;
1570 my $abstract_query = {
1572 "alias" => $self->alias,
1573 "alias_fields" => $self->alias_fields,
1574 "class" => $self->classname,
1575 "fields" => $self->fields
1580 for my $qatom (@{$self->query_atoms}) {
1581 if (QueryParser::_util::is_joiner($qatom)) {
1582 if ($abstract_query->{children}) {
1583 my $open_joiner = (keys(%{$abstract_query->{children}}))[0];
1584 next if $open_joiner eq $qatom;
1586 my $oldroot = $abstract_query->{children};
1588 $abstract_query->{children} = {$qatom => $kids};
1590 $abstract_query->{children} = {$qatom => $kids};
1593 push @$kids, $qatom->to_abstract_query;
1597 if ($self->{phrases} and not $opts{no_phrases}) {
1598 for my $phrase (@{$self->{phrases}}) {
1599 # Phrases appear duplication in a real QP tree, and we don't want
1600 # that duplication in our abstract query. So for all our phrases,
1601 # break them into atoms as QP would, and remove any matching
1602 # sequences of atoms from our abstract query.
1604 my $tmptree = $self->{plan}->{QueryParser}->new(query => '"'.$phrase.'"')->parse->parse_tree;
1606 # For a well-behaved phrase, we should now have only one node
1607 # in the $tmptree query plan, and that node should have an
1608 # orderly list of atoms and joiners.
1610 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
1614 $tmplist = $tmptree->{query}->[0]->to_abstract_query(
1616 )->{children}->{'&'}->[0]->{children}->{'&'};
1621 QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
1623 last if $self->replace_phrase_in_abstract_query(
1626 QueryParser::_util::fake_abstract_atom_from_phrase($phrase, undef, $pkg)
1634 # Do the same as the preceding block for unphrases (negated phrases).
1635 if ($self->{unphrases} and not $opts{no_phrases}) {
1636 for my $phrase (@{$self->{unphrases}}) {
1637 my $tmptree = $self->{plan}->{QueryParser}->new(
1638 query => $QueryParser::parser_config{$pkg}{operators}{disallowed}.
1640 )->parse->parse_tree;
1643 if ($tmptree->{query} and scalar(@{$tmptree->{query}}) == 1) {
1647 $tmplist = $tmptree->{query}->[0]->to_abstract_query(
1649 )->{children}->{'&'}->[0]->{children}->{'&'};
1654 QueryParser::_util::find_arrays_in_abstract($abstract_query->{children})
1656 last if $self->replace_phrase_in_abstract_query(
1659 QueryParser::_util::fake_abstract_atom_from_phrase($phrase, 1, $pkg)
1667 $abstract_query->{children} ||= { QueryParser::_util::default_joiner() => $kids };
1668 return $abstract_query;
1671 #-------------------------------
1672 package QueryParser::query_plan::node::atom;
1676 $pkg = ref($pkg) || $pkg;
1679 return bless \%args => $pkg;
1684 return undef unless (ref $self);
1685 return $self->{node};
1690 return undef unless (ref $self);
1691 return $self->{content};
1696 return undef unless (ref $self);
1697 return $self->{prefix};
1702 return undef unless (ref $self);
1703 return $self->{suffix};
1706 sub to_abstract_query {
1710 (map { $_ => $self->$_ } qw/prefix suffix content/),
1714 #-------------------------------
1715 package QueryParser::query_plan::filter;
1719 $pkg = ref($pkg) || $pkg;
1722 return bless \%args => $pkg;
1727 return $self->{plan};
1732 return $self->{name};
1737 return $self->{negate};
1742 return $self->{args};
1745 sub to_abstract_query {
1749 map { $_ => $self->$_ } qw/name negate args/
1753 #-------------------------------
1754 package QueryParser::query_plan::facet;
1758 $pkg = ref($pkg) || $pkg;
1761 return bless \%args => $pkg;
1766 return $self->{plan};
1771 return $self->{name};
1776 return $self->{negate};
1781 return $self->{'values'};
1784 sub to_abstract_query {
1788 (map { $_ => $self->$_ } qw/name negate values/),
1793 #-------------------------------
1794 package QueryParser::query_plan::modifier;
1798 $pkg = ref($pkg) || $pkg;
1799 my $modifier = shift;
1802 return bless { name => $modifier, negate => $negate } => $pkg;
1807 return $self->{name};
1812 return $self->{negate};
1815 sub to_abstract_query {