Koha/SearchEngine/Elasticsearch/QueryBuilder.pm

   1 package Koha::SearchEngine::Elasticsearch::QueryBuilder;
   2
   3 # This file is part of Koha.
   4 #
   5 # Copyright 2014 Catalyst IT Ltd.
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  19
  20 =head1 NAME
  21
  22 Koha::SearchEngine::Elasticsearch::QueryBuilder - constructs elasticsearch
  23 query objects from user-supplied queries
  24
  25 =head1 DESCRIPTION
  26
  27 This provides the functions that take a user-supplied search query, and
  28 provides something that can be given to elasticsearch to get answers.
  29
  30 =head1 SYNOPSIS
  31
  32     use Koha::SearchEngine::Elasticsearch::QueryBuilder;
  33     $builder = Koha::SearchEngine::Elasticsearch->new({ index => $index });
  34     my $simple_query = $builder->build_query("hello");
  35     # This is currently undocumented because the original code is undocumented
  36     my $adv_query = $builder->build_advanced_query($indexes, $operands, $operators);
  37
  38 =head1 METHODS
  39
  40 =cut
  41
  42 use base qw(Koha::SearchEngine::Elasticsearch);
  43 use Carp;
  44 use JSON;
  45 use List::MoreUtils qw/ each_array /;
  46 use Modern::Perl;
  47 use URI::Escape;
  48
  49 use C4::Context;
  50 use Koha::Exceptions;
  51
  52 =head2 build_query
  53
  54     my $simple_query = $builder->build_query("hello", %options)
  55
  56 This will build a query that can be issued to elasticsearch from the provided
  57 string input. This expects a lucene style search form (see
  58 L<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#query-string-syntax>
  59 for details.)
  60
  61 It'll make an attempt to respect the various query options.
  62
  63 Additional options can be provided with the C<%options> hash.
  64
  65 =over 4
  66
  67 =item sort
  68
  69 This should be an arrayref of hashrefs, each containing a C<field> and an
  70 C<direction> (optional, defaults to C<asc>.) The results will be sorted
  71 according to these values. Valid values for C<direction> are 'asc' and 'desc'.
  72
  73 =back
  74
  75 =cut
  76
  77 sub build_query {
  78     my ( $self, $query, %options ) = @_;
  79
  80     my $stemming         = C4::Context->preference("QueryStemming")        || 0;
  81     my $auto_truncation  = C4::Context->preference("QueryAutoTruncate")    || 0;
  82     my $weight_fields    = C4::Context->preference("QueryWeightFields")    || 0;
  83     my $fuzzy_enabled    = C4::Context->preference("QueryFuzzy")           || 0;
  84
  85     $query = '*' unless defined $query;
  86
  87     my $res;
  88     $res->{query} = {
  89         query_string => {
  90             query            => $query,
  91             fuzziness        => $fuzzy_enabled ? 'auto' : '0',
  92             default_operator => 'AND',
  93             default_field    => '_all',
  94             lenient          => JSON::true,
  95         }
  96     };
  97
  98     if ( $options{sort} ) {
  99         foreach my $sort ( @{ $options{sort} } ) {
 100             my ( $f, $d ) = @$sort{qw/ field direction /};
 101             die "Invalid sort direction, $d"
 102               if $d && ( $d ne 'asc' && $d ne 'desc' );
 103             $d = 'asc' unless $d;
 104
 105             # TODO account for fields that don't have a 'phrase' type
 106
 107             $f = $self->_sort_field($f);
 108             push @{ $res->{sort} }, { "$f.phrase" => { order => $d } };
 109         }
 110     }
 111
 112     # See _convert_facets in Search.pm for how these get turned into
 113     # things that Koha can use.
 114     $res->{aggregations} = {
 115         author   => { terms => { field => "author__facet" } },
 116         subject  => { terms => { field => "subject__facet" } },
 117         itype    => { terms => { field => "itype__facet" } },
 118         location => { terms => { field => "location__facet" } },
 119         'su-geo' => { terms => { field => "su-geo__facet" } },
 120         se       => { terms => { field => "se__facet" } },
 121         ccode    => { terms => { field => "ccode__facet" } },
 122     };
 123
 124     my $display_library_facets = C4::Context->preference('DisplayLibraryFacets');
 125     if (   $display_library_facets eq 'both'
 126         or $display_library_facets eq 'home' ) {
 127         $res->{aggregations}{homebranch} = { terms => { field => "homebranch__facet" } };
 128     }
 129     if (   $display_library_facets eq 'both'
 130         or $display_library_facets eq 'holding' ) {
 131         $res->{aggregations}{holdingbranch} = { terms => { field => "holdingbranch__facet" } };
 132     }
 133     if ( my $ef = $options{expanded_facet} ) {
 134         $res->{aggregations}{$ef}{terms}{size} = C4::Context->preference('FacetMaxCount');
 135     };
 136     return $res;
 137 }
 138
 139 =head2 build_browse_query
 140
 141     my $browse_query = $builder->build_browse_query($field, $query);
 142
 143 This performs a "starts with" style query on a particular field. The field
 144 to be searched must have been indexed with an appropriate mapping as a
 145 "phrase" subfield, which pretty much everything has.
 146
 147 =cut
 148
 149 # XXX this isn't really a browse query like we want in the end
 150 sub build_browse_query {
 151     my ( $self, $field, $query ) = @_;
 152
 153     my $fuzzy_enabled = C4::Context->preference("QueryFuzzy") || 0;
 154
 155     return { query => '*' } if !defined $query;
 156
 157     # TODO this should come from Koha::SearchEngine::Elasticsearch
 158     my %field_whitelist = (
 159         title  => 1,
 160         author => 1,
 161     );
 162     $field = 'title' if !exists $field_whitelist{$field};
 163     my $sort = $self->_sort_field($field);
 164     my $res = {
 165         query => {
 166             match_phrase_prefix => {
 167                 "$field.phrase" => {
 168                     query     => $query,
 169                     operator  => 'or',
 170                     fuzziness => $fuzzy_enabled ? 'auto' : '0',
 171                 }
 172             }
 173         },
 174         sort => [ { "$sort.phrase" => { order => "asc" } } ],
 175     };
 176 }
 177
 178 =head2 build_query_compat
 179
 180     my (
 181         $error,             $query, $simple_query, $query_cgi,
 182         $query_desc,        $limit, $limit_cgi,    $limit_desc,
 183         $stopwords_removed, $query_type
 184       )
 185       = $builder->build_query_compat( \@operators, \@operands, \@indexes,
 186         \@limits, \@sort_by, $scan, $lang );
 187
 188 This handles a search using the same api as L<C4::Search::buildQuery> does.
 189
 190 A very simple query will go in with C<$operands> set to ['query'], and
 191 C<$sort_by> set to ['pubdate_dsc']. This simple case will return with
 192 C<$query> set to something that can perform the search, C<$simple_query>
 193 set to just the search term, C<$query_cgi> set to something that can
 194 reproduce this search, and C<$query_desc> set to something else.
 195
 196 =cut
 197
 198 sub build_query_compat {
 199     my ( $self, $operators, $operands, $indexes, $orig_limits, $sort_by, $scan,
 200         $lang, $params )
 201       = @_;
 202
 203 #die Dumper ( $self, $operators, $operands, $indexes, $orig_limits, $sort_by, $scan, $lang );
 204     my @sort_params  = $self->_convert_sort_fields(@$sort_by);
 205     my @index_params = $self->_convert_index_fields(@$indexes);
 206     my $limits       = $self->_fix_limit_special_cases($orig_limits);
 207     if ( $params->{suppress} ) { push @$limits, "suppress:0"; }
 208
 209     # Merge the indexes in with the search terms and the operands so that
 210     # each search thing is a handy unit.
 211     unshift @$operators, undef;    # The first one can't have an op
 212     my @search_params;
 213     my $ea = each_array( @$operands, @$operators, @index_params );
 214     while ( my ( $oand, $otor, $index ) = $ea->() ) {
 215         next if ( !defined($oand) || $oand eq '' );
 216         push @search_params, {
 217             operand => $self->_clean_search_term($oand),      # the search terms
 218             operator => defined($otor) ? uc $otor : undef,    # AND and so on
 219             $index ? %$index : (),
 220         };
 221     }
 222
 223     # We build a string query from limits and the queries. An alternative
 224     # would be to pass them separately into build_query and let it build
 225     # them into a structured ES query itself. Maybe later, though that'd be
 226     # more robust.
 227     my $query_str = join( ' AND ',
 228         join( ' ', $self->_create_query_string(@search_params) ) || (),
 229         $self->_join_queries( $self->_convert_index_strings(@$limits) ) || () );
 230
 231     # If there's no query on the left, let's remove the junk left behind
 232     $query_str =~ s/^ AND //;
 233     my %options;
 234     $options{sort} = \@sort_params;
 235     $options{expanded_facet} = $params->{expanded_facet};
 236     my $query = $self->build_query( $query_str, %options );
 237
 238     #die Dumper($query);
 239     # We roughly emulate the CGI parameters of the zebra query builder
 240     my $query_cgi;
 241     $query_cgi = 'q=' . uri_escape_utf8( $operands->[0] ) if @$operands;
 242     my $simple_query;
 243     $simple_query = $operands->[0] if @$operands == 1;
 244     my $query_desc   = $simple_query;
 245     my $limit        = $self->_join_queries( $self->_convert_index_strings(@$limits));
 246     my $limit_cgi = ( $orig_limits and @$orig_limits )
 247       ? '&limit=' . join( '&limit=', map { uri_escape_utf8($_) } @$orig_limits )
 248       : '';
 249     my $limit_desc;
 250     $limit_desc = "$limit" if $limit;
 251     return (
 252         undef,  $query,     $simple_query, $query_cgi, $query_desc,
 253         $limit, $limit_cgi, $limit_desc,   undef,      undef
 254     );
 255 }
 256
 257 =head2 build_authorities_query
 258
 259     my $query = $builder->build_authorities_query(\%search);
 260
 261 This takes a nice description of an authority search and turns it into a black-box
 262 query that can then be passed to the appropriate searcher.
 263
 264 The search description is a hashref that looks something like:
 265
 266     {
 267         searches => [
 268             {
 269                 where    => 'Heading',    # search the main entry
 270                 operator => 'exact',        # require an exact match
 271                 value    => 'frogs',        # the search string
 272             },
 273             {
 274                 where    => '',             # search all entries
 275                 operator => '',             # default keyword, right truncation
 276                 value    => 'pond',
 277             },
 278         ],
 279         sort => {
 280             field => 'Heading',
 281             order => 'desc',
 282         },
 283         authtypecode => 'TOPIC_TERM',
 284     }
 285
 286 =cut
 287
 288 sub build_authorities_query {
 289     my ( $self, $search ) = @_;
 290
 291     # Start by making the query parts
 292     my @query_parts;
 293
 294     foreach my $s ( @{ $search->{searches} } ) {
 295         my ( $wh, $op, $val ) = @{$s}{qw(where operator value)};
 296         $wh = '_all' if $wh eq '';
 297         if ( $op eq 'is' || $op eq '=' ) {
 298
 299             # look for something that matches a term completely
 300             # note, '=' is about numerical vals. May need special handling.
 301             # Also, we lowercase our search because the ES
 302             # index lowercases its values, and term searches don't get the
 303             # search analyzer applied to them.
 304             push @query_parts, { term => {"$wh.phrase" => lc $val} };
 305         }
 306         elsif ( $op eq 'exact' ) {
 307             # left and right truncation, otherwise an exact phrase
 308             push @query_parts, { match_phrase => {"$wh.phrase" => lc $val} };
 309         }
 310         elsif ( $op eq 'start' ) {
 311             # startswith search, uses lowercase untokenized version of heading
 312             push @query_parts, { prefix => {"$wh.lc_raw" => lc $val} };
 313         }
 314         else {
 315             # regular wordlist stuff
 316 #            push @query_parts, { match => {$wh => { query => $val, operator => 'and' }} };
 317             my @values = split(' ',$val);
 318             foreach $val (@values) {
 319                 push @query_parts, { wildcard => { "$wh.phrase" => "*" . lc $val . "*" } };
 320             }
 321         }
 322     }
 323
 324     # Merge the query parts appropriately
 325     # 'should' behaves like 'or'
 326     # 'must' behaves like 'and'
 327     # Zebra results seem to match must so using that here
 328     my $query = { query=>
 329                  { bool =>
 330                      { must => \@query_parts  }
 331                  }
 332              };
 333
 334     # We need to add '.phrase' to all the sort headings otherwise it'll sort
 335     # based on the tokenised form.
 336     my %s;
 337     if ( exists $search->{sort} ) {
 338         foreach my $k ( keys %{ $search->{sort} } ) {
 339             my $f = $self->_sort_field($k);
 340             $s{"$f.phrase"} = $search->{sort}{$k};
 341         }
 342         $search->{sort} = \%s;
 343     }
 344
 345     # add the sort stuff
 346     $query->{sort} = [ $search->{sort} ]  if exists $search->{sort};
 347
 348     return $query;
 349 }
 350
 351
 352 =head2 build_authorities_query_compat
 353
 354     my ($query) =
 355       $builder->build_authorities_query_compat( \@marclist, \@and_or,
 356         \@excluding, \@operator, \@value, $authtypecode, $orderby );
 357
 358 This builds a query for searching for authorities, in the style of
 359 L<C4::AuthoritiesMarc::SearchAuthorities>.
 360
 361 Arguments:
 362
 363 =over 4
 364
 365 =item marclist
 366
 367 An arrayref containing where the particular term should be searched for.
 368 Options are: mainmainentry, mainentry, match, match-heading, see-from, and
 369 thesaurus. If left blank, any field is used.
 370
 371 =item and_or
 372
 373 Totally ignored. It is never used in L<C4::AuthoritiesMarc::SearchAuthorities>.
 374
 375 =item excluding
 376
 377 Also ignored.
 378
 379 =item operator
 380
 381 What form of search to do. Options are: is (phrase, no trunction, whole field
 382 must match), = (number exact match), exact (phrase, but with left and right
 383 truncation). If left blank, then word list, right truncted, anywhere is used.
 384
 385 =item value
 386
 387 The actual user-provided string value to search for.
 388
 389 =item authtypecode
 390
 391 The authority type code to search within. If blank, then all will be searched.
 392
 393 =item orderby
 394
 395 The order to sort the results by. Options are Relevance, HeadingAsc,
 396 HeadingDsc, AuthidAsc, AuthidDsc.
 397
 398 =back
 399
 400 marclist, operator, and value must be the same length, and the values at
 401 index /i/ all relate to each other.
 402
 403 This returns a query, which is a black box object that can be passed to the
 404 appropriate search object.
 405
 406 =cut
 407
 408 our $koha_to_index_name = {
 409     mainmainentry   => 'Heading-Main',
 410     mainentry       => 'Heading',
 411     match           => 'Match',
 412     'match-heading' => 'Match-heading',
 413     'see-from'      => 'Match-heading-see-from',
 414     thesaurus       => 'Subject-heading-thesaurus',
 415     all              => ''
 416 };
 417
 418 sub build_authorities_query_compat {
 419     my ( $self, $marclist, $and_or, $excluding, $operator, $value,
 420         $authtypecode, $orderby )
 421       = @_;
 422
 423     # This turns the old-style many-options argument form into a more
 424     # extensible hash form that is understood by L<build_authorities_query>.
 425     my @searches;
 426
 427     # Make sure everything exists
 428     foreach my $m (@$marclist) {
 429         Koha::Exceptions::WrongParameter->throw("Invalid marclist field provided: $m")
 430             unless exists $koha_to_index_name->{$m};
 431     }
 432     for ( my $i = 0 ; $i < @$value ; $i++ ) {
 433         next unless $value->[$i]; #clean empty form values, ES doesn't like undefined searches
 434         push @searches,
 435           {
 436             where    => $koha_to_index_name->{$marclist->[$i]},
 437             operator => $operator->[$i],
 438             value    => $value->[$i],
 439           };
 440     }
 441
 442     my %sort;
 443     my $sort_field =
 444         ( $orderby =~ /^Heading/ ) ? 'Heading__sort'
 445       : ( $orderby =~ /^Auth/ )    ? 'Local-Number'
 446       :                              undef;
 447     if ($sort_field) {
 448         my $sort_order = ( $orderby =~ /Asc$/ ) ? 'asc' : 'desc';
 449         %sort = ( $sort_field => $sort_order, );
 450     }
 451     my %search = (
 452         searches     => \@searches,
 453         authtypecode => $authtypecode,
 454     );
 455     $search{sort} = \%sort if %sort;
 456     my $query = $self->build_authorities_query( \%search );
 457     return $query;
 458 }
 459
 460 =head2 _convert_sort_fields
 461
 462     my @sort_params = _convert_sort_fields(@sort_by)
 463
 464 Converts the zebra-style sort index information into elasticsearch-style.
 465
 466 C<@sort_by> is the same as presented to L<build_query_compat>, and it returns
 467 something that can be sent to L<build_query>.
 468
 469 =cut
 470
 471 sub _convert_sort_fields {
 472     my ( $self, @sort_by ) = @_;
 473
 474     # Turn the sorting into something we care about.
 475     my %sort_field_convert = (
 476         acqdate     => 'acqdate',
 477         author      => 'author',
 478         call_number => 'callnum',
 479         popularity  => 'issues',
 480         relevance   => undef,       # default
 481         title       => 'title',
 482         pubdate     => 'pubdate',
 483     );
 484     my %sort_order_convert =
 485       ( qw( desc desc ), qw( dsc desc ), qw( asc asc ), qw( az asc ), qw( za desc ) );
 486
 487     # Convert the fields and orders, drop anything we don't know about.
 488     grep { $_->{field} } map {
 489         my ( $f, $d ) = /(.+)_(.+)/;
 490         {
 491             field     => $sort_field_convert{$f},
 492             direction => $sort_order_convert{$d}
 493         }
 494     } @sort_by;
 495 }
 496
 497 =head2 _convert_index_fields
 498
 499     my @index_params = $self->_convert_index_fields(@indexes);
 500
 501 Converts zebra-style search index notation into elasticsearch-style.
 502
 503 C<@indexes> is an array of index names, as presented to L<build_query_compat>,
 504 and it returns something that can be sent to L<build_query>.
 505
 506 B<TODO>: this will pull from the elasticsearch mappings table to figure out
 507 types.
 508
 509 =cut
 510
 511 our %index_field_convert = (
 512     'kw'      => '_all',
 513     'ti'      => 'title',
 514     'au'      => 'author',
 515     'su'      => 'subject',
 516     'nb'      => 'isbn',
 517     'se'      => 'title-series',
 518     'callnum' => 'callnum',
 519     'itype'   => 'itype',
 520     'ln'      => 'ln',
 521     'branch'  => 'homebranch',
 522     'fic'     => 'lf',
 523     'mus'     => 'rtype',
 524     'aud'     => 'ta',
 525     'hi'      => 'Host-Item-Number',
 526 );
 527
 528 sub _convert_index_fields {
 529     my ( $self, @indexes ) = @_;
 530
 531     my %index_type_convert =
 532       ( __default => undef, phr => 'phrase', rtrn => 'right-truncate' );
 533
 534     # Convert according to our table, drop anything that doesn't convert.
 535     # If a field starts with mc- we save it as it's used (and removed) later
 536     # when joining things, to indicate we make it an 'OR' join.
 537     # (Sorry, this got a bit ugly after special cases were found.)
 538     grep { $_->{field} } map {
 539         my ( $f, $t ) = split /,/;
 540         my $mc = '';
 541         if ($f =~ /^mc-/) {
 542             $mc = 'mc-';
 543             $f =~ s/^mc-//;
 544         }
 545         my $r = {
 546             field => $index_field_convert{$f},
 547             type  => $index_type_convert{ $t // '__default' }
 548         };
 549         $r->{field} = ($mc . $r->{field}) if $mc && $r->{field};
 550         $r;
 551     } @indexes;
 552 }
 553
 554 =head2 _convert_index_strings
 555
 556     my @searches = $self->_convert_index_strings(@searches);
 557
 558 Similar to L<_convert_index_fields>, this takes strings of the form
 559 B<field:search term> and rewrites the field from zebra-style to
 560 elasticsearch-style. Anything it doesn't understand is returned verbatim.
 561
 562 =cut
 563
 564 sub _convert_index_strings {
 565     my ( $self, @searches ) = @_;
 566     my @res;
 567     foreach my $s (@searches) {
 568         next if $s eq '';
 569         my ( $field, $term ) = $s =~ /^\s*([\w,-]*?):(.*)/;
 570         unless ( defined($field) && defined($term) ) {
 571             push @res, $s;
 572             next;
 573         }
 574         my ($conv) = $self->_convert_index_fields($field);
 575         unless ( defined($conv) ) {
 576             push @res, $s;
 577             next;
 578         }
 579         push @res, $conv->{field} . ":"
 580           . $self->_modify_string_by_type( %$conv, operand => $term );
 581     }
 582     return @res;
 583 }
 584
 585 =head2 _convert_index_strings_freeform
 586
 587     my $search = $self->_convert_index_strings_freeform($search);
 588
 589 This is similar to L<_convert_index_strings>, however it'll search out the
 590 things to change within the string. So it can handle strings such as
 591 C<(su:foo) AND (su:bar)>, converting the C<su> appropriately.
 592
 593 If there is something of the form "su,complete-subfield" or something, the
 594 second part is stripped off as we can't yet handle that. Making it work
 595 will have to wait for a real query parser.
 596
 597 =cut
 598
 599 sub _convert_index_strings_freeform {
 600     my ( $self, $search ) = @_;
 601     while ( my ( $zeb, $es ) = each %index_field_convert ) {
 602         $search =~ s/\b$zeb(?:,[\w\-]*)?:/$es:/g;
 603     }
 604     return $search;
 605 }
 606
 607 =head2 _modify_string_by_type
 608
 609     my $str = $self->_modify_string_by_type(%index_field);
 610
 611 If you have a search term (operand) and a type (phrase, right-truncated), this
 612 will convert the string to have the function in lucene search terms, e.g.
 613 wrapping quotes around it.
 614
 615 =cut
 616
 617 sub _modify_string_by_type {
 618     my ( $self, %idx ) = @_;
 619
 620     my $type = $idx{type} || '';
 621     my $str = $idx{operand};
 622     return $str unless $str;    # Empty or undef, we can't use it.
 623
 624     $str .= '*' if $type eq 'right-truncate';
 625     $str = '"' . $str . '"' if $type eq 'phrase';
 626     return $str;
 627 }
 628
 629 =head2 _join_queries
 630
 631     my $query_str = $self->_join_queries(@query_parts);
 632
 633 This takes a list of query parts, that might be search terms on their own, or
 634 booleaned together, or specifying fields, or whatever, wraps them in
 635 parentheses, and ANDs them all together. Suitable for feeding to the ES
 636 query string query.
 637
 638 Note: doesn't AND them together if they specify an index that starts with "mc"
 639 as that was a special case in the original code for dealing with multiple
 640 choice options (you can't search for something that has an itype of A and
 641 and itype of B otherwise.)
 642
 643 =cut
 644
 645 sub _join_queries {
 646     my ( $self, @parts ) = @_;
 647
 648     my @norm_parts = grep { defined($_) && $_ ne '' && $_ !~ /^mc-/ } @parts;
 649     my @mc_parts =
 650       map { s/^mc-//r } grep { defined($_) && $_ ne '' && $_ =~ /^mc-/ } @parts;
 651     return () unless @norm_parts + @mc_parts;
 652     return ( @norm_parts, @mc_parts )[0] if @norm_parts + @mc_parts == 1;
 653     my $grouped_mc =
 654       @mc_parts ? '(' . ( join ' OR ', map { "($_)" } @mc_parts ) . ')' : ();
 655
 656     # Handy trick: $x || () inside a join means that if $x ends up as an
 657     # empty string, it gets replaced with (), which makes join ignore it.
 658     # (bad effect: this'll also happen to '0', this hopefully doesn't matter
 659     # in this case.)
 660     join( ' AND ',
 661         join( ' AND ', map { "($_)" } @norm_parts ) || (),
 662         $grouped_mc || () );
 663 }
 664
 665 =head2 _make_phrases
 666
 667     my @phrased_queries = $self->_make_phrases(@query_parts);
 668
 669 This takes the supplied queries and forces them to be phrases by wrapping
 670 quotes around them. It understands field prefixes, e.g. 'subject:' and puts
 671 the quotes outside of them if they're there.
 672
 673 =cut
 674
 675 sub _make_phrases {
 676     my ( $self, @parts ) = @_;
 677     map { s/^\s*(\w*?:)(.*)$/$1"$2"/r } @parts;
 678 }
 679
 680 =head2 _create_query_string
 681
 682     my @query_strings = $self->_create_query_string(@queries);
 683
 684 Given a list of hashrefs, it will turn them into a lucene-style query string.
 685 The hash should contain field, type (both for the indexes), operator, and
 686 operand.
 687
 688 =cut
 689
 690 sub _create_query_string {
 691     my ( $self, @queries ) = @_;
 692
 693     map {
 694         my $otor  = $_->{operator} ? $_->{operator} . ' ' : '';
 695         my $field = $_->{field}    ? $_->{field} . ':'    : '';
 696
 697         my $oand = $self->_modify_string_by_type(%$_);
 698         "$otor($field$oand)";
 699     } @queries;
 700 }
 701
 702 =head2 _clean_search_term
 703
 704     my $term = $self->_clean_search_term($term);
 705
 706 This cleans a search term by removing any funny characters that may upset
 707 ES and give us an error. It also calls L<_convert_index_strings_freeform>
 708 to ensure those parts are correct.
 709
 710 =cut
 711
 712 sub _clean_search_term {
 713     my ( $self, $term ) = @_;
 714
 715     my $auto_truncation = C4::Context->preference("QueryAutoTruncate") || 0;
 716
 717     # Some hardcoded searches (like with authorities) produce things like
 718     # 'an=123', when it ought to be 'an:123' for our purposes.
 719     $term =~ s/=/:/g;
 720     $term = $self->_convert_index_strings_freeform($term);
 721     $term =~ s/[{}]/"/g;
 722     $term = $self->_truncate_terms($term) if ($auto_truncation);
 723     return $term;
 724 }
 725
 726 =head2 _fix_limit_special_cases
 727
 728     my $limits = $self->_fix_limit_special_cases($limits);
 729
 730 This converts any special cases that the limit specifications have into things
 731 that are more readily processable by the rest of the code.
 732
 733 The argument should be an arrayref, and it'll return an arrayref.
 734
 735 =cut
 736
 737 sub _fix_limit_special_cases {
 738     my ( $self, $limits ) = @_;
 739
 740     my @new_lim;
 741     foreach my $l (@$limits) {
 742
 743         # This is set up by opac-search.pl
 744         if ( $l =~ /^yr,st-numeric,ge=/ ) {
 745             my ( $start, $end ) =
 746               ( $l =~ /^yr,st-numeric,ge=(.*) and yr,st-numeric,le=(.*)$/ );
 747             next unless defined($start) && defined($end);
 748             push @new_lim, "copydate:[$start TO $end]";
 749         }
 750         elsif ( $l =~ /^yr,st-numeric=/ ) {
 751             my ($date) = ( $l =~ /^yr,st-numeric=(.*)$/ );
 752             next unless defined($date);
 753             push @new_lim, "copydate:$date";
 754         }
 755         elsif ( $l =~ /^available$/ ) {
 756             push @new_lim, 'onloan:0';
 757         }
 758         else {
 759             push @new_lim, $l;
 760         }
 761     }
 762     return \@new_lim;
 763 }
 764
 765 =head2 _sort_field
 766
 767     my $field = $self->_sort_field($field);
 768
 769 Given a field name, this works out what the actual name of the version to sort
 770 on should be. Often it's the same, sometimes it involves sticking "__sort" on
 771 the end. Maybe it'll be something else in the future, who knows?
 772
 773 =cut
 774
 775 sub _sort_field {
 776     my ($self, $f) = @_;
 777     if ($self->sort_fields()->{$f}) {
 778         $f .= '__sort';
 779     }
 780     return $f;
 781 }
 782
 783 =head2 _truncate_terms
 784
 785     my $query = $self->_truncate_terms($query);
 786
 787 Given a string query this function appends '*' wildcard  to all terms except
 788 operands and double quoted strings.
 789
 790 =cut
 791
 792 sub _truncate_terms {
 793     my ( $self, $query ) = @_;
 794
 795     # '"donald duck" title:"the mouse" and peter" get split into
 796     # ['', '"donald duck"', '', ' ', '', 'title:"the mouse"', '', ' ', 'and', ' ', 'pete']
 797     my @tokens = split /((?:[\w\-.]+:)?"[^"]+"|\s+)/, $query;
 798
 799     # Filter out empty tokens
 800     my @words = grep { $_ !~ /^\s*$/ } @tokens;
 801
 802     # Append '*' to words if needed, ie. if it's not surrounded by quotes, not
 803     # terminated by '*' and not a keyword
 804     my @terms = map {
 805         my $w = $_;
 806         (/"$/ or /\*$/ or grep {lc($w) eq $_} qw/and or not/) ? $_ : "$_*";
 807     } @words;
 808
 809     return join ' ', @terms;
 810 }
 811
 812 1;