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 = 'idx=kw&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     my @filter_parts;
 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 completely
 300             # note, '=' is about numerical vals. May need special handling.
 301             # _allphrase is a special field that only groups the exact
 302             # matches. Also, we lowercase our search because the ES
 303             # index lowercases its values, and term searches don't get the
 304             # search analyzer applied to them.
 305             push @filter_parts, { term => { "$wh.phrase" => lc $val } };
 306         }
 307         elsif ( $op eq 'exact' ) {
 308
 309             # left and right truncation, otherwise an exact phrase
 310             push @query_parts, { match_phrase => { $wh => $val } };
 311         }
 312         elsif ( $op eq 'start' ) {
 313
 314             # startswith search
 315             push @query_parts, { wildcard => { "$wh.phrase" => lc "$val*" } };
 316         }
 317         else {
 318             # regular wordlist stuff
 319             push @query_parts, { match => { $wh => $val } };
 320         }
 321     }
 322
 323     # Merge the query and filter parts appropriately
 324     # 'should' behaves like 'or', if we want 'and', use 'must'
 325     my $query_part  = { bool => { should => \@query_parts } };
 326     my $filter_part = { bool => { should => \@filter_parts } };
 327
 328     # We need to add '.phrase' to all the sort headings otherwise it'll sort
 329     # based on the tokenised form.
 330     my %s;
 331     if ( exists $search->{sort} ) {
 332         foreach my $k ( keys %{ $search->{sort} } ) {
 333             my $f = $self->_sort_field($k);
 334             $s{"$f.phrase"} = $search->{sort}{$k};
 335         }
 336         $search->{sort} = \%s;
 337     }
 338
 339     # extract the sort stuff
 340     my %sort;
 341     %sort = ( sort => [ $search->{sort} ] ) if exists $search->{sort};
 342     my $query;
 343     if (@filter_parts) {
 344         $query =
 345           { query =>
 346               { filtered => { filter => $filter_part, query => $query_part } }
 347           };
 348     }
 349     else {
 350         $query = { query => $query_part };
 351     }
 352     $query = { %$query, %sort };
 353     return $query;
 354 }
 355
 356
 357 =head2 build_authorities_query_compat
 358
 359     my ($query) =
 360       $builder->build_authorities_query_compat( \@marclist, \@and_or,
 361         \@excluding, \@operator, \@value, $authtypecode, $orderby );
 362
 363 This builds a query for searching for authorities, in the style of
 364 L<C4::AuthoritiesMarc::SearchAuthorities>.
 365
 366 Arguments:
 367
 368 =over 4
 369
 370 =item marclist
 371
 372 An arrayref containing where the particular term should be searched for.
 373 Options are: mainmainentry, mainentry, match, match-heading, see-from, and
 374 thesaurus. If left blank, any field is used.
 375
 376 =item and_or
 377
 378 Totally ignored. It is never used in L<C4::AuthoritiesMarc::SearchAuthorities>.
 379
 380 =item excluding
 381
 382 Also ignored.
 383
 384 =item operator
 385
 386 What form of search to do. Options are: is (phrase, no trunction, whole field
 387 must match), = (number exact match), exact (phrase, but with left and right
 388 truncation). If left blank, then word list, right truncted, anywhere is used.
 389
 390 =item value
 391
 392 The actual user-provided string value to search for.
 393
 394 =item authtypecode
 395
 396 The authority type code to search within. If blank, then all will be searched.
 397
 398 =item orderby
 399
 400 The order to sort the results by. Options are Relevance, HeadingAsc,
 401 HeadingDsc, AuthidAsc, AuthidDsc.
 402
 403 =back
 404
 405 marclist, operator, and value must be the same length, and the values at
 406 index /i/ all relate to each other.
 407
 408 This returns a query, which is a black box object that can be passed to the
 409 appropriate search object.
 410
 411 =cut
 412
 413 our $koha_to_index_name = {
 414     mainmainentry   => 'Heading-Main',
 415     mainentry       => 'Heading',
 416     match           => 'Match',
 417     'match-heading' => 'Match-heading',
 418     'see-from'      => 'Match-heading-see-from',
 419     thesaurus       => 'Subject-heading-thesaurus',
 420     all              => ''
 421 };
 422
 423 sub build_authorities_query_compat {
 424     my ( $self, $marclist, $and_or, $excluding, $operator, $value,
 425         $authtypecode, $orderby )
 426       = @_;
 427
 428     # This turns the old-style many-options argument form into a more
 429     # extensible hash form that is understood by L<build_authorities_query>.
 430     my @searches;
 431
 432     # Make sure everything exists
 433     foreach my $m (@$marclist) {
 434         Koha::Exceptions::WrongParameter->throw("Invalid marclist field provided: $m")
 435             unless exists $koha_to_index_name->{$m};
 436     }
 437     for ( my $i = 0 ; $i < @$value ; $i++ ) {
 438         next unless $value->[$i]; #clean empty form values, ES doesn't like undefined searches
 439         push @searches,
 440           {
 441             where    => $koha_to_index_name->{$marclist->[$i]},
 442             operator => $operator->[$i],
 443             value    => $value->[$i],
 444           };
 445     }
 446
 447     my %sort;
 448     my $sort_field =
 449         ( $orderby =~ /^Heading/ ) ? 'Heading'
 450       : ( $orderby =~ /^Auth/ )    ? 'Local-Number'
 451       :                              undef;
 452     if ($sort_field) {
 453         my $sort_order = ( $orderby =~ /Asc$/ ) ? 'asc' : 'desc';
 454         %sort = ( $sort_field => $sort_order, );
 455     }
 456     my %search = (
 457         searches     => \@searches,
 458         authtypecode => $authtypecode,
 459     );
 460     $search{sort} = \%sort if %sort;
 461     my $query = $self->build_authorities_query( \%search );
 462     return $query;
 463 }
 464
 465 =head2 _convert_sort_fields
 466
 467     my @sort_params = _convert_sort_fields(@sort_by)
 468
 469 Converts the zebra-style sort index information into elasticsearch-style.
 470
 471 C<@sort_by> is the same as presented to L<build_query_compat>, and it returns
 472 something that can be sent to L<build_query>.
 473
 474 =cut
 475
 476 sub _convert_sort_fields {
 477     my ( $self, @sort_by ) = @_;
 478
 479     # Turn the sorting into something we care about.
 480     my %sort_field_convert = (
 481         acqdate     => 'acqdate',
 482         author      => 'author',
 483         call_number => 'callnum',
 484         popularity  => 'issues',
 485         relevance   => undef,       # default
 486         title       => 'title',
 487         pubdate     => 'pubdate',
 488     );
 489     my %sort_order_convert =
 490       ( qw( dsc desc ), qw( asc asc ), qw( az asc ), qw( za desc ) );
 491
 492     # Convert the fields and orders, drop anything we don't know about.
 493     grep { $_->{field} } map {
 494         my ( $f, $d ) = split /_/;
 495         {
 496             field     => $sort_field_convert{$f},
 497             direction => $sort_order_convert{$d}
 498         }
 499     } @sort_by;
 500 }
 501
 502 =head2 _convert_index_fields
 503
 504     my @index_params = $self->_convert_index_fields(@indexes);
 505
 506 Converts zebra-style search index notation into elasticsearch-style.
 507
 508 C<@indexes> is an array of index names, as presented to L<build_query_compat>,
 509 and it returns something that can be sent to L<build_query>.
 510
 511 B<TODO>: this will pull from the elasticsearch mappings table to figure out
 512 types.
 513
 514 =cut
 515
 516 our %index_field_convert = (
 517     'kw'      => '_all',
 518     'ti'      => 'title',
 519     'au'      => 'author',
 520     'su'      => 'subject',
 521     'nb'      => 'isbn',
 522     'se'      => 'title-series',
 523     'callnum' => 'callnum',
 524     'itype'   => 'itype',
 525     'ln'      => 'ln',
 526     'branch'  => 'homebranch',
 527     'fic'     => 'lf',
 528     'mus'     => 'rtype',
 529     'aud'     => 'ta',
 530     'hi'      => 'Host-Item-Number',
 531 );
 532
 533 sub _convert_index_fields {
 534     my ( $self, @indexes ) = @_;
 535
 536     my %index_type_convert =
 537       ( __default => undef, phr => 'phrase', rtrn => 'right-truncate' );
 538
 539     # Convert according to our table, drop anything that doesn't convert.
 540     # If a field starts with mc- we save it as it's used (and removed) later
 541     # when joining things, to indicate we make it an 'OR' join.
 542     # (Sorry, this got a bit ugly after special cases were found.)
 543     grep { $_->{field} } map {
 544         my ( $f, $t ) = split /,/;
 545         my $mc = '';
 546         if ($f =~ /^mc-/) {
 547             $mc = 'mc-';
 548             $f =~ s/^mc-//;
 549         }
 550         my $r = {
 551             field => $index_field_convert{$f},
 552             type  => $index_type_convert{ $t // '__default' }
 553         };
 554         $r->{field} = ($mc . $r->{field}) if $mc && $r->{field};
 555         $r;
 556     } @indexes;
 557 }
 558
 559 =head2 _convert_index_strings
 560
 561     my @searches = $self->_convert_index_strings(@searches);
 562
 563 Similar to L<_convert_index_fields>, this takes strings of the form
 564 B<field:search term> and rewrites the field from zebra-style to
 565 elasticsearch-style. Anything it doesn't understand is returned verbatim.
 566
 567 =cut
 568
 569 sub _convert_index_strings {
 570     my ( $self, @searches ) = @_;
 571     my @res;
 572     foreach my $s (@searches) {
 573         next if $s eq '';
 574         my ( $field, $term ) = $s =~ /^\s*([\w,-]*?):(.*)/;
 575         unless ( defined($field) && defined($term) ) {
 576             push @res, $s;
 577             next;
 578         }
 579         my ($conv) = $self->_convert_index_fields($field);
 580         unless ( defined($conv) ) {
 581             push @res, $s;
 582             next;
 583         }
 584         push @res, $conv->{field} . ":"
 585           . $self->_modify_string_by_type( %$conv, operand => $term );
 586     }
 587     return @res;
 588 }
 589
 590 =head2 _convert_index_strings_freeform
 591
 592     my $search = $self->_convert_index_strings_freeform($search);
 593
 594 This is similar to L<_convert_index_strings>, however it'll search out the
 595 things to change within the string. So it can handle strings such as
 596 C<(su:foo) AND (su:bar)>, converting the C<su> appropriately.
 597
 598 If there is something of the form "su,complete-subfield" or something, the
 599 second part is stripped off as we can't yet handle that. Making it work
 600 will have to wait for a real query parser.
 601
 602 =cut
 603
 604 sub _convert_index_strings_freeform {
 605     my ( $self, $search ) = @_;
 606     while ( my ( $zeb, $es ) = each %index_field_convert ) {
 607         $search =~ s/\b$zeb(?:,[\w\-]*)?:/$es:/g;
 608     }
 609     return $search;
 610 }
 611
 612 =head2 _modify_string_by_type
 613
 614     my $str = $self->_modify_string_by_type(%index_field);
 615
 616 If you have a search term (operand) and a type (phrase, right-truncated), this
 617 will convert the string to have the function in lucene search terms, e.g.
 618 wrapping quotes around it.
 619
 620 =cut
 621
 622 sub _modify_string_by_type {
 623     my ( $self, %idx ) = @_;
 624
 625     my $type = $idx{type} || '';
 626     my $str = $idx{operand};
 627     return $str unless $str;    # Empty or undef, we can't use it.
 628
 629     $str .= '*' if $type eq 'right-truncate';
 630     $str = '"' . $str . '"' if $type eq 'phrase';
 631     return $str;
 632 }
 633
 634 =head2 _join_queries
 635
 636     my $query_str = $self->_join_queries(@query_parts);
 637
 638 This takes a list of query parts, that might be search terms on their own, or
 639 booleaned together, or specifying fields, or whatever, wraps them in
 640 parentheses, and ANDs them all together. Suitable for feeding to the ES
 641 query string query.
 642
 643 Note: doesn't AND them together if they specify an index that starts with "mc"
 644 as that was a special case in the original code for dealing with multiple
 645 choice options (you can't search for something that has an itype of A and
 646 and itype of B otherwise.)
 647
 648 =cut
 649
 650 sub _join_queries {
 651     my ( $self, @parts ) = @_;
 652
 653     my @norm_parts = grep { defined($_) && $_ ne '' && $_ !~ /^mc-/ } @parts;
 654     my @mc_parts =
 655       map { s/^mc-//r } grep { defined($_) && $_ ne '' && $_ =~ /^mc-/ } @parts;
 656     return () unless @norm_parts + @mc_parts;
 657     return ( @norm_parts, @mc_parts )[0] if @norm_parts + @mc_parts == 1;
 658     my $grouped_mc =
 659       @mc_parts ? '(' . ( join ' OR ', map { "($_)" } @mc_parts ) . ')' : ();
 660
 661     # Handy trick: $x || () inside a join means that if $x ends up as an
 662     # empty string, it gets replaced with (), which makes join ignore it.
 663     # (bad effect: this'll also happen to '0', this hopefully doesn't matter
 664     # in this case.)
 665     join( ' AND ',
 666         join( ' AND ', map { "($_)" } @norm_parts ) || (),
 667         $grouped_mc || () );
 668 }
 669
 670 =head2 _make_phrases
 671
 672     my @phrased_queries = $self->_make_phrases(@query_parts);
 673
 674 This takes the supplied queries and forces them to be phrases by wrapping
 675 quotes around them. It understands field prefixes, e.g. 'subject:' and puts
 676 the quotes outside of them if they're there.
 677
 678 =cut
 679
 680 sub _make_phrases {
 681     my ( $self, @parts ) = @_;
 682     map { s/^\s*(\w*?:)(.*)$/$1"$2"/r } @parts;
 683 }
 684
 685 =head2 _create_query_string
 686
 687     my @query_strings = $self->_create_query_string(@queries);
 688
 689 Given a list of hashrefs, it will turn them into a lucene-style query string.
 690 The hash should contain field, type (both for the indexes), operator, and
 691 operand.
 692
 693 =cut
 694
 695 sub _create_query_string {
 696     my ( $self, @queries ) = @_;
 697
 698     map {
 699         my $otor  = $_->{operator} ? $_->{operator} . ' ' : '';
 700         my $field = $_->{field}    ? $_->{field} . ':'    : '';
 701
 702         my $oand = $self->_modify_string_by_type(%$_);
 703         "$otor($field$oand)";
 704     } @queries;
 705 }
 706
 707 =head2 _clean_search_term
 708
 709     my $term = $self->_clean_search_term($term);
 710
 711 This cleans a search term by removing any funny characters that may upset
 712 ES and give us an error. It also calls L<_convert_index_strings_freeform>
 713 to ensure those parts are correct.
 714
 715 =cut
 716
 717 sub _clean_search_term {
 718     my ( $self, $term ) = @_;
 719
 720     my $auto_truncation = C4::Context->preference("QueryAutoTruncate") || 0;
 721
 722     # Some hardcoded searches (like with authorities) produce things like
 723     # 'an=123', when it ought to be 'an:123' for our purposes.
 724     $term =~ s/=/:/g;
 725     $term = $self->_convert_index_strings_freeform($term);
 726     $term =~ s/[{}]/"/g;
 727     $term = $self->_truncate_terms($term) if ($auto_truncation);
 728     return $term;
 729 }
 730
 731 =head2 _fix_limit_special_cases
 732
 733     my $limits = $self->_fix_limit_special_cases($limits);
 734
 735 This converts any special cases that the limit specifications have into things
 736 that are more readily processable by the rest of the code.
 737
 738 The argument should be an arrayref, and it'll return an arrayref.
 739
 740 =cut
 741
 742 sub _fix_limit_special_cases {
 743     my ( $self, $limits ) = @_;
 744
 745     my @new_lim;
 746     foreach my $l (@$limits) {
 747
 748         # This is set up by opac-search.pl
 749         if ( $l =~ /^yr,st-numeric,ge=/ ) {
 750             my ( $start, $end ) =
 751               ( $l =~ /^yr,st-numeric,ge=(.*) and yr,st-numeric,le=(.*)$/ );
 752             next unless defined($start) && defined($end);
 753             push @new_lim, "copydate:[$start TO $end]";
 754         }
 755         elsif ( $l =~ /^yr,st-numeric=/ ) {
 756             my ($date) = ( $l =~ /^yr,st-numeric=(.*)$/ );
 757             next unless defined($date);
 758             push @new_lim, "copydate:$date";
 759         }
 760         elsif ( $l =~ /^available$/ ) {
 761             push @new_lim, 'onloan:0';
 762         }
 763         else {
 764             push @new_lim, $l;
 765         }
 766     }
 767     return \@new_lim;
 768 }
 769
 770 =head2 _sort_field
 771
 772     my $field = $self->_sort_field($field);
 773
 774 Given a field name, this works out what the actual name of the version to sort
 775 on should be. Often it's the same, sometimes it involves sticking "__sort" on
 776 the end. Maybe it'll be something else in the future, who knows?
 777
 778 =cut
 779
 780 sub _sort_field {
 781     my ($self, $f) = @_;
 782     if ($self->sort_fields()->{$f}) {
 783         $f .= '__sort';
 784     }
 785     return $f;
 786 }
 787
 788 =head2 _truncate_terms
 789
 790     my $query = $self->_truncate_terms($query);
 791
 792 Given a string query this function appends '*' wildcard  to all terms except
 793 operands and double quoted strings.
 794
 795 =cut
 796
 797 sub _truncate_terms {
 798     my ( $self, $query ) = @_;
 799
 800     # '"donald duck" title:"the mouse" and peter" get split into
 801     # ['', '"donald duck"', '', ' ', '', 'title:"the mouse"', '', ' ', 'and', ' ', 'pete']
 802     my @tokens = split /((?:[\w\-.]+:)?"[^"]+"|\s+)/, $query;
 803
 804     # Filter out empty tokens
 805     my @words = grep { $_ !~ /^\s*$/ } @tokens;
 806
 807     # Append '*' to words if needed, ie. if it's not surrounded by quotes, not
 808     # terminated by '*' and not a keyword
 809     my @terms = map {
 810         my $w = $_;
 811         (/"$/ or /\*$/ or grep {lc($w) eq $_} qw/and or not/) ? $_ : "$_*";
 812     } @words;
 813
 814     return join ' ', @terms;
 815 }
 816
 817 1;