Open-ILS/src/perlmods/lib/OpenILS/Application/Storage/Publisher/metabib.pm

   1 package OpenILS::Application::Storage::Publisher::metabib;
   2 use base qw/OpenILS::Application::Storage::Publisher/;
   3 use vars qw/$VERSION/;
   4 use OpenSRF::EX qw/:try/;
   5 use OpenILS::Application::Storage::FTS;
   6 use OpenILS::Utils::Fieldmapper;
   7 use OpenSRF::Utils::Logger qw/:level/;
   8 use OpenSRF::Utils::Cache;
   9 use OpenSRF::Utils::JSON;
  10 use Data::Dumper;
  11 use Digest::MD5 qw/md5_hex/;
  12
  13 use OpenILS::Application::Storage::QueryParser;
  14
  15 my $log = 'OpenSRF::Utils::Logger';
  16
  17 $VERSION = 1;
  18
  19 sub _initialize_parser {
  20     my ($parser) = @_;
  21
  22     my $cstore = OpenSRF::AppSession->create( 'open-ils.cstore' );
  23     $parser->initialize(
  24         config_record_attr_index_norm_map =>
  25             $cstore->request(
  26                 'open-ils.cstore.direct.config.record_attr_index_norm_map.search.atomic',
  27                 { id => { "!=" => undef } },
  28                 { flesh => 1, flesh_fields => { crainm => [qw/norm/] }, order_by => [{ class => "crainm", field => "pos" }] }
  29             )->gather(1),
  30         search_relevance_adjustment         =>
  31             $cstore->request(
  32                 'open-ils.cstore.direct.search.relevance_adjustment.search.atomic',
  33                 { id => { "!=" => undef } }
  34             )->gather(1),
  35         config_metabib_field                =>
  36             $cstore->request(
  37                 'open-ils.cstore.direct.config.metabib_field.search.atomic',
  38                 { id => { "!=" => undef } }
  39             )->gather(1),
  40         config_metabib_search_alias         =>
  41             $cstore->request(
  42                 'open-ils.cstore.direct.config.metabib_search_alias.search.atomic',
  43                 { alias => { "!=" => undef } }
  44             )->gather(1),
  45         config_metabib_field_index_norm_map =>
  46             $cstore->request(
  47                 'open-ils.cstore.direct.config.metabib_field_index_norm_map.search.atomic',
  48                 { id => { "!=" => undef } },
  49                 { flesh => 1, flesh_fields => { cmfinm => [qw/norm/] }, order_by => [{ class => "cmfinm", field => "pos" }] }
  50             )->gather(1),
  51         config_record_attr_definition       =>
  52             $cstore->request(
  53                 'open-ils.cstore.direct.config.record_attr_definition.search.atomic',
  54                 { name => { "!=" => undef } }
  55             )->gather(1),
  56         config_metabib_class_ts_map         =>
  57             $cstore->request(
  58                 'open-ils.cstore.direct.config.metabib_class_ts_map.search.atomic',
  59                 { active => "t" }
  60             )->gather(1),
  61         config_metabib_field_ts_map         =>
  62             $cstore->request(
  63                 'open-ils.cstore.direct.config.metabib_field_ts_map.search.atomic',
  64                 { active => "t" }
  65             )->gather(1),
  66         config_metabib_class                =>
  67             $cstore->request(
  68                 'open-ils.cstore.direct.config.metabib_class.search.atomic',
  69                 { name => { "!=" => undef } }
  70             )->gather(1),
  71     );
  72
  73     $cstore->disconnect;
  74     die("Cannot initialize $parser!") unless ($parser->initialization_complete);
  75 }
  76
  77 sub ordered_records_from_metarecord {
  78         my $self = shift;
  79         my $client = shift;
  80         my $mr = shift;
  81         my $formats = shift;
  82         my $org = shift || 1;
  83         my $depth = shift;
  84
  85         my (@types,@forms,@blvl);
  86
  87         if ($formats) {
  88                 my ($t, $f, $b) = split '-', $formats;
  89                 @types = split '', $t;
  90                 @forms = split '', $f;
  91                 @blvl = split '', $b;
  92         }
  93
  94         my $descendants =
  95                 defined($depth) ?
  96                         "actor.org_unit_descendants($org, $depth)" :
  97                         "actor.org_unit_descendants($org)" ;
  98
  99
 100         my $copies_visible = 'AND d.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.opac_visible IS TRUE AND cl.opac_visible IS TRUE';
 101         $copies_visible = '' if ($self->api_name =~ /staff/o);
 102
 103         my $sm_table = metabib::metarecord_source_map->table;
 104         my $rd_table = metabib::record_descriptor->table;
 105         my $fr_table = metabib::full_rec->table;
 106         my $cn_table = asset::call_number->table;
 107         my $cl_table = asset::copy_location->table;
 108         my $cp_table = asset::copy->table;
 109         my $cs_table = config::copy_status->table;
 110         my $src_table = config::bib_source->table;
 111         my $out_table = actor::org_unit_type->table;
 112         my $br_table = biblio::record_entry->table;
 113
 114         my $sql = <<"   SQL";
 115                 SELECT  record,
 116                         item_type,
 117                         item_form,
 118                         quality,
 119                         FIRST(COALESCE(LTRIM(SUBSTR( value, COALESCE(SUBSTRING(ind2 FROM E'\\\\d+'),'0')::INT + 1 )),'zzzzzzzz')) AS title
 120                 FROM    (
 121                         SELECT  rd.record,
 122                                 rd.item_type,
 123                                 rd.item_form,
 124                                 br.quality,
 125                                 fr.tag,
 126                                 fr.subfield,
 127                                 fr.value,
 128                                 fr.ind2
 129         SQL
 130
 131         if ($copies_visible) {
 132                 $sql .= <<"             SQL";
 133                           FROM  $sm_table sm,
 134                                 $br_table br,
 135                                 $fr_table fr,
 136                                 $rd_table rd
 137                           WHERE rd.record = sm.source
 138                                 AND fr.record = sm.source
 139                                 AND br.id = sm.source
 140                                 AND sm.metarecord = ?
 141                                 AND (EXISTS ((SELECT    1
 142                                                 FROM    $cp_table cp
 143                                                         JOIN $cn_table cn ON (cp.call_number = cn.id)
 144                                                         JOIN $cs_table cs ON (cp.status = cs.id)
 145                                                         JOIN $cl_table cl ON (cp.location = cl.id)
 146                                                         JOIN $descendants d ON (cp.circ_lib = d.id)
 147                                                 WHERE   cn.record = sm.source
 148                                                         $copies_visible
 149                                                 LIMIT 1))
 150                                         OR EXISTS ((
 151                                             SELECT      1
 152                                               FROM      $src_table src
 153                                               WHERE     src.id = br.source
 154                                                         AND src.transcendant IS TRUE))
 155                                 )
 156
 157                 SQL
 158         } else {
 159                 $sql .= <<"             SQL";
 160                           FROM  $sm_table sm
 161                                 JOIN $br_table br ON (sm.source = br.id)
 162                                 JOIN $fr_table fr ON (fr.record = br.id)
 163                                 JOIN $rd_table rd ON (rd.record = br.id)
 164                           WHERE sm.metarecord = ?
 165                                 AND ((  EXISTS (
 166                                                 SELECT  1
 167                                                   FROM  $cp_table cp,
 168                                                         $cn_table cn,
 169                                                         $descendants d
 170                                                   WHERE cn.record = br.id
 171                                                         AND cn.deleted = FALSE
 172                                                         AND cp.deleted = FALSE
 173                                                         AND cp.circ_lib = d.id
 174                                                         AND cn.id = cp.call_number
 175                                                   LIMIT 1
 176                                         ) OR NOT EXISTS (
 177                                                 SELECT  1
 178                                                   FROM  $cp_table cp,
 179                                                         $cn_table cn
 180                                                   WHERE cn.record = br.id
 181                                                         AND cn.deleted = FALSE
 182                                                         AND cp.deleted = FALSE
 183                                                         AND cn.id = cp.call_number
 184                                                   LIMIT 1
 185                                         ))
 186                                         OR EXISTS ((
 187                                             SELECT      1
 188                                               FROM      $src_table src
 189                                               WHERE     src.id = br.source
 190                                                         AND src.transcendant IS TRUE))
 191                                 )
 192                 SQL
 193         }
 194
 195         if (@types) {
 196                 $sql .= '                               AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 197         }
 198
 199         if (@forms) {
 200                 $sql .= '                               AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 201         }
 202
 203         if (@blvl) {
 204                 $sql .= '                               AND rd.bib_level IN ('.join(',',map{'?'}@blvl).')';
 205         }
 206
 207
 208
 209         $sql .= <<"     SQL";
 210                           OFFSET 0
 211                         ) AS x
 212           WHERE tag = '245'
 213                 AND subfield = 'a'
 214           GROUP BY record, item_type, item_form, quality
 215           ORDER BY
 216                 CASE
 217                         WHEN item_type IS NULL -- default
 218                                 THEN 0
 219                         WHEN item_type = '' -- default
 220                                 THEN 0
 221                         WHEN item_type IN ('a','t') -- books
 222                                 THEN 1
 223                         WHEN item_type = 'g' -- movies
 224                                 THEN 2
 225                         WHEN item_type IN ('i','j') -- sound recordings
 226                                 THEN 3
 227                         WHEN item_type = 'm' -- software
 228                                 THEN 4
 229                         WHEN item_type = 'k' -- images
 230                                 THEN 5
 231                         WHEN item_type IN ('e','f') -- maps
 232                                 THEN 6
 233                         WHEN item_type IN ('o','p') -- mixed
 234                                 THEN 7
 235                         WHEN item_type IN ('c','d') -- music
 236                                 THEN 8
 237                         WHEN item_type = 'r' -- 3d
 238                                 THEN 9
 239                 END,
 240                 title ASC,
 241                 quality DESC
 242         SQL
 243
 244         my $ids = metabib::metarecord_source_map->db_Main->selectcol_arrayref($sql, {}, "$mr", @types, @forms, @blvl);
 245         return $ids if ($self->api_name =~ /atomic$/o);
 246
 247         $client->respond( $_ ) for ( @$ids );
 248         return undef;
 249
 250 }
 251 __PACKAGE__->register_method(
 252         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records',
 253         method          => 'ordered_records_from_metarecord',
 254         api_level       => 1,
 255         cachable        => 1,
 256 );
 257 __PACKAGE__->register_method(
 258         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.staff',
 259         method          => 'ordered_records_from_metarecord',
 260         api_level       => 1,
 261         cachable        => 1,
 262 );
 263
 264 __PACKAGE__->register_method(
 265         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.atomic',
 266         method          => 'ordered_records_from_metarecord',
 267         api_level       => 1,
 268         cachable        => 1,
 269 );
 270 __PACKAGE__->register_method(
 271         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.staff.atomic',
 272         method          => 'ordered_records_from_metarecord',
 273         api_level       => 1,
 274         cachable        => 1,
 275 );
 276
 277 # XXX: this subroutine and its two registered methods are marked for
 278 # deprecation, as they do not work properly in 2.x (these tags are no longer
 279 # normalized in mfr) and are not in known use
 280 sub isxn_search {
 281         my $self = shift;
 282         my $client = shift;
 283         my $isxn = lc(shift());
 284
 285         $isxn =~ s/^\s*//o;
 286         $isxn =~ s/\s*$//o;
 287         $isxn =~ s/-//o if ($self->api_name =~ /isbn/o);
 288
 289         my $tag = ($self->api_name =~ /isbn/o) ? "'020' OR f.tag = '024'" : "'022'";
 290
 291         my $fr_table = metabib::full_rec->table;
 292         my $bib_table = biblio::record_entry->table;
 293
 294         my $sql = <<"   SQL";
 295                 SELECT  DISTINCT f.record
 296                   FROM  $fr_table f
 297                         JOIN $bib_table b ON (b.id = f.record)
 298                   WHERE (f.tag = $tag)
 299                         AND f.value LIKE ?
 300                         AND b.deleted IS FALSE
 301         SQL
 302
 303         my $list = metabib::full_rec->db_Main->selectcol_arrayref($sql, {}, "$isxn%");
 304         $client->respond($_) for (@$list);
 305         return undef;
 306 }
 307 __PACKAGE__->register_method(
 308         api_name        => 'open-ils.storage.id_list.biblio.record_entry.search.isbn',
 309         method          => 'isxn_search',
 310         api_level       => 1,
 311         stream          => 1,
 312 );
 313 __PACKAGE__->register_method(
 314         api_name        => 'open-ils.storage.id_list.biblio.record_entry.search.issn',
 315         method          => 'isxn_search',
 316         api_level       => 1,
 317         stream          => 1,
 318 );
 319
 320 sub metarecord_copy_count {
 321         my $self = shift;
 322         my $client = shift;
 323
 324         my %args = @_;
 325
 326         my $sm_table = metabib::metarecord_source_map->table;
 327         my $rd_table = metabib::record_descriptor->table;
 328         my $cn_table = asset::call_number->table;
 329         my $cp_table = asset::copy->table;
 330         my $br_table = biblio::record_entry->table;
 331         my $src_table = config::bib_source->table;
 332         my $cl_table = asset::copy_location->table;
 333         my $cs_table = config::copy_status->table;
 334         my $out_table = actor::org_unit_type->table;
 335
 336         my $descendants = "actor.org_unit_descendants(u.id)";
 337         my $ancestors = "actor.org_unit_ancestors(?) u JOIN $out_table t ON (u.ou_type = t.id)";
 338
 339     if ($args{org_unit} < 0) {
 340         $args{org_unit} *= -1;
 341         $ancestors = "(select org_unit as id from actor.org_lasso_map where lasso = ?) u CROSS JOIN (SELECT -1 AS depth) t";
 342     }
 343
 344         my $copies_visible = 'AND a.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.opac_visible IS TRUE AND cl.opac_visible IS TRUE';
 345         $copies_visible = '' if ($self->api_name =~ /staff/o);
 346
 347         my (@types,@forms,@blvl);
 348         my ($t_filter, $f_filter, $b_filter) = ('','','');
 349
 350         if ($args{format}) {
 351                 my ($t, $f, $b) = split '-', $args{format};
 352                 @types = split '', $t;
 353                 @forms = split '', $f;
 354                 @blvl = split '', $b;
 355
 356                 if (@types) {
 357                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 358                 }
 359
 360                 if (@forms) {
 361                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 362                 }
 363
 364                 if (@blvl) {
 365                         $b_filter .= ' AND rd.bib_level IN ('.join(',',map{'?'}@blvl).')';
 366                 }
 367         }
 368
 369         my $sql = <<"   SQL";
 370                 SELECT  t.depth,
 371                         u.id AS org_unit,
 372                         sum(
 373                                 (SELECT count(cp.id)
 374                                   FROM  $sm_table r
 375                                         JOIN $cn_table cn ON (cn.record = r.source)
 376                                         JOIN $rd_table rd ON (cn.record = rd.record)
 377                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 378                                         JOIN $cs_table cs ON (cp.status = cs.id)
 379                                         JOIN $cl_table cl ON (cp.location = cl.id)
 380                                         JOIN $descendants a ON (cp.circ_lib = a.id)
 381                                   WHERE r.metarecord = ?
 382                                         AND cn.deleted IS FALSE
 383                                         AND cp.deleted IS FALSE
 384                                         $copies_visible
 385                                         $t_filter
 386                                         $f_filter
 387                                         $b_filter
 388                                 )
 389                         ) AS count,
 390                         sum(
 391                                 (SELECT count(cp.id)
 392                                   FROM  $sm_table r
 393                                         JOIN $cn_table cn ON (cn.record = r.source)
 394                                         JOIN $rd_table rd ON (cn.record = rd.record)
 395                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 396                                         JOIN $cs_table cs ON (cp.status = cs.id)
 397                                         JOIN $cl_table cl ON (cp.location = cl.id)
 398                                         JOIN $descendants a ON (cp.circ_lib = a.id)
 399                                   WHERE r.metarecord = ?
 400                                         AND cp.status IN (0,7,12)
 401                                         AND cn.deleted IS FALSE
 402                                         AND cp.deleted IS FALSE
 403                                         $copies_visible
 404                                         $t_filter
 405                                         $f_filter
 406                                         $b_filter
 407                                 )
 408                         ) AS available,
 409                         sum(
 410                                 (SELECT count(cp.id)
 411                                   FROM  $sm_table r
 412                                         JOIN $cn_table cn ON (cn.record = r.source)
 413                                         JOIN $rd_table rd ON (cn.record = rd.record)
 414                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 415                                         JOIN $cs_table cs ON (cp.status = cs.id)
 416                                         JOIN $cl_table cl ON (cp.location = cl.id)
 417                                   WHERE r.metarecord = ?
 418                                         AND cn.deleted IS FALSE
 419                                         AND cp.deleted IS FALSE
 420                                         AND cp.opac_visible IS TRUE
 421                                         AND cs.opac_visible IS TRUE
 422                                         AND cl.opac_visible IS TRUE
 423                                         $t_filter
 424                                         $f_filter
 425                                         $b_filter
 426                                 )
 427                         ) AS unshadow,
 428                         sum(
 429                                 (SELECT sum(1)
 430                                   FROM  $sm_table r
 431                                         JOIN $br_table br ON (br.id = r.source)
 432                                         JOIN $src_table src ON (src.id = br.source)
 433                                   WHERE r.metarecord = ?
 434                                         AND src.transcendant IS TRUE
 435                                 )
 436                         ) AS transcendant
 437
 438                   FROM  $ancestors
 439                   GROUP BY 1,2
 440         SQL
 441
 442         my $sth = metabib::metarecord_source_map->db_Main->prepare_cached($sql);
 443         $sth->execute(  ''.$args{metarecord},
 444                         @types,
 445                         @forms,
 446                         @blvl,
 447                         ''.$args{metarecord},
 448                         @types,
 449                         @forms,
 450                         @blvl,
 451                         ''.$args{metarecord},
 452                         @types,
 453                         @forms,
 454                         @blvl,
 455                         ''.$args{metarecord},
 456                         ''.$args{org_unit},
 457         );
 458
 459         while ( my $row = $sth->fetchrow_hashref ) {
 460                 $client->respond( $row );
 461         }
 462         return undef;
 463 }
 464 __PACKAGE__->register_method(
 465         api_name        => 'open-ils.storage.metabib.metarecord.copy_count',
 466         method          => 'metarecord_copy_count',
 467         api_level       => 1,
 468         stream          => 1,
 469         cachable        => 1,
 470 );
 471 __PACKAGE__->register_method(
 472         api_name        => 'open-ils.storage.metabib.metarecord.copy_count.staff',
 473         method          => 'metarecord_copy_count',
 474         api_level       => 1,
 475         stream          => 1,
 476         cachable        => 1,
 477 );
 478
 479 sub biblio_multi_search_full_rec {
 480     my $self   = shift;
 481     my $client = shift;
 482     my %args   = @_;
 483
 484     my $class_join = $args{class_join} || 'AND';
 485     my $limit      = $args{limit}      || 100;
 486     my $offset     = $args{offset}     || 0;
 487     my $sort       = $args{'sort'};
 488     my $sort_dir   = $args{sort_dir}   || 'DESC';
 489
 490         my @binds;
 491         my @selects;
 492
 493         for my $arg (@{ $args{searches} }) {
 494                 my $term     = $$arg{term};
 495                 my $limiters = $$arg{restrict};
 496
 497                 my ($index_col)  = metabib::full_rec->columns('FTS');
 498                 $index_col ||= 'value';
 499                 my $search_table = metabib::full_rec->table;
 500
 501                 my $fts = OpenILS::Application::Storage::FTS->compile('default' => $term, 'value',"$index_col");
 502
 503                 my $fts_where = $fts->sql_where_clause();
 504                 my @fts_ranks = $fts->fts_rank;
 505
 506                 my $rank = join(' + ', @fts_ranks);
 507
 508                 my @wheres;
 509                 for my $limit (@$limiters) {
 510                         if ($$limit{tag} =~ /^\d+$/ and $$limit{tag} < 10) {
 511                                 # MARC control field; mfr.subfield is NULL
 512                                 push @wheres, "( tag = ? AND $fts_where )";
 513                                 push @binds, $$limit{tag};
 514                                 $log->debug("Limiting query using { tag => $$limit{tag} }", DEBUG);
 515                         } else {
 516                                 push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
 517                                 push @binds, $$limit{tag}, $$limit{subfield};
 518                                 $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
 519                         }
 520                 }
 521                 my $where = join(' OR ', @wheres);
 522
 523                 push @selects, "SELECT record, AVG($rank) as sum FROM $search_table WHERE $where GROUP BY record";
 524
 525         }
 526
 527         my $descendants = defined($args{depth}) ?
 528                                 "actor.org_unit_descendants($args{org_unit}, $args{depth})" :
 529                                 "actor.org_unit_descendants($args{org_unit})" ;
 530
 531
 532         my $metabib_record_descriptor = metabib::record_descriptor->table;
 533         my $metabib_full_rec = metabib::full_rec->table;
 534         my $asset_call_number_table = asset::call_number->table;
 535         my $asset_copy_table = asset::copy->table;
 536         my $cs_table = config::copy_status->table;
 537         my $cl_table = asset::copy_location->table;
 538         my $br_table = biblio::record_entry->table;
 539
 540         my $cj = 'HAVING COUNT(x.record) = ' . scalar(@selects) if ($class_join eq 'AND');
 541         my $search_table =
 542                 '(SELECT x.record, sum(x.sum) FROM (('.
 543                         join(') UNION ALL (', @selects).
 544                         ")) x GROUP BY 1 $cj ORDER BY 2 DESC )";
 545
 546         my $has_vols = 'AND cn.owning_lib = d.id';
 547         my $has_copies = 'AND cp.call_number = cn.id';
 548         my $copies_visible = 'AND d.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.opac_visible IS TRUE AND cl.opac_visible IS TRUE';
 549
 550         if ($self->api_name =~ /staff/o) {
 551                 $copies_visible = '';
 552                 $has_copies     = '' if ($ou_type == 0);
 553                 $has_vols       = '' if ($ou_type == 0);
 554         }
 555
 556         my ($t_filter, $f_filter) = ('','');
 557         my ($a_filter, $l_filter, $lf_filter) = ('','','');
 558
 559         if (my $a = $args{audience}) {
 560                 $a = [$a] if (!ref($a));
 561                 my @aud = @$a;
 562
 563                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
 564                 push @binds, @aud;
 565         }
 566
 567         if (my $l = $args{language}) {
 568                 $l = [$l] if (!ref($l));
 569                 my @lang = @$l;
 570
 571                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
 572                 push @binds, @lang;
 573         }
 574
 575         if (my $f = $args{lit_form}) {
 576                 $f = [$f] if (!ref($f));
 577                 my @lit_form = @$f;
 578
 579                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
 580                 push @binds, @lit_form;
 581         }
 582
 583         if (my $f = $args{item_form}) {
 584                 $f = [$f] if (!ref($f));
 585                 my @forms = @$f;
 586
 587                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 588                 push @binds, @forms;
 589         }
 590
 591         if (my $t = $args{item_type}) {
 592                 $t = [$t] if (!ref($t));
 593                 my @types = @$t;
 594
 595                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 596                 push @binds, @types;
 597         }
 598
 599
 600         if ($args{format}) {
 601                 my ($t, $f) = split '-', $args{format};
 602                 my @types = split '', $t;
 603                 my @forms = split '', $f;
 604                 if (@types) {
 605                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 606                 }
 607
 608                 if (@forms) {
 609                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 610                 }
 611                 push @binds, @types, @forms;
 612         }
 613
 614         my $relevance = 'sum(f.sum)';
 615         $relevance = 1 if (!$copies_visible);
 616
 617         my $rank = $relevance;
 618         if (lc($sort) eq 'pubdate') {
 619                 $rank = <<"             RANK";
 620                         ( FIRST ((
 621                                 SELECT  COALESCE(SUBSTRING(frp.value FROM E'\\\\d+'),'9999')::INT
 622                                   FROM  $metabib_full_rec frp
 623                                   WHERE frp.record = f.record
 624                                         AND frp.tag = '260'
 625                                         AND frp.subfield = 'c'
 626                                   LIMIT 1
 627                         )) )
 628                 RANK
 629         } elsif (lc($sort) eq 'create_date') {
 630                 $rank = <<"             RANK";
 631                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = f.record)) )
 632                 RANK
 633         } elsif (lc($sort) eq 'edit_date') {
 634                 $rank = <<"             RANK";
 635                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = f.record)) )
 636                 RANK
 637         } elsif (lc($sort) eq 'title') {
 638                 $rank = <<"             RANK";
 639                         ( FIRST ((
 640                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM E'\\\\d+'),'0')::INT + 1 )),'zzzzzzzz')
 641                                   FROM  $metabib_full_rec frt
 642                                   WHERE frt.record = f.record
 643                                         AND frt.tag = '245'
 644                                         AND frt.subfield = 'a'
 645                                   LIMIT 1
 646                         )) )
 647                 RANK
 648         } elsif (lc($sort) eq 'author') {
 649                 $rank = <<"             RANK";
 650                         ( FIRST((
 651                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
 652                                   FROM  $metabib_full_rec fra
 653                                   WHERE fra.record = f.record
 654                                         AND fra.tag LIKE '1%'
 655                                         AND fra.subfield = 'a'
 656                                   ORDER BY fra.tag::text::int
 657                                   LIMIT 1
 658                         )) )
 659                 RANK
 660         } else {
 661                 $sort = undef;
 662         }
 663
 664
 665         if ($copies_visible) {
 666                 $select = <<"           SQL";
 667                         SELECT  f.record, $relevance, count(DISTINCT cp.id), $rank
 668                         FROM    $search_table f,
 669                                 $asset_call_number_table cn,
 670                                 $asset_copy_table cp,
 671                                 $cs_table cs,
 672                                 $cl_table cl,
 673                                 $br_table br,
 674                                 $metabib_record_descriptor rd,
 675                                 $descendants d
 676                         WHERE   br.id = f.record
 677                                 AND cn.record = f.record
 678                                 AND rd.record = f.record
 679                                 AND cp.status = cs.id
 680                                 AND cp.location = cl.id
 681                                 AND br.deleted IS FALSE
 682                                 AND cn.deleted IS FALSE
 683                                 AND cp.deleted IS FALSE
 684                                 $has_vols
 685                                 $has_copies
 686                                 $copies_visible
 687                                 $t_filter
 688                                 $f_filter
 689                                 $a_filter
 690                                 $l_filter
 691                                 $lf_filter
 692                         GROUP BY f.record HAVING count(DISTINCT cp.id) > 0
 693                         ORDER BY 4 $sort_dir,3 DESC
 694                 SQL
 695         } else {
 696                 $select = <<"           SQL";
 697                         SELECT  f.record, 1, 1, $rank
 698                         FROM    $search_table f,
 699                                 $br_table br,
 700                                 $metabib_record_descriptor rd
 701                         WHERE   br.id = f.record
 702                                 AND rd.record = f.record
 703                                 AND br.deleted IS FALSE
 704                                 $t_filter
 705                                 $f_filter
 706                                 $a_filter
 707                                 $l_filter
 708                                 $lf_filter
 709                         GROUP BY 1,2,3
 710                         ORDER BY 4 $sort_dir
 711                 SQL
 712         }
 713
 714
 715         $log->debug("Search SQL :: [$select]",DEBUG);
 716
 717         my $recs = metabib::full_rec->db_Main->selectall_arrayref("$select;", {}, @binds);
 718         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 719
 720         my $max = 0;
 721         $max = 1 if (!@$recs);
 722         for (@$recs) {
 723                 $max = $$_[1] if ($$_[1] > $max);
 724         }
 725
 726         my $count = @$recs;
 727         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
 728                 next unless ($$rec[0]);
 729                 my ($rid,$rank,$junk,$skip) = @$rec;
 730                 $client->respond( [$rid, sprintf('%0.3f',$rank/$max), $count] );
 731         }
 732         return undef;
 733 }
 734 __PACKAGE__->register_method(
 735         api_name        => 'open-ils.storage.biblio.full_rec.multi_search',
 736         method          => 'biblio_multi_search_full_rec',
 737         api_level       => 1,
 738         stream          => 1,
 739         cachable        => 1,
 740 );
 741 __PACKAGE__->register_method(
 742         api_name        => 'open-ils.storage.biblio.full_rec.multi_search.staff',
 743         method          => 'biblio_multi_search_full_rec',
 744         api_level       => 1,
 745         stream          => 1,
 746         cachable        => 1,
 747 );
 748
 749 sub search_full_rec {
 750         my $self = shift;
 751         my $client = shift;
 752
 753         my %args = @_;
 754
 755         my $term = $args{term};
 756         my $limiters = $args{restrict};
 757
 758         my ($index_col) = metabib::full_rec->columns('FTS');
 759         $index_col ||= 'value';
 760         my $search_table = metabib::full_rec->table;
 761
 762         my $fts = OpenILS::Application::Storage::FTS->compile('default' => $term, 'value',"$index_col");
 763
 764         my $fts_where = $fts->sql_where_clause();
 765         my @fts_ranks = $fts->fts_rank;
 766
 767         my $rank = join(' + ', @fts_ranks);
 768
 769         my @binds;
 770         my @wheres;
 771         for my $limit (@$limiters) {
 772                 if ($$limit{tag} =~ /^\d+$/ and $$limit{tag} < 10) {
 773                         # MARC control field; mfr.subfield is NULL
 774                         push @wheres, "( tag = ? AND $fts_where )";
 775                         push @binds, $$limit{tag};
 776                         $log->debug("Limiting query using { tag => $$limit{tag} }", DEBUG);
 777                 } else {
 778                         push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
 779                         push @binds, $$limit{tag}, $$limit{subfield};
 780                         $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
 781                 }
 782         }
 783         my $where = join(' OR ', @wheres);
 784
 785         my $select = "SELECT record, sum($rank) FROM $search_table WHERE $where GROUP BY 1 ORDER BY 2 DESC;";
 786
 787         $log->debug("Search SQL :: [$select]",DEBUG);
 788
 789         my $recs = metabib::full_rec->db_Main->selectall_arrayref($select, {}, @binds);
 790         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 791
 792         $client->respond($_) for (@$recs);
 793         return undef;
 794 }
 795 __PACKAGE__->register_method(
 796         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.value',
 797         method          => 'search_full_rec',
 798         api_level       => 1,
 799         stream          => 1,
 800         cachable        => 1,
 801 );
 802 __PACKAGE__->register_method(
 803         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.index_vector',
 804         method          => 'search_full_rec',
 805         api_level       => 1,
 806         stream          => 1,
 807         cachable        => 1,
 808 );
 809
 810
 811 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 812 sub search_class_fts {
 813         my $self = shift;
 814         my $client = shift;
 815         my %args = @_;
 816
 817         my $term = $args{term};
 818         my $ou = $args{org_unit};
 819         my $ou_type = $args{depth};
 820         my $limit = $args{limit};
 821         my $offset = $args{offset};
 822
 823         my $limit_clause = '';
 824         my $offset_clause = '';
 825
 826         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
 827         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
 828
 829         my (@types,@forms);
 830         my ($t_filter, $f_filter) = ('','');
 831
 832         if ($args{format}) {
 833                 my ($t, $f) = split '-', $args{format};
 834                 @types = split '', $t;
 835                 @forms = split '', $f;
 836                 if (@types) {
 837                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 838                 }
 839
 840                 if (@forms) {
 841                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 842                 }
 843         }
 844
 845
 846
 847         my $descendants = defined($ou_type) ?
 848                                 "actor.org_unit_descendants($ou, $ou_type)" :
 849                                 "actor.org_unit_descendants($ou)";
 850
 851         my $class = $self->{cdbi};
 852         my $search_table = $class->table;
 853
 854         my $metabib_record_descriptor = metabib::record_descriptor->table;
 855         my $metabib_metarecord = metabib::metarecord->table;
 856         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
 857         my $asset_call_number_table = asset::call_number->table;
 858         my $asset_copy_table = asset::copy->table;
 859         my $cs_table = config::copy_status->table;
 860         my $cl_table = asset::copy_location->table;
 861
 862         my ($index_col) = $class->columns('FTS');
 863         $index_col ||= 'value';
 864
 865         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
 866         my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $term, 'f.value', "f.$index_col");
 867
 868         my $fts_where = $fts->sql_where_clause;
 869         my @fts_ranks = $fts->fts_rank;
 870
 871         my $rank = join(' + ', @fts_ranks);
 872
 873         my $has_vols = 'AND cn.owning_lib = d.id';
 874         my $has_copies = 'AND cp.call_number = cn.id';
 875         my $copies_visible = 'AND d.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.opac_visible IS TRUE AND cl.opac_visible IS TRUE';
 876
 877         my $visible_count = ', count(DISTINCT cp.id)';
 878         my $visible_count_test = 'HAVING count(DISTINCT cp.id) > 0';
 879
 880         if ($self->api_name =~ /staff/o) {
 881                 $copies_visible = '';
 882                 $visible_count_test = '';
 883                 $has_copies = '' if ($ou_type == 0);
 884                 $has_vols = '' if ($ou_type == 0);
 885         }
 886
 887         my $rank_calc = <<"     RANK";
 888                 , (SUM( $rank
 889                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
 890                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
 891                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
 892                 )/COUNT(m.source)), MIN(COALESCE(CHAR_LENGTH(f.value),1))
 893         RANK
 894
 895         $rank_calc = ',1 , 1' if ($self->api_name =~ /unordered/o);
 896
 897         if ($copies_visible) {
 898                 $select = <<"           SQL";
 899                         SELECT  m.metarecord $rank_calc $visible_count, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
 900                         FROM    $search_table f,
 901                                 $metabib_metarecord_source_map_table m,
 902                                 $asset_call_number_table cn,
 903                                 $asset_copy_table cp,
 904                                 $cs_table cs,
 905                                 $cl_table cl,
 906                                 $metabib_record_descriptor rd,
 907                                 $descendants d
 908                         WHERE   $fts_where
 909                                 AND m.source = f.source
 910                                 AND cn.record = m.source
 911                                 AND rd.record = m.source
 912                                 AND cp.status = cs.id
 913                                 AND cp.location = cl.id
 914                                 $has_vols
 915                                 $has_copies
 916                                 $copies_visible
 917                                 $t_filter
 918                                 $f_filter
 919                         GROUP BY 1 $visible_count_test
 920                         ORDER BY 2 DESC,3
 921                         $limit_clause $offset_clause
 922                 SQL
 923         } else {
 924                 $select = <<"           SQL";
 925                         SELECT  m.metarecord $rank_calc, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
 926                         FROM    $search_table f,
 927                                 $metabib_metarecord_source_map_table m,
 928                                 $metabib_record_descriptor rd
 929                         WHERE   $fts_where
 930                                 AND m.source = f.source
 931                                 AND rd.record = m.source
 932                                 $t_filter
 933                                 $f_filter
 934                         GROUP BY 1, 4
 935                         ORDER BY 2 DESC,3
 936                         $limit_clause $offset_clause
 937                 SQL
 938         }
 939
 940         $log->debug("Field Search SQL :: [$select]",DEBUG);
 941
 942         my $SQLstring = join('%',$fts->words);
 943         my $REstring = join('\\s+',$fts->words);
 944         my $first_word = ($fts->words)[0].'%';
 945         my $recs = ($self->api_name =~ /unordered/o) ?
 946                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
 947                         $class->db_Main->selectall_arrayref($select, {},
 948                                 '%'.lc($SQLstring).'%',                 # phrase order match
 949                                 lc($first_word),                        # first word match
 950                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
 951                                 @types, @forms
 952                         );
 953
 954         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 955
 956         $client->respond($_) for (map { [@$_[0,1,3,4]] } @$recs);
 957         return undef;
 958 }
 959
 960 for my $class ( qw/title author subject keyword series identifier/ ) {
 961         __PACKAGE__->register_method(
 962                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord",
 963                 method          => 'search_class_fts',
 964                 api_level       => 1,
 965                 stream          => 1,
 966                 cdbi            => "metabib::${class}_field_entry",
 967                 cachable        => 1,
 968         );
 969         __PACKAGE__->register_method(
 970                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.unordered",
 971                 method          => 'search_class_fts',
 972                 api_level       => 1,
 973                 stream          => 1,
 974                 cdbi            => "metabib::${class}_field_entry",
 975                 cachable        => 1,
 976         );
 977         __PACKAGE__->register_method(
 978                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff",
 979                 method          => 'search_class_fts',
 980                 api_level       => 1,
 981                 stream          => 1,
 982                 cdbi            => "metabib::${class}_field_entry",
 983                 cachable        => 1,
 984         );
 985         __PACKAGE__->register_method(
 986                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff.unordered",
 987                 method          => 'search_class_fts',
 988                 api_level       => 1,
 989                 stream          => 1,
 990                 cdbi            => "metabib::${class}_field_entry",
 991                 cachable        => 1,
 992         );
 993 }
 994
 995 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 996 sub search_class_fts_count {
 997         my $self = shift;
 998         my $client = shift;
 999         my %args = @_;
1000
1001         my $term = $args{term};
1002         my $ou = $args{org_unit};
1003         my $ou_type = $args{depth};
1004         my $limit = $args{limit} || 100;
1005         my $offset = $args{offset} || 0;
1006
1007         my $descendants = defined($ou_type) ?
1008                                 "actor.org_unit_descendants($ou, $ou_type)" :
1009                                 "actor.org_unit_descendants($ou)";
1010
1011         my (@types,@forms);
1012         my ($t_filter, $f_filter) = ('','');
1013
1014         if ($args{format}) {
1015                 my ($t, $f) = split '-', $args{format};
1016                 @types = split '', $t;
1017                 @forms = split '', $f;
1018                 if (@types) {
1019                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1020                 }
1021
1022                 if (@forms) {
1023                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1024                 }
1025         }
1026
1027
1028         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
1029
1030         my $class = $self->{cdbi};
1031         my $search_table = $class->table;
1032
1033         my $metabib_record_descriptor = metabib::record_descriptor->table;
1034         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1035         my $asset_call_number_table = asset::call_number->table;
1036         my $asset_copy_table = asset::copy->table;
1037         my $cs_table = config::copy_status->table;
1038         my $cl_table = asset::copy_location->table;
1039
1040         my ($index_col) = $class->columns('FTS');
1041         $index_col ||= 'value';
1042
1043         my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $term, 'value',"$index_col");
1044
1045         my $fts_where = $fts->sql_where_clause;
1046
1047         my $has_vols = 'AND cn.owning_lib = d.id';
1048         my $has_copies = 'AND cp.call_number = cn.id';
1049         my $copies_visible = 'AND d.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.opac_visible IS TRUE AND cl.opac_visible IS TRUE';
1050         if ($self->api_name =~ /staff/o) {
1051                 $copies_visible = '';
1052                 $has_vols = '' if ($ou_type == 0);
1053                 $has_copies = '' if ($ou_type == 0);
1054         }
1055
1056         # XXX test an "EXISTS version of descendant checking...
1057         my $select;
1058         if ($copies_visible) {
1059                 $select = <<"           SQL";
1060                 SELECT  count(distinct  m.metarecord)
1061                   FROM  $search_table f,
1062                         $metabib_metarecord_source_map_table m,
1063                         $metabib_metarecord_source_map_table mr,
1064                         $asset_call_number_table cn,
1065                         $asset_copy_table cp,
1066                         $cs_table cs,
1067                         $cl_table cl,
1068                         $metabib_record_descriptor rd,
1069                         $descendants d
1070                   WHERE $fts_where
1071                         AND mr.source = f.source
1072                         AND mr.metarecord = m.metarecord
1073                         AND cn.record = m.source
1074                         AND rd.record = m.source
1075                         AND cp.status = cs.id
1076                         AND cp.location = cl.id
1077                         $has_vols
1078                         $has_copies
1079                         $copies_visible
1080                         $t_filter
1081                         $f_filter
1082                 SQL
1083         } else {
1084                 $select = <<"           SQL";
1085                 SELECT  count(distinct  m.metarecord)
1086                   FROM  $search_table f,
1087                         $metabib_metarecord_source_map_table m,
1088                         $metabib_metarecord_source_map_table mr,
1089                         $metabib_record_descriptor rd
1090                   WHERE $fts_where
1091                         AND mr.source = f.source
1092                         AND mr.metarecord = m.metarecord
1093                         AND rd.record = m.source
1094                         $t_filter
1095                         $f_filter
1096                 SQL
1097         }
1098
1099         $log->debug("Field Search Count SQL :: [$select]",DEBUG);
1100
1101         my $recs = $class->db_Main->selectrow_arrayref($select, {}, @types, @forms)->[0];
1102
1103         $log->debug("Count Search yielded $recs results.",DEBUG);
1104
1105         return $recs;
1106
1107 }
1108 for my $class ( qw/title author subject keyword series identifier/ ) {
1109         __PACKAGE__->register_method(
1110                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count",
1111                 method          => 'search_class_fts_count',
1112                 api_level       => 1,
1113                 stream          => 1,
1114                 cdbi            => "metabib::${class}_field_entry",
1115                 cachable        => 1,
1116         );
1117         __PACKAGE__->register_method(
1118                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count.staff",
1119                 method          => 'search_class_fts_count',
1120                 api_level       => 1,
1121                 stream          => 1,
1122                 cdbi            => "metabib::${class}_field_entry",
1123                 cachable        => 1,
1124         );
1125 }
1126
1127
1128 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1129 sub postfilter_search_class_fts {
1130         my $self = shift;
1131         my $client = shift;
1132         my %args = @_;
1133
1134         my $term = $args{term};
1135         my $sort = $args{'sort'};
1136         my $sort_dir = $args{sort_dir} || 'DESC';
1137         my $ou = $args{org_unit};
1138         my $ou_type = $args{depth};
1139         my $limit = $args{limit} || 10;
1140         my $visibility_limit = $args{visibility_limit} || 5000;
1141         my $offset = $args{offset} || 0;
1142
1143         my $outer_limit = 1000;
1144
1145         my $limit_clause = '';
1146         my $offset_clause = '';
1147
1148         $limit_clause = "LIMIT $outer_limit";
1149         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1150
1151         my (@types,@forms,@lang,@aud,@lit_form);
1152         my ($t_filter, $f_filter) = ('','');
1153         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1154         my ($ot_filter, $of_filter) = ('','');
1155         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1156
1157         if (my $a = $args{audience}) {
1158                 $a = [$a] if (!ref($a));
1159                 @aud = @$a;
1160
1161                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1162                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1163         }
1164
1165         if (my $l = $args{language}) {
1166                 $l = [$l] if (!ref($l));
1167                 @lang = @$l;
1168
1169                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1170                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1171         }
1172
1173         if (my $f = $args{lit_form}) {
1174                 $f = [$f] if (!ref($f));
1175                 @lit_form = @$f;
1176
1177                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1178                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1179         }
1180
1181         if ($args{format}) {
1182                 my ($t, $f) = split '-', $args{format};
1183                 @types = split '', $t;
1184                 @forms = split '', $f;
1185                 if (@types) {
1186                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1187                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1188                 }
1189
1190                 if (@forms) {
1191                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1192                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1193                 }
1194         }
1195
1196
1197         my $descendants = defined($ou_type) ?
1198                                 "actor.org_unit_descendants($ou, $ou_type)" :
1199                                 "actor.org_unit_descendants($ou)";
1200
1201         my $class = $self->{cdbi};
1202         my $search_table = $class->table;
1203
1204         my $metabib_full_rec = metabib::full_rec->table;
1205         my $metabib_record_descriptor = metabib::record_descriptor->table;
1206         my $metabib_metarecord = metabib::metarecord->table;
1207         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1208         my $asset_call_number_table = asset::call_number->table;
1209         my $asset_copy_table = asset::copy->table;
1210         my $cs_table = config::copy_status->table;
1211         my $cl_table = asset::copy_location->table;
1212         my $br_table = biblio::record_entry->table;
1213
1214         my ($index_col) = $class->columns('FTS');
1215         $index_col ||= 'value';
1216
1217         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).post_filter.*/$1/o;
1218
1219         my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $term, 'f.value', "f.$index_col");
1220
1221         my $SQLstring = join('%',map { lc($_) } $fts->words);
1222         my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1223         my $first_word = lc(($fts->words)[0]).'%';
1224
1225         my $fts_where = $fts->sql_where_clause;
1226         my @fts_ranks = $fts->fts_rank;
1227
1228         my %bonus = ();
1229         $bonus{'metabib::identifier_field_entry'} =
1230         $bonus{'metabib::keyword_field_entry'} = [
1231             { 'CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END' => $SQLstring }
1232         ];
1233
1234         $bonus{'metabib::title_field_entry'} =
1235                 $bonus{'metabib::series_field_entry'} = [
1236                         { 'CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END' => $first_word },
1237                         { 'CASE WHEN f.value ~* ? THEN 2 ELSE 1 END' => $REstring },
1238                         @{ $bonus{'metabib::keyword_field_entry'} }
1239                 ];
1240
1241         my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$class} };
1242         $bonus_list ||= '1';
1243
1244         my @bonus_values = map { values %$_ } @{ $bonus{$class} };
1245
1246         my $relevance = join(' + ', @fts_ranks);
1247         $relevance = <<"        RANK";
1248                         (SUM( ( $relevance )  * ( $bonus_list ) )/COUNT(m.source))
1249         RANK
1250
1251         my $string_default_sort = 'zzzz';
1252         $string_default_sort = 'AAAA' if ($sort_dir eq 'DESC');
1253
1254         my $number_default_sort = '9999';
1255         $number_default_sort = '0000' if ($sort_dir eq 'DESC');
1256
1257         my $rank = $relevance;
1258         if (lc($sort) eq 'pubdate') {
1259                 $rank = <<"             RANK";
1260                         ( FIRST ((
1261                                 SELECT  COALESCE(SUBSTRING(frp.value FROM E'\\\\d+'),'$number_default_sort')::INT
1262                                   FROM  $metabib_full_rec frp
1263                                   WHERE frp.record = mr.master_record
1264                                         AND frp.tag = '260'
1265                                         AND frp.subfield = 'c'
1266                                   LIMIT 1
1267                         )) )
1268                 RANK
1269         } elsif (lc($sort) eq 'create_date') {
1270                 $rank = <<"             RANK";
1271                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1272                 RANK
1273         } elsif (lc($sort) eq 'edit_date') {
1274                 $rank = <<"             RANK";
1275                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1276                 RANK
1277         } elsif (lc($sort) eq 'title') {
1278                 $rank = <<"             RANK";
1279                         ( FIRST ((
1280                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM E'\\\\d+'),'0')::INT + 1 )),'$string_default_sort')
1281                                   FROM  $metabib_full_rec frt
1282                                   WHERE frt.record = mr.master_record
1283                                         AND frt.tag = '245'
1284                                         AND frt.subfield = 'a'
1285                                   LIMIT 1
1286                         )) )
1287                 RANK
1288         } elsif (lc($sort) eq 'author') {
1289                 $rank = <<"             RANK";
1290                         ( FIRST((
1291                                 SELECT  COALESCE(LTRIM(fra.value),'$string_default_sort')
1292                                   FROM  $metabib_full_rec fra
1293                                   WHERE fra.record = mr.master_record
1294                                         AND fra.tag LIKE '1%'
1295                                         AND fra.subfield = 'a'
1296                                   ORDER BY fra.tag::text::int
1297                                   LIMIT 1
1298                         )) )
1299                 RANK
1300         } else {
1301                 $sort = undef;
1302         }
1303
1304         my $select = <<"        SQL";
1305                 SELECT  m.metarecord,
1306                         $relevance,
1307                         CASE WHEN COUNT(DISTINCT smrs.source) = 1 THEN MIN(m.source) ELSE 0 END,
1308                         $rank
1309                 FROM    $search_table f,
1310                         $metabib_metarecord_source_map_table m,
1311                         $metabib_metarecord_source_map_table smrs,
1312                         $metabib_metarecord mr,
1313                         $metabib_record_descriptor rd
1314                 WHERE   $fts_where
1315                         AND smrs.metarecord = mr.id
1316                         AND m.source = f.source
1317                         AND m.metarecord = mr.id
1318                         AND rd.record = smrs.source
1319                         $t_filter
1320                         $f_filter
1321                         $a_filter
1322                         $l_filter
1323                         $lf_filter
1324                 GROUP BY m.metarecord
1325                 ORDER BY 4 $sort_dir, MIN(COALESCE(CHAR_LENGTH(f.value),1))
1326                 LIMIT $visibility_limit
1327         SQL
1328
1329         if (0) {
1330                 $select = <<"           SQL";
1331
1332                         SELECT  DISTINCT s.*
1333                           FROM  $asset_call_number_table cn,
1334                                 $metabib_metarecord_source_map_table mrs,
1335                                 $asset_copy_table cp,
1336                                 $cs_table cs,
1337                                 $cl_table cl,
1338                                 $br_table br,
1339                                 $descendants d,
1340                                 $metabib_record_descriptor ord,
1341                                 ($select) s
1342                           WHERE mrs.metarecord = s.metarecord
1343                                 AND br.id = mrs.source
1344                                 AND cn.record = mrs.source
1345                                 AND cp.status = cs.id
1346                                 AND cp.location = cl.id
1347                                 AND cn.owning_lib = d.id
1348                                 AND cp.call_number = cn.id
1349                                 AND cp.opac_visible IS TRUE
1350                                 AND cs.opac_visible IS TRUE
1351                                 AND cl.opac_visible IS TRUE
1352                                 AND d.opac_visible IS TRUE
1353                                 AND br.active IS TRUE
1354                                 AND br.deleted IS FALSE
1355                                 AND ord.record = mrs.source
1356                                 $ot_filter
1357                                 $of_filter
1358                                 $oa_filter
1359                                 $ol_filter
1360                                 $olf_filter
1361                           ORDER BY 4 $sort_dir
1362                 SQL
1363         } elsif ($self->api_name !~ /staff/o) {
1364                 $select = <<"           SQL";
1365
1366                         SELECT  DISTINCT s.*
1367                           FROM  ($select) s
1368                           WHERE EXISTS (
1369                                 SELECT  1
1370                                   FROM  $asset_call_number_table cn,
1371                                         $metabib_metarecord_source_map_table mrs,
1372                                         $asset_copy_table cp,
1373                                         $cs_table cs,
1374                                         $cl_table cl,
1375                                         $br_table br,
1376                                         $descendants d,
1377                                         $metabib_record_descriptor ord
1378
1379                                   WHERE mrs.metarecord = s.metarecord
1380                                         AND br.id = mrs.source
1381                                         AND cn.record = mrs.source
1382                                         AND cp.status = cs.id
1383                                         AND cp.location = cl.id
1384                                         AND cp.circ_lib = d.id
1385                                         AND cp.call_number = cn.id
1386                                         AND cp.opac_visible IS TRUE
1387                                         AND cs.opac_visible IS TRUE
1388                                         AND cl.opac_visible IS TRUE
1389                                         AND d.opac_visible IS TRUE
1390                                         AND br.active IS TRUE
1391                                         AND br.deleted IS FALSE
1392                                         AND ord.record = mrs.source
1393                                         $ot_filter
1394                                         $of_filter
1395                                         $oa_filter
1396                                         $ol_filter
1397                                         $olf_filter
1398                                   LIMIT 1
1399                                 )
1400                           ORDER BY 4 $sort_dir
1401                 SQL
1402         } else {
1403                 $select = <<"           SQL";
1404
1405                         SELECT  DISTINCT s.*
1406                           FROM  ($select) s
1407                           WHERE EXISTS (
1408                                 SELECT  1
1409                                   FROM  $asset_call_number_table cn,
1410                                         $asset_copy_table cp,
1411                                         $metabib_metarecord_source_map_table mrs,
1412                                         $br_table br,
1413                                         $descendants d,
1414                                         $metabib_record_descriptor ord
1415
1416                                   WHERE mrs.metarecord = s.metarecord
1417                                         AND br.id = mrs.source
1418                                         AND cn.record = mrs.source
1419                                         AND cn.id = cp.call_number
1420                                         AND br.deleted IS FALSE
1421                                         AND cn.deleted IS FALSE
1422                                         AND ord.record = mrs.source
1423                                         AND (   cn.owning_lib = d.id
1424                                                 OR (    cp.circ_lib = d.id
1425                                                         AND cp.deleted IS FALSE
1426                                                 )
1427                                         )
1428                                         $ot_filter
1429                                         $of_filter
1430                                         $oa_filter
1431                                         $ol_filter
1432                                         $olf_filter
1433                                   LIMIT 1
1434                                 )
1435                                 OR NOT EXISTS (
1436                                 SELECT  1
1437                                   FROM  $asset_call_number_table cn,
1438                                         $metabib_metarecord_source_map_table mrs,
1439                                         $metabib_record_descriptor ord
1440                                   WHERE mrs.metarecord = s.metarecord
1441                                         AND cn.record = mrs.source
1442                                         AND ord.record = mrs.source
1443                                         $ot_filter
1444                                         $of_filter
1445                                         $oa_filter
1446                                         $ol_filter
1447                                         $olf_filter
1448                                   LIMIT 1
1449                                 )
1450                           ORDER BY 4 $sort_dir
1451                 SQL
1452         }
1453
1454
1455         $log->debug("Field Search SQL :: [$select]",DEBUG);
1456
1457         my $recs = $class->db_Main->selectall_arrayref(
1458                         $select, {},
1459                         (@bonus_values > 0 ? @bonus_values : () ),
1460                         ( (!$sort && @bonus_values > 0) ? @bonus_values : () ),
1461                         @types, @forms, @aud, @lang, @lit_form,
1462                         @types, @forms, @aud, @lang, @lit_form,
1463                         ($self->api_name =~ /staff/o ? (@types, @forms, @aud, @lang, @lit_form) : () ) );
1464
1465         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1466
1467         my $max = 0;
1468         $max = 1 if (!@$recs);
1469         for (@$recs) {
1470                 $max = $$_[1] if ($$_[1] > $max);
1471         }
1472
1473         my $count = scalar(@$recs);
1474         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1475                 my ($mrid,$rank,$skip) = @$rec;
1476                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $skip, $count] );
1477         }
1478         return undef;
1479 }
1480
1481 for my $class ( qw/title author subject keyword series identifier/ ) {
1482         __PACKAGE__->register_method(
1483                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord",
1484                 method          => 'postfilter_search_class_fts',
1485                 api_level       => 1,
1486                 stream          => 1,
1487                 cdbi            => "metabib::${class}_field_entry",
1488                 cachable        => 1,
1489         );
1490         __PACKAGE__->register_method(
1491                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord.staff",
1492                 method          => 'postfilter_search_class_fts',
1493                 api_level       => 1,
1494                 stream          => 1,
1495                 cdbi            => "metabib::${class}_field_entry",
1496                 cachable        => 1,
1497         );
1498 }
1499
1500
1501
1502 my $_cdbi = {   title   => "metabib::title_field_entry",
1503                 author  => "metabib::author_field_entry",
1504                 subject => "metabib::subject_field_entry",
1505                 keyword => "metabib::keyword_field_entry",
1506                 series  => "metabib::series_field_entry",
1507                 identifier      => "metabib::identifier_field_entry",
1508 };
1509
1510 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1511 sub postfilter_search_multi_class_fts {
1512     my $self   = shift;
1513     my $client = shift;
1514     my %args   = @_;
1515
1516     my $sort             = $args{'sort'};
1517     my $sort_dir         = $args{sort_dir} || 'DESC';
1518     my $ou               = $args{org_unit};
1519     my $ou_type          = $args{depth};
1520     my $limit            = $args{limit}  || 10;
1521     my $offset           = $args{offset} ||  0;
1522     my $visibility_limit = $args{visibility_limit} || 5000;
1523
1524         if (!$ou) {
1525                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
1526         }
1527
1528         if (!defined($args{org_unit})) {
1529                 die "No target organizational unit passed to ".$self->api_name;
1530         }
1531
1532         if (! scalar( keys %{$args{searches}} )) {
1533                 die "No search arguments were passed to ".$self->api_name;
1534         }
1535
1536         my $outer_limit = 1000;
1537
1538         my $limit_clause  = '';
1539         my $offset_clause = '';
1540
1541         $limit_clause  = "LIMIT $outer_limit";
1542         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1543
1544         my ($avail_filter,@types,@forms,@lang,@aud,@lit_form,@vformats) = ('');
1545         my ($t_filter,   $f_filter,   $v_filter) = ('','','');
1546         my ($a_filter,   $l_filter,  $lf_filter) = ('','','');
1547         my ($ot_filter, $of_filter,  $ov_filter) = ('','','');
1548         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1549
1550         if ($args{available}) {
1551                 $avail_filter = ' AND cp.status IN (0,7,12)';
1552         }
1553
1554         if (my $a = $args{audience}) {
1555                 $a = [$a] if (!ref($a));
1556                 @aud = @$a;
1557
1558                 $a_filter  = ' AND  rd.audience IN ('.join(',',map{'?'}@aud).')';
1559                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1560         }
1561
1562         if (my $l = $args{language}) {
1563                 $l = [$l] if (!ref($l));
1564                 @lang = @$l;
1565
1566                 $l_filter  = ' AND  rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1567                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1568         }
1569
1570         if (my $f = $args{lit_form}) {
1571                 $f = [$f] if (!ref($f));
1572                 @lit_form = @$f;
1573
1574                 $lf_filter  = ' AND  rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1575                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1576         }
1577
1578         if (my $f = $args{item_form}) {
1579                 $f = [$f] if (!ref($f));
1580                 @forms = @$f;
1581
1582                 $f_filter  = ' AND  rd.item_form IN ('.join(',',map{'?'}@forms).')';
1583                 $of_filter = ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1584         }
1585
1586         if (my $t = $args{item_type}) {
1587                 $t = [$t] if (!ref($t));
1588                 @types = @$t;
1589
1590                 $t_filter  = ' AND  rd.item_type IN ('.join(',',map{'?'}@types).')';
1591                 $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1592         }
1593
1594         if (my $v = $args{vr_format}) {
1595                 $v = [$v] if (!ref($v));
1596                 @vformats = @$v;
1597
1598                 $v_filter  = ' AND  rd.vr_format IN ('.join(',',map{'?'}@vformats).')';
1599                 $ov_filter = ' AND ord.vr_format IN ('.join(',',map{'?'}@vformats).')';
1600         }
1601
1602
1603         # XXX legacy format and item type support
1604         if ($args{format}) {
1605                 my ($t, $f) = split '-', $args{format};
1606                 @types = split '', $t;
1607                 @forms = split '', $f;
1608                 if (@types) {
1609                         $t_filter  = ' AND  rd.item_type IN ('.join(',',map{'?'}@types).')';
1610                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1611                 }
1612
1613                 if (@forms) {
1614                         $f_filter  .= ' AND  rd.item_form IN ('.join(',',map{'?'}@forms).')';
1615                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1616                 }
1617         }
1618
1619
1620
1621         my $descendants = defined($ou_type) ?
1622                                 "actor.org_unit_descendants($ou, $ou_type)" :
1623                                 "actor.org_unit_descendants($ou)";
1624
1625     my $search_table_list = '';
1626     my $fts_list          = '';
1627     my $join_table_list   = '';
1628     my @rank_list;
1629
1630         my $field_table = config::metabib_field->table;
1631
1632         my @bonus_lists;
1633         my @bonus_values;
1634         my $prev_search_group;
1635         my $curr_search_group;
1636         my $search_class;
1637         my $search_field;
1638         my $metabib_field;
1639         for my $search_group (sort keys %{$args{searches}}) {
1640                 (my $search_group_name = $search_group) =~ s/\|/_/gso;
1641                 ($search_class,$search_field) = split /\|/, $search_group;
1642                 $log->debug("Searching class [$search_class] and field [$search_field]",DEBUG);
1643
1644                 if ($search_field) {
1645                         unless ( $metabib_field = config::metabib_field->search( field_class => $search_class, name => $search_field )->next ) {
1646                                 $log->warn("Requested class [$search_class] or field [$search_field] does not exist!");
1647                                 return undef;
1648                         }
1649                 }
1650
1651                 $prev_search_group = $curr_search_group if ($curr_search_group);
1652
1653                 $curr_search_group = $search_group_name;
1654
1655                 my $class = $_cdbi->{$search_class};
1656                 my $search_table = $class->table;
1657
1658                 my ($index_col) = $class->columns('FTS');
1659                 $index_col ||= 'value';
1660
1661
1662                 my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $args{searches}{$search_group}{term}, $search_group_name.'.value', "$search_group_name.$index_col");
1663
1664                 my $fts_where = $fts->sql_where_clause;
1665                 my @fts_ranks = $fts->fts_rank;
1666
1667                 my $SQLstring = join('%',map { lc($_) } $fts->words);
1668                 my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1669                 my $first_word = lc(($fts->words)[0]).'%';
1670
1671                 $_.=" * (SELECT weight FROM $field_table WHERE $search_group_name.field = id)" for (@fts_ranks);
1672                 my $rank = join(' + ', @fts_ranks);
1673
1674                 my %bonus = ();
1675                 $bonus{'keyword'} = [ { "CASE WHEN $search_group_name.value LIKE ? THEN 10 ELSE 1 END" => $SQLstring } ];
1676                 $bonus{'author'}  = [ { "CASE WHEN $search_group_name.value ILIKE ? THEN 10 ELSE 1 END" => $first_word } ];
1677
1678                 $bonus{'series'} = [
1679                         { "CASE WHEN $search_group_name.value LIKE ? THEN 1.5 ELSE 1 END" => $first_word },
1680                         { "CASE WHEN $search_group_name.value ~ ? THEN 20 ELSE 1 END" => $REstring },
1681                 ];
1682
1683                 $bonus{'title'} = [ @{ $bonus{'series'} }, @{ $bonus{'keyword'} } ];
1684
1685                 my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$search_class} };
1686                 $bonus_list ||= '1';
1687
1688                 push @bonus_lists, $bonus_list;
1689                 push @bonus_values, map { values %$_ } @{ $bonus{$search_class} };
1690
1691
1692                 #---------------------
1693
1694                 $search_table_list .= "$search_table $search_group_name, ";
1695                 push @rank_list,$rank;
1696                 $fts_list .= " AND $fts_where AND m.source = $search_group_name.source";
1697
1698                 if ($metabib_field) {
1699                         $join_table_list .= " AND $search_group_name.field = " . $metabib_field->id;
1700                         $metabib_field = undef;
1701                 }
1702
1703                 if ($prev_search_group) {
1704                         $join_table_list .= " AND $prev_search_group.source = $curr_search_group.source";
1705                 }
1706         }
1707
1708         my $metabib_record_descriptor = metabib::record_descriptor->table;
1709         my $metabib_full_rec = metabib::full_rec->table;
1710         my $metabib_metarecord = metabib::metarecord->table;
1711         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1712         my $asset_call_number_table = asset::call_number->table;
1713         my $asset_copy_table = asset::copy->table;
1714         my $cs_table = config::copy_status->table;
1715         my $cl_table = asset::copy_location->table;
1716         my $br_table = biblio::record_entry->table;
1717         my $source_table = config::bib_source->table;
1718
1719         my $bonuses = join (' * ', @bonus_lists);
1720         my $relevance = join (' + ', @rank_list);
1721         $relevance = "SUM( ($relevance) * ($bonuses) )/COUNT(DISTINCT smrs.source)";
1722
1723         my $string_default_sort = 'zzzz';
1724         $string_default_sort = 'AAAA' if ($sort_dir eq 'DESC');
1725
1726         my $number_default_sort = '9999';
1727         $number_default_sort = '0000' if ($sort_dir eq 'DESC');
1728
1729
1730
1731         my $secondary_sort = <<"        SORT";
1732                 ( FIRST ((
1733                         SELECT  COALESCE(LTRIM(SUBSTR( sfrt.value, COALESCE(SUBSTRING(sfrt.ind2 FROM E'\\\\d+'),'0')::INT + 1 )),'$string_default_sort')
1734                           FROM  $metabib_full_rec sfrt,
1735                                 $metabib_metarecord mr
1736                           WHERE sfrt.record = mr.master_record
1737                                 AND sfrt.tag = '245'
1738                                 AND sfrt.subfield = 'a'
1739                           LIMIT 1
1740                 )) )
1741         SORT
1742
1743         my $rank = $relevance;
1744         if (lc($sort) eq 'pubdate') {
1745                 $rank = <<"             RANK";
1746                         ( FIRST ((
1747                                 SELECT  COALESCE(SUBSTRING(frp.value FROM E'\\\\d+'),'$number_default_sort')::INT
1748                                   FROM  $metabib_full_rec frp
1749                                   WHERE frp.record = mr.master_record
1750                                         AND frp.tag = '260'
1751                                         AND frp.subfield = 'c'
1752                                   LIMIT 1
1753                         )) )
1754                 RANK
1755         } elsif (lc($sort) eq 'create_date') {
1756                 $rank = <<"             RANK";
1757                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1758                 RANK
1759         } elsif (lc($sort) eq 'edit_date') {
1760                 $rank = <<"             RANK";
1761                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1762                 RANK
1763         } elsif (lc($sort) eq 'title') {
1764                 $rank = <<"             RANK";
1765                         ( FIRST ((
1766                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM E'\\\\d+'),'0')::INT + 1 )),'$string_default_sort')
1767                                   FROM  $metabib_full_rec frt
1768                                   WHERE frt.record = mr.master_record
1769                                         AND frt.tag = '245'
1770                                         AND frt.subfield = 'a'
1771                                   LIMIT 1
1772                         )) )
1773                 RANK
1774                 $secondary_sort = <<"           SORT";
1775                         ( FIRST ((
1776                                 SELECT  COALESCE(SUBSTRING(sfrp.value FROM E'\\\\d+'),'$number_default_sort')::INT
1777                                   FROM  $metabib_full_rec sfrp
1778                                   WHERE sfrp.record = mr.master_record
1779                                         AND sfrp.tag = '260'
1780                                         AND sfrp.subfield = 'c'
1781                                   LIMIT 1
1782                         )) )
1783                 SORT
1784         } elsif (lc($sort) eq 'author') {
1785                 $rank = <<"             RANK";
1786                         ( FIRST((
1787                                 SELECT  COALESCE(LTRIM(fra.value),'$string_default_sort')
1788                                   FROM  $metabib_full_rec fra
1789                                   WHERE fra.record = mr.master_record
1790                                         AND fra.tag LIKE '1%'
1791                                         AND fra.subfield = 'a'
1792                                   ORDER BY fra.tag::text::int
1793                                   LIMIT 1
1794                         )) )
1795                 RANK
1796         } else {
1797                 push @bonus_values, @bonus_values;
1798                 $sort = undef;
1799         }
1800
1801
1802         my $select = <<"        SQL";
1803                 SELECT  m.metarecord,
1804                         $relevance,
1805                         CASE WHEN COUNT(DISTINCT smrs.source) = 1 THEN FIRST(m.source) ELSE 0 END,
1806                         $rank,
1807                         $secondary_sort
1808                 FROM    $search_table_list
1809                         $metabib_metarecord mr,
1810                         $metabib_metarecord_source_map_table m,
1811                         $metabib_metarecord_source_map_table smrs
1812                 WHERE   m.metarecord = smrs.metarecord
1813                         AND mr.id = m.metarecord
1814                         $fts_list
1815                         $join_table_list
1816                 GROUP BY m.metarecord
1817                 -- ORDER BY 4 $sort_dir
1818                 LIMIT $visibility_limit
1819         SQL
1820
1821         if ($self->api_name !~ /staff/o) {
1822                 $select = <<"           SQL";
1823
1824                         SELECT  s.*
1825                           FROM  ($select) s
1826                           WHERE EXISTS (
1827                                 SELECT  1
1828                                   FROM  $asset_call_number_table cn,
1829                                         $metabib_metarecord_source_map_table mrs,
1830                                         $asset_copy_table cp,
1831                                         $cs_table cs,
1832                                         $cl_table cl,
1833                                         $br_table br,
1834                                         $descendants d,
1835                                         $metabib_record_descriptor ord
1836                                   WHERE mrs.metarecord = s.metarecord
1837                                         AND br.id = mrs.source
1838                                         AND cn.record = mrs.source
1839                                         AND cp.status = cs.id
1840                                         AND cp.location = cl.id
1841                                         AND cp.circ_lib = d.id
1842                                         AND cp.call_number = cn.id
1843                                         AND cp.opac_visible IS TRUE
1844                                         AND cs.opac_visible IS TRUE
1845                                         AND cl.opac_visible IS TRUE
1846                                         AND d.opac_visible IS TRUE
1847                                         AND br.active IS TRUE
1848                                         AND br.deleted IS FALSE
1849                                         AND cp.deleted IS FALSE
1850                                         AND cn.deleted IS FALSE
1851                                         AND ord.record = mrs.source
1852                                         $ot_filter
1853                                         $of_filter
1854                                         $ov_filter
1855                                         $oa_filter
1856                                         $ol_filter
1857                                         $olf_filter
1858                                         $avail_filter
1859                                   LIMIT 1
1860                                 )
1861                                 OR EXISTS (
1862                                 SELECT  1
1863                                   FROM  $br_table br,
1864                                         $metabib_metarecord_source_map_table mrs,
1865                                         $metabib_record_descriptor ord,
1866                                         $source_table src
1867                                   WHERE mrs.metarecord = s.metarecord
1868                                         AND ord.record = mrs.source
1869                                         AND br.id = mrs.source
1870                                         AND br.source = src.id
1871                                         AND src.transcendant IS TRUE
1872                                         $ot_filter
1873                                         $of_filter
1874                                         $ov_filter
1875                                         $oa_filter
1876                                         $ol_filter
1877                                         $olf_filter
1878                                 )
1879                           ORDER BY 4 $sort_dir, 5
1880                 SQL
1881         } else {
1882                 $select = <<"           SQL";
1883
1884                         SELECT  DISTINCT s.*
1885                           FROM  ($select) s,
1886                                 $metabib_metarecord_source_map_table omrs,
1887                                 $metabib_record_descriptor ord
1888                           WHERE omrs.metarecord = s.metarecord
1889                                 AND ord.record = omrs.source
1890                                 AND (   EXISTS (
1891                                                 SELECT  1
1892                                                   FROM  $asset_call_number_table cn,
1893                                                         $asset_copy_table cp,
1894                                                         $descendants d,
1895                                                         $br_table br
1896                                                   WHERE br.id = omrs.source
1897                                                         AND cn.record = omrs.source
1898                                                         AND br.deleted IS FALSE
1899                                                         AND cn.deleted IS FALSE
1900                                                         AND cp.call_number = cn.id
1901                                                         AND (   cn.owning_lib = d.id
1902                                                                 OR (    cp.circ_lib = d.id
1903                                                                         AND cp.deleted IS FALSE
1904                                                                 )
1905                                                         )
1906                                                         $avail_filter
1907                                                   LIMIT 1
1908                                         )
1909                                         OR NOT EXISTS (
1910                                                 SELECT  1
1911                                                   FROM  $asset_call_number_table cn
1912                                                   WHERE cn.record = omrs.source
1913                                                         AND cn.deleted IS FALSE
1914                                                   LIMIT 1
1915                                         )
1916                                         OR EXISTS (
1917                                         SELECT  1
1918                                           FROM  $br_table br,
1919                                                 $metabib_metarecord_source_map_table mrs,
1920                                                 $metabib_record_descriptor ord,
1921                                                 $source_table src
1922                                           WHERE mrs.metarecord = s.metarecord
1923                                                 AND br.id = mrs.source
1924                                                 AND br.source = src.id
1925                                                 AND src.transcendant IS TRUE
1926                                                 $ot_filter
1927                                                 $of_filter
1928                                                 $ov_filter
1929                                                 $oa_filter
1930                                                 $ol_filter
1931                                                 $olf_filter
1932                                         )
1933                                 )
1934                                 $ot_filter
1935                                 $of_filter
1936                                 $ov_filter
1937                                 $oa_filter
1938                                 $ol_filter
1939                                 $olf_filter
1940
1941                           ORDER BY 4 $sort_dir, 5
1942                 SQL
1943         }
1944
1945
1946         $log->debug("Field Search SQL :: [$select]",DEBUG);
1947
1948         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
1949                         $select, {},
1950                         @bonus_values,
1951                         @types, @forms, @vformats, @aud, @lang, @lit_form,
1952                         @types, @forms, @vformats, @aud, @lang, @lit_form,
1953                         # ($self->api_name =~ /staff/o ? (@types, @forms, @aud, @lang, @lit_form) : () )
1954         );
1955
1956         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1957
1958         my $max = 0;
1959         $max = 1 if (!@$recs);
1960         for (@$recs) {
1961                 $max = $$_[1] if ($$_[1] > $max);
1962         }
1963
1964         my $count = scalar(@$recs);
1965         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1966                 next unless ($$rec[0]);
1967                 my ($mrid,$rank,$skip) = @$rec;
1968                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $skip, $count] );
1969         }
1970         return undef;
1971 }
1972
1973 __PACKAGE__->register_method(
1974         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord",
1975         method          => 'postfilter_search_multi_class_fts',
1976         api_level       => 1,
1977         stream          => 1,
1978         cachable        => 1,
1979 );
1980 __PACKAGE__->register_method(
1981         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord.staff",
1982         method          => 'postfilter_search_multi_class_fts',
1983         api_level       => 1,
1984         stream          => 1,
1985         cachable        => 1,
1986 );
1987
1988 __PACKAGE__->register_method(
1989         api_name        => "open-ils.storage.metabib.multiclass.search_fts",
1990         method          => 'postfilter_search_multi_class_fts',
1991         api_level       => 1,
1992         stream          => 1,
1993         cachable        => 1,
1994 );
1995 __PACKAGE__->register_method(
1996         api_name        => "open-ils.storage.metabib.multiclass.search_fts.staff",
1997         method          => 'postfilter_search_multi_class_fts',
1998         api_level       => 1,
1999         stream          => 1,
2000         cachable        => 1,
2001 );
2002
2003 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
2004 sub biblio_search_multi_class_fts {
2005         my $self = shift;
2006         my $client = shift;
2007         my %args = @_;
2008
2009     my $sort             = $args{'sort'};
2010     my $sort_dir         = $args{sort_dir} || 'DESC';
2011     my $ou               = $args{org_unit};
2012     my $ou_type          = $args{depth};
2013     my $limit            = $args{limit}  || 10;
2014     my $offset           = $args{offset} ||  0;
2015     my $pref_lang        = $args{preferred_language} || 'eng';
2016     my $visibility_limit = $args{visibility_limit}  || 5000;
2017
2018         if (!$ou) {
2019                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
2020         }
2021
2022         if (! scalar( keys %{$args{searches}} )) {
2023                 die "No search arguments were passed to ".$self->api_name;
2024         }
2025
2026         my $outer_limit = 1000;
2027
2028         my $limit_clause  = '';
2029         my $offset_clause = '';
2030
2031         $limit_clause  = "LIMIT $outer_limit";
2032         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
2033
2034         my ($avail_filter,@types,@forms,@lang,@aud,@lit_form,@vformats) = ('');
2035         my ($t_filter,   $f_filter,   $v_filter) = ('','','');
2036         my ($a_filter,   $l_filter,  $lf_filter) = ('','','');
2037         my ($ot_filter, $of_filter,  $ov_filter) = ('','','');
2038         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
2039
2040         if ($args{available}) {
2041                 $avail_filter = ' AND cp.status IN (0,7,12)';
2042         }
2043
2044         if (my $a = $args{audience}) {
2045                 $a = [$a] if (!ref($a));
2046                 @aud = @$a;
2047
2048                 $a_filter  = ' AND rd.audience  IN ('.join(',',map{'?'}@aud).')';
2049                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
2050         }
2051
2052         if (my $l = $args{language}) {
2053                 $l = [$l] if (!ref($l));
2054                 @lang = @$l;
2055
2056                 $l_filter  = ' AND rd.item_lang  IN ('.join(',',map{'?'}@lang).')';
2057                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
2058         }
2059
2060         if (my $f = $args{lit_form}) {
2061                 $f = [$f] if (!ref($f));
2062                 @lit_form = @$f;
2063
2064                 $lf_filter  = ' AND rd.lit_form  IN ('.join(',',map{'?'}@lit_form).')';
2065                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
2066         }
2067
2068         if (my $f = $args{item_form}) {
2069                 $f = [$f] if (!ref($f));
2070                 @forms = @$f;
2071
2072                 $f_filter  = ' AND rd.item_form  IN ('.join(',',map{'?'}@forms).')';
2073                 $of_filter = ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
2074         }
2075
2076         if (my $t = $args{item_type}) {
2077                 $t = [$t] if (!ref($t));
2078                 @types = @$t;
2079
2080                 $t_filter  = ' AND rd.item_type  IN ('.join(',',map{'?'}@types).')';
2081                 $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
2082         }
2083
2084         if (my $v = $args{vr_format}) {
2085                 $v = [$v] if (!ref($v));
2086                 @vformats = @$v;
2087
2088                 $v_filter  = ' AND rd.vr_format  IN ('.join(',',map{'?'}@vformats).')';
2089                 $ov_filter = ' AND ord.vr_format IN ('.join(',',map{'?'}@vformats).')';
2090         }
2091
2092         # XXX legacy format and item type support
2093         if ($args{format}) {
2094                 my ($t, $f) = split '-', $args{format};
2095                 @types = split '', $t;
2096                 @forms = split '', $f;
2097                 if (@types) {
2098                         $t_filter  = ' AND rd.item_type  IN ('.join(',',map{'?'}@types).')';
2099                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
2100                 }
2101
2102                 if (@forms) {
2103                         $f_filter  .= ' AND rd.item_form  IN ('.join(',',map{'?'}@forms).')';
2104                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
2105                 }
2106         }
2107
2108
2109         my $descendants = defined($ou_type) ?
2110                                 "actor.org_unit_descendants($ou, $ou_type)" :
2111                                 "actor.org_unit_descendants($ou)";
2112
2113         my $search_table_list = '';
2114         my $fts_list = '';
2115         my $join_table_list = '';
2116         my @rank_list;
2117
2118         my $field_table = config::metabib_field->table;
2119
2120         my @bonus_lists;
2121         my @bonus_values;
2122         my $prev_search_group;
2123         my $curr_search_group;
2124         my $search_class;
2125         my $search_field;
2126         my $metabib_field;
2127         for my $search_group (sort keys %{$args{searches}}) {
2128                 (my $search_group_name = $search_group) =~ s/\|/_/gso;
2129                 ($search_class,$search_field) = split /\|/, $search_group;
2130                 $log->debug("Searching class [$search_class] and field [$search_field]",DEBUG);
2131
2132                 if ($search_field) {
2133                         unless ( $metabib_field = config::metabib_field->search( field_class => $search_class, name => $search_field )->next ) {
2134                                 $log->warn("Requested class [$search_class] or field [$search_field] does not exist!");
2135                                 return undef;
2136                         }
2137                 }
2138
2139                 $prev_search_group = $curr_search_group if ($curr_search_group);
2140
2141                 $curr_search_group = $search_group_name;
2142
2143                 my $class = $_cdbi->{$search_class};
2144                 my $search_table = $class->table;
2145
2146                 my ($index_col) = $class->columns('FTS');
2147                 $index_col ||= 'value';
2148
2149
2150                 my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $args{searches}{$search_group}{term}, $search_group_name.'.value', "$search_group_name.$index_col");
2151
2152                 my $fts_where = $fts->sql_where_clause;
2153                 my @fts_ranks = $fts->fts_rank;
2154
2155                 my $SQLstring = join('%',map { lc($_) } $fts->words) .'%';
2156                 my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
2157                 my $first_word = lc(($fts->words)[0]).'%';
2158
2159                 $_.=" * (SELECT weight FROM $field_table WHERE $search_group_name.field = id)" for (@fts_ranks);
2160                 my $rank = join('  + ', @fts_ranks);
2161
2162                 my %bonus = ();
2163                 $bonus{'subject'} = [];
2164                 $bonus{'author'}  = [ { "CASE WHEN $search_group_name.value ILIKE ? THEN 1.5 ELSE 1 END" => $first_word } ];
2165
2166                 $bonus{'keyword'} = [ { "CASE WHEN $search_group_name.value ILIKE ? THEN 10 ELSE 1 END" => $SQLstring } ];
2167
2168                 $bonus{'series'} = [
2169                         { "CASE WHEN $search_group_name.value ILIKE ? THEN 1.5 ELSE 1 END" => $first_word },
2170                         { "CASE WHEN $search_group_name.value ~ ? THEN 20 ELSE 1 END" => $REstring },
2171                 ];
2172
2173                 $bonus{'title'} = [ @{ $bonus{'series'} }, @{ $bonus{'keyword'} } ];
2174
2175                 if ($pref_lang) {
2176                         push @{ $bonus{'title'}   }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2177                         push @{ $bonus{'author'}  }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2178                         push @{ $bonus{'subject'} }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2179                         push @{ $bonus{'keyword'} }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2180                         push @{ $bonus{'series'}  }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2181                 }
2182
2183                 my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$search_class} };
2184                 $bonus_list ||= '1';
2185
2186                 push @bonus_lists, $bonus_list;
2187                 push @bonus_values, map { values %$_ } @{ $bonus{$search_class} };
2188
2189                 #---------------------
2190
2191                 $search_table_list .= "$search_table $search_group_name, ";
2192                 push @rank_list,$rank;
2193                 $fts_list .= " AND $fts_where AND b.id = $search_group_name.source";
2194
2195                 if ($metabib_field) {
2196                         $fts_list .= " AND $curr_search_group.field = " . $metabib_field->id;
2197                         $metabib_field = undef;
2198                 }
2199
2200                 if ($prev_search_group) {
2201                         $join_table_list .= " AND $prev_search_group.source = $curr_search_group.source";
2202                 }
2203         }
2204
2205         my $metabib_record_descriptor = metabib::record_descriptor->table;
2206         my $metabib_full_rec = metabib::full_rec->table;
2207         my $metabib_metarecord = metabib::metarecord->table;
2208         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
2209         my $asset_call_number_table = asset::call_number->table;
2210         my $asset_copy_table = asset::copy->table;
2211         my $cs_table = config::copy_status->table;
2212         my $cl_table = asset::copy_location->table;
2213         my $br_table = biblio::record_entry->table;
2214         my $source_table = config::bib_source->table;
2215
2216
2217         my $bonuses = join (' * ', @bonus_lists);
2218         my $relevance = join (' + ', @rank_list);
2219         $relevance = "AVG( ($relevance) * ($bonuses) )";
2220
2221         my $string_default_sort = 'zzzz';
2222         $string_default_sort = 'AAAA' if ($sort_dir eq 'DESC');
2223
2224         my $number_default_sort = '9999';
2225         $number_default_sort = '0000' if ($sort_dir eq 'DESC');
2226
2227         my $rank = $relevance;
2228         if (lc($sort) eq 'pubdate') {
2229                 $rank = <<"             RANK";
2230                         ( FIRST ((
2231                                 SELECT  COALESCE(SUBSTRING(frp.value FROM E'\\\\d{4}'),'$number_default_sort')::INT
2232                                   FROM  $metabib_full_rec frp
2233                                   WHERE frp.record = b.id
2234                                         AND frp.tag = '260'
2235                                         AND frp.subfield = 'c'
2236                                   LIMIT 1
2237                         )) )
2238                 RANK
2239         } elsif (lc($sort) eq 'create_date') {
2240                 $rank = <<"             RANK";
2241                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = b.id)) )
2242                 RANK
2243         } elsif (lc($sort) eq 'edit_date') {
2244                 $rank = <<"             RANK";
2245                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = b.id)) )
2246                 RANK
2247         } elsif (lc($sort) eq 'title') {
2248                 $rank = <<"             RANK";
2249                         ( FIRST ((
2250                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM E'\\\\d+'),'0')::INT + 1 )),'$string_default_sort')
2251                                   FROM  $metabib_full_rec frt
2252                                   WHERE frt.record = b.id
2253                                         AND frt.tag = '245'
2254                                         AND frt.subfield = 'a'
2255                                   LIMIT 1
2256                         )) )
2257                 RANK
2258         } elsif (lc($sort) eq 'author') {
2259                 $rank = <<"             RANK";
2260                         ( FIRST((
2261                                 SELECT  COALESCE(LTRIM(fra.value),'$string_default_sort')
2262                                   FROM  $metabib_full_rec fra
2263                                   WHERE fra.record = b.id
2264                                         AND fra.tag LIKE '1%'
2265                                         AND fra.subfield = 'a'
2266                                   ORDER BY fra.tag::text::int
2267                                   LIMIT 1
2268                         )) )
2269                 RANK
2270         } else {
2271                 push @bonus_values, @bonus_values;
2272                 $sort = undef;
2273         }
2274
2275
2276         my $select = <<"        SQL";
2277                 SELECT  b.id,
2278                         $relevance AS rel,
2279                         $rank AS rank,
2280                         b.source
2281                 FROM    $search_table_list
2282                         $metabib_record_descriptor rd,
2283                         $source_table src,
2284                         $br_table b
2285                 WHERE   rd.record = b.id
2286                         AND b.active IS TRUE
2287                         AND b.deleted IS FALSE
2288                         $fts_list
2289                         $join_table_list
2290                         $t_filter
2291                         $f_filter
2292                         $v_filter
2293                         $a_filter
2294                         $l_filter
2295                         $lf_filter
2296                 GROUP BY b.id, b.source
2297                 ORDER BY 3 $sort_dir
2298                 LIMIT $visibility_limit
2299         SQL
2300
2301         if ($self->api_name !~ /staff/o) {
2302                 $select = <<"           SQL";
2303
2304                         SELECT  s.*
2305                           FROM  ($select) s
2306                                 LEFT OUTER JOIN $source_table src ON (s.source = src.id)
2307                           WHERE EXISTS (
2308                                 SELECT  1
2309                                   FROM  $asset_call_number_table cn,
2310                                         $asset_copy_table cp,
2311                                         $cs_table cs,
2312                                         $cl_table cl,
2313                                         $descendants d
2314                                   WHERE cn.record = s.id
2315                                         AND cp.status = cs.id
2316                                         AND cp.location = cl.id
2317                                         AND cp.call_number = cn.id
2318                                         AND cp.opac_visible IS TRUE
2319                                         AND cs.opac_visible IS TRUE
2320                                         AND cl.opac_visible IS TRUE
2321                                         AND d.opac_visible IS TRUE
2322                                         AND cp.deleted IS FALSE
2323                                         AND cn.deleted IS FALSE
2324                                         AND cp.circ_lib = d.id
2325                                         $avail_filter
2326                                   LIMIT 1
2327                                 )
2328                                 OR src.transcendant IS TRUE
2329                           ORDER BY 3 $sort_dir
2330                 SQL
2331         } else {
2332                 $select = <<"           SQL";
2333
2334                         SELECT  s.*
2335                           FROM  ($select) s
2336                                 LEFT OUTER JOIN $source_table src ON (s.source = src.id)
2337                           WHERE EXISTS (
2338                                 SELECT  1
2339                                   FROM  $asset_call_number_table cn,
2340                                         $asset_copy_table cp,
2341                                         $descendants d
2342                                   WHERE cn.record = s.id
2343                                         AND cp.call_number = cn.id
2344                                         AND cn.deleted IS FALSE
2345                                         AND cp.circ_lib = d.id
2346                                         AND cp.deleted IS FALSE
2347                                         $avail_filter
2348                                   LIMIT 1
2349                                 )
2350                                 OR NOT EXISTS (
2351                                 SELECT  1
2352                                   FROM  $asset_call_number_table cn
2353                                   WHERE cn.record = s.id
2354                                   LIMIT 1
2355                                 )
2356                                 OR src.transcendant IS TRUE
2357                           ORDER BY 3 $sort_dir
2358                 SQL
2359         }
2360
2361
2362         $log->debug("Field Search SQL :: [$select]",DEBUG);
2363
2364         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
2365                         $select, {},
2366                         @bonus_values, @types, @forms, @vformats, @aud, @lang, @lit_form
2367         );
2368
2369         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
2370
2371         my $count = scalar(@$recs);
2372         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
2373                 next unless ($$rec[0]);
2374                 my ($mrid,$rank) = @$rec;
2375                 $client->respond( [$mrid, sprintf('%0.3f',$rank), $count] );
2376         }
2377         return undef;
2378 }
2379
2380 __PACKAGE__->register_method(
2381         api_name        => "open-ils.storage.biblio.multiclass.search_fts.record",
2382         method          => 'biblio_search_multi_class_fts',
2383         api_level       => 1,
2384         stream          => 1,
2385         cachable        => 1,
2386 );
2387 __PACKAGE__->register_method(
2388         api_name        => "open-ils.storage.biblio.multiclass.search_fts.record.staff",
2389         method          => 'biblio_search_multi_class_fts',
2390         api_level       => 1,
2391         stream          => 1,
2392         cachable        => 1,
2393 );
2394 __PACKAGE__->register_method(
2395         api_name        => "open-ils.storage.biblio.multiclass.search_fts",
2396         method          => 'biblio_search_multi_class_fts',
2397         api_level       => 1,
2398         stream          => 1,
2399         cachable        => 1,
2400 );
2401 __PACKAGE__->register_method(
2402         api_name        => "open-ils.storage.biblio.multiclass.search_fts.staff",
2403         method          => 'biblio_search_multi_class_fts',
2404         api_level       => 1,
2405         stream          => 1,
2406         cachable        => 1,
2407 );
2408
2409
2410 my %locale_map;
2411 my $default_preferred_language;
2412 my $default_preferred_language_weight;
2413
2414 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
2415 sub staged_fts {
2416     my $self   = shift;
2417     my $client = shift;
2418     my %args   = @_;
2419
2420     if (!$locale_map{COMPLETE}) {
2421
2422         my @locales = config::i18n_locale->search_where({ code => { '<>' => '' } });
2423         for my $locale ( @locales ) {
2424             $locale_map{lc($locale->code)} = $locale->marc_code;
2425         }
2426         $locale_map{COMPLETE} = 1;
2427
2428     }
2429
2430     my $config = OpenSRF::Utils::SettingsClient->new();
2431
2432     if (!$default_preferred_language) {
2433
2434         $default_preferred_language = $config->config_value(
2435                 apps => 'open-ils.search' => app_settings => 'default_preferred_language'
2436         ) || $config->config_value(
2437                 apps => 'open-ils.storage' => app_settings => 'default_preferred_language'
2438         );
2439
2440     }
2441
2442     if (!$default_preferred_language_weight) {
2443
2444         $default_preferred_language_weight = $config->config_value(
2445                 apps => 'open-ils.storage' => app_settings => 'default_preferred_language_weight'
2446         ) || $config->config_value(
2447                 apps => 'open-ils.storage' => app_settings => 'default_preferred_language_weight'
2448         );
2449     }
2450
2451     # inclusion, exclusion, delete_adjusted_inclusion, delete_adjusted_exclusion
2452     my $estimation_strategy = $args{estimation_strategy} || 'inclusion';
2453
2454     my $ou     = $args{org_unit};
2455     my $limit  = $args{limit}  || 10;
2456     my $offset = $args{offset} ||  0;
2457
2458         if (!$ou) {
2459                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
2460         }
2461
2462         if (! scalar( keys %{$args{searches}} )) {
2463                 die "No search arguments were passed to ".$self->api_name;
2464         }
2465
2466         my (@between,@statuses,@locations,@types,@forms,@lang,@aud,@lit_form,@vformats,@bib_level);
2467
2468     if (!defined($args{preferred_language})) {
2469                 my $ses_locale = $client->session ? $client->session->session_locale : $default_preferred_language;
2470         $args{preferred_language} =
2471             $locale_map{ lc($ses_locale) } || 'eng';
2472     }
2473
2474     if (!defined($args{preferred_language_weight})) {
2475         $args{preferred_language_weight} = $default_preferred_language_weight || 2;
2476     }
2477
2478         if ($args{available}) {
2479                 @statuses = (0,7,12);
2480         }
2481
2482         if (my $s = $args{locations}) {
2483                 $s = [$s] if (!ref($s));
2484                 @locations = @$s;
2485         }
2486
2487         if (my $b = $args{between}) {
2488                 if (ref($b) && @$b == 2) {
2489                     @between = @$b;
2490         }
2491         }
2492
2493         if (my $s = $args{statuses}) {
2494                 $s = [$s] if (!ref($s));
2495                 @statuses = @$s;
2496         }
2497
2498         if (my $a = $args{audience}) {
2499                 $a = [$a] if (!ref($a));
2500                 @aud = @$a;
2501         }
2502
2503         if (my $l = $args{language}) {
2504                 $l = [$l] if (!ref($l));
2505                 @lang = @$l;
2506         }
2507
2508         if (my $f = $args{lit_form}) {
2509                 $f = [$f] if (!ref($f));
2510                 @lit_form = @$f;
2511         }
2512
2513         if (my $f = $args{item_form}) {
2514                 $f = [$f] if (!ref($f));
2515                 @forms = @$f;
2516         }
2517
2518         if (my $t = $args{item_type}) {
2519                 $t = [$t] if (!ref($t));
2520                 @types = @$t;
2521         }
2522
2523         if (my $b = $args{bib_level}) {
2524                 $b = [$b] if (!ref($b));
2525                 @bib_level = @$b;
2526         }
2527
2528         if (my $v = $args{vr_format}) {
2529                 $v = [$v] if (!ref($v));
2530                 @vformats = @$v;
2531         }
2532
2533         # XXX legacy format and item type support
2534         if ($args{format}) {
2535                 my ($t, $f) = split '-', $args{format};
2536                 @types = split '', $t;
2537                 @forms = split '', $f;
2538         }
2539
2540     my %stored_proc_search_args;
2541         for my $search_group (sort keys %{$args{searches}}) {
2542                 (my $search_group_name = $search_group) =~ s/\|/_/gso;
2543                 my ($search_class,$search_field) = split /\|/, $search_group;
2544                 $log->debug("Searching class [$search_class] and field [$search_field]",DEBUG);
2545
2546                 if ($search_field) {
2547                         unless ( config::metabib_field->search( field_class => $search_class, name => $search_field )->next ) {
2548                                 $log->warn("Requested class [$search_class] or field [$search_field] does not exist!");
2549                                 return undef;
2550                         }
2551                 }
2552
2553                 my $class = $_cdbi->{$search_class};
2554                 my $search_table = $class->table;
2555
2556                 my ($index_col) = $class->columns('FTS');
2557                 $index_col ||= 'value';
2558
2559
2560                 my $fts = OpenILS::Application::Storage::FTS->compile(
2561             $search_class => $args{searches}{$search_group}{term},
2562             $search_group_name.'.value',
2563             "$search_group_name.$index_col"
2564         );
2565                 $fts->sql_where_clause; # this builds the ranks for us
2566
2567                 my @fts_ranks   = $fts->fts_rank;
2568                 my @fts_queries = $fts->fts_query;
2569                 my @phrases = map { lc($_) } $fts->phrases;
2570                 my @words   = map { lc($_) } $fts->words;
2571
2572         $stored_proc_search_args{$search_group} = {
2573             fts_rank    => \@fts_ranks,
2574             fts_query   => \@fts_queries,
2575             phrase      => \@phrases,
2576             word        => \@words,
2577         };
2578
2579         }
2580
2581         my $param_search_ou = $ou;
2582         my $param_depth = $args{depth}; $param_depth = 'NULL' unless (defined($param_depth) and length($param_depth) > 0 );
2583         my $param_searches = OpenSRF::Utils::JSON->perl2JSON( \%stored_proc_search_args ); $param_searches =~ s/\$//go; $param_searches = '$$'.$param_searches.'$$';
2584         my $param_statuses  = '$${' . join(',', map { s/\$//go; "\"$_\"" } @statuses ) . '}$$';
2585         my $param_locations = '$${' . join(',', map { s/\$//go; "\"$_\"" } @locations) . '}$$';
2586         my $param_audience  = '$${' . join(',', map { s/\$//go; "\"$_\"" } @aud      ) . '}$$';
2587         my $param_language  = '$${' . join(',', map { s/\$//go; "\"$_\"" } @lang     ) . '}$$';
2588         my $param_lit_form  = '$${' . join(',', map { s/\$//go; "\"$_\"" } @lit_form ) . '}$$';
2589         my $param_types     = '$${' . join(',', map { s/\$//go; "\"$_\"" } @types    ) . '}$$';
2590         my $param_forms     = '$${' . join(',', map { s/\$//go; "\"$_\"" } @forms    ) . '}$$';
2591         my $param_vformats  = '$${' . join(',', map { s/\$//go; "\"$_\"" } @vformats ) . '}$$';
2592     my $param_bib_level = '$${' . join(',', map { s/\$//go; "\"$_\"" } @bib_level) . '}$$';
2593         my $param_before = $args{before}; $param_before = 'NULL' unless (defined($param_before) and length($param_before) > 0 );
2594         my $param_after  = $args{after} ; $param_after  = 'NULL' unless (defined($param_after ) and length($param_after ) > 0 );
2595         my $param_during = $args{during}; $param_during = 'NULL' unless (defined($param_during) and length($param_during) > 0 );
2596     my $param_between = '$${"' . join('","', map { int($_) } @between) . '"}$$';
2597         my $param_pref_lang = $args{preferred_language}; $param_pref_lang =~ s/\$//go; $param_pref_lang = '$$'.$param_pref_lang.'$$';
2598         my $param_pref_lang_multiplier = $args{preferred_language_weight}; $param_pref_lang_multiplier ||= 'NULL';
2599         my $param_sort = $args{'sort'}; $param_sort =~ s/\$//go; $param_sort = '$$'.$param_sort.'$$';
2600         my $param_sort_desc = defined($args{sort_dir}) && $args{sort_dir} =~ /^d/io ? "'t'" : "'f'";
2601         my $metarecord = $self->api_name =~ /metabib/o ? "'t'" : "'f'";
2602         my $staff = $self->api_name =~ /staff/o ? "'t'" : "'f'";
2603     my $param_rel_limit = $args{core_limit};  $param_rel_limit ||= 'NULL';
2604     my $param_chk_limit = $args{check_limit}; $param_chk_limit ||= 'NULL';
2605     my $param_skip_chk  = $args{skip_check};  $param_skip_chk  ||= 'NULL';
2606
2607         my $sth = metabib::metarecord_source_map->db_Main->prepare(<<"    SQL");
2608         SELECT  *
2609           FROM  search.staged_fts(
2610                     $param_search_ou\:\:INT,
2611                     $param_depth\:\:INT,
2612                     $param_searches\:\:TEXT,
2613                     $param_statuses\:\:INT[],
2614                     $param_locations\:\:INT[],
2615                     $param_audience\:\:TEXT[],
2616                     $param_language\:\:TEXT[],
2617                     $param_lit_form\:\:TEXT[],
2618                     $param_types\:\:TEXT[],
2619                     $param_forms\:\:TEXT[],
2620                     $param_vformats\:\:TEXT[],
2621                     $param_bib_level\:\:TEXT[],
2622                     $param_before\:\:TEXT,
2623                     $param_after\:\:TEXT,
2624                     $param_during\:\:TEXT,
2625                     $param_between\:\:TEXT[],
2626                     $param_pref_lang\:\:TEXT,
2627                     $param_pref_lang_multiplier\:\:REAL,
2628                     $param_sort\:\:TEXT,
2629                     $param_sort_desc\:\:BOOL,
2630                     $metarecord\:\:BOOL,
2631                     $staff\:\:BOOL,
2632                     $param_rel_limit\:\:INT,
2633                     $param_chk_limit\:\:INT,
2634                     $param_skip_chk\:\:INT
2635                 );
2636     SQL
2637
2638     $sth->execute;
2639
2640     my $recs = $sth->fetchall_arrayref({});
2641     my $summary_row = pop @$recs;
2642
2643     my $total    = $$summary_row{total};
2644     my $checked  = $$summary_row{checked};
2645     my $visible  = $$summary_row{visible};
2646     my $deleted  = $$summary_row{deleted};
2647     my $excluded = $$summary_row{excluded};
2648
2649     my $estimate = $visible;
2650     if ( $total > $checked && $checked ) {
2651
2652         $$summary_row{hit_estimate} = FTS_paging_estimate($self, $client, $checked, $visible, $excluded, $deleted, $total);
2653         $estimate = $$summary_row{estimated_hit_count} = $$summary_row{hit_estimate}{$estimation_strategy};
2654
2655     }
2656
2657     delete $$summary_row{id};
2658     delete $$summary_row{rel};
2659     delete $$summary_row{record};
2660
2661     $client->respond( $summary_row );
2662
2663         $log->debug("Search yielded ".scalar(@$recs)." checked, visible results with an approximate visible total of $estimate.",DEBUG);
2664
2665         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
2666         delete $$rec{checked};
2667         delete $$rec{visible};
2668         delete $$rec{excluded};
2669         delete $$rec{deleted};
2670         delete $$rec{total};
2671         $$rec{rel} = sprintf('%0.3f',$$rec{rel});
2672
2673                 $client->respond( $rec );
2674         }
2675         return undef;
2676 }
2677 __PACKAGE__->register_method(
2678         api_name        => "open-ils.storage.biblio.multiclass.staged.search_fts",
2679         method          => 'staged_fts',
2680         api_level       => 0,
2681         stream          => 1,
2682         cachable        => 1,
2683 );
2684 __PACKAGE__->register_method(
2685         api_name        => "open-ils.storage.biblio.multiclass.staged.search_fts.staff",
2686         method          => 'staged_fts',
2687         api_level       => 0,
2688         stream          => 1,
2689         cachable        => 1,
2690 );
2691 __PACKAGE__->register_method(
2692         api_name        => "open-ils.storage.metabib.multiclass.staged.search_fts",
2693         method          => 'staged_fts',
2694         api_level       => 0,
2695         stream          => 1,
2696         cachable        => 1,
2697 );
2698 __PACKAGE__->register_method(
2699         api_name        => "open-ils.storage.metabib.multiclass.staged.search_fts.staff",
2700         method          => 'staged_fts',
2701         api_level       => 0,
2702         stream          => 1,
2703         cachable        => 1,
2704 );
2705
2706 sub FTS_paging_estimate {
2707     my $self   = shift;
2708     my $client = shift;
2709
2710     my $checked  = shift;
2711     my $visible  = shift;
2712     my $excluded = shift;
2713     my $deleted  = shift;
2714     my $total    = shift;
2715
2716     my $deleted_ratio = $deleted / $checked;
2717     my $delete_adjusted_total = $total - ( $total * $deleted_ratio );
2718
2719     my $exclusion_ratio = $excluded / $checked;
2720     my $delete_adjusted_exclusion_ratio = $checked - $deleted ? $excluded / ($checked - $deleted) : 1;
2721
2722     my $inclusion_ratio = $visible / $checked;
2723     my $delete_adjusted_inclusion_ratio = $checked - $deleted ? $visible / ($checked - $deleted) : 0;
2724
2725     return {
2726         exclusion                   => int($delete_adjusted_total - ( $delete_adjusted_total * $exclusion_ratio )),
2727         inclusion                   => int($delete_adjusted_total * $inclusion_ratio),
2728         delete_adjusted_exclusion   => int($delete_adjusted_total - ( $delete_adjusted_total * $delete_adjusted_exclusion_ratio )),
2729         delete_adjusted_inclusion   => int($delete_adjusted_total * $delete_adjusted_inclusion_ratio)
2730     };
2731 }
2732 __PACKAGE__->register_method(
2733         api_name        => "open-ils.storage.fts_paging_estimate",
2734         method          => 'FTS_paging_estimate',
2735     argc        => 5,
2736     strict      => 1,
2737         api_level       => 1,
2738     signature   => {
2739         'return'=> q#
2740             Hash of estimation values based on four variant estimation strategies:
2741                 exclusion -- Estimate based on the ratio of excluded records on the current superpage;
2742                 inclusion -- Estimate based on the ratio of visible records on the current superpage;
2743                 delete_adjusted_exclusion -- Same as exclusion strategy, but the ratio is adjusted by deleted count;
2744                 delete_adjusted_inclusion -- Same as inclusion strategy, but the ratio is adjusted by deleted count;
2745         #,
2746         desc    => q#
2747             Helper method used to determin the approximate number of
2748             hits for a search that spans multiple superpages.  For
2749             sparse superpages, the inclusion estimate will likely be the
2750             best estimate.  The exclusion strategy is the original, but
2751             inclusion is the default.
2752         #,
2753         params  => [
2754             {   name    => 'checked',
2755                 desc    => 'Number of records check -- nominally the size of a superpage, or a remaining amount from the last superpage.',
2756                 type    => 'number'
2757             },
2758             {   name    => 'visible',
2759                 desc    => 'Number of records visible to the search location on the current superpage.',
2760                 type    => 'number'
2761             },
2762             {   name    => 'excluded',
2763                 desc    => 'Number of records excluded from the search location on the current superpage.',
2764                 type    => 'number'
2765             },
2766             {   name    => 'deleted',
2767                 desc    => 'Number of deleted records on the current superpage.',
2768                 type    => 'number'
2769             },
2770             {   name    => 'total',
2771                 desc    => 'Total number of records up to check_limit (superpage_size * max_superpages).',
2772                 type    => 'number'
2773             }
2774         ]
2775     }
2776 );
2777
2778
2779 sub xref_count {
2780     my $self   = shift;
2781     my $client = shift;
2782     my $args   = shift;
2783
2784     my $term  = $$args{term};
2785     my $limit = $$args{max} || 1;
2786     my $min   = $$args{min} || 1;
2787         my @classes = @{$$args{class}};
2788
2789         $limit = $min if ($min > $limit);
2790
2791         if (!@classes) {
2792                 @classes = ( qw/ title author subject series keyword / );
2793         }
2794
2795         my %matches;
2796         my $bre_table = biblio::record_entry->table;
2797         my $cn_table  = asset::call_number->table;
2798         my $cp_table  = asset::copy->table;
2799
2800         for my $search_class ( @classes ) {
2801
2802                 my $class = $_cdbi->{$search_class};
2803                 my $search_table = $class->table;
2804
2805                 my ($index_col) = $class->columns('FTS');
2806                 $index_col ||= 'value';
2807
2808
2809                 my $where = OpenILS::Application::Storage::FTS
2810                         ->compile($search_class => $term, $search_class.'.value', "$search_class.$index_col")
2811                         ->sql_where_clause;
2812
2813                 my $SQL = <<"           SQL";
2814                         SELECT  COUNT(DISTINCT X.source)
2815                           FROM  (SELECT $search_class.source
2816                                   FROM  $search_table $search_class
2817                                         JOIN $bre_table b ON (b.id = $search_class.source)
2818                                   WHERE $where
2819                                         AND NOT b.deleted
2820                                         AND b.active
2821                                   LIMIT $limit) X
2822                           HAVING COUNT(DISTINCT X.source) >= $min;
2823                 SQL
2824
2825                 my $res = $class->db_Main->selectrow_arrayref( $SQL );
2826                 $matches{$search_class} = $res ? $res->[0] : 0;
2827         }
2828
2829         return \%matches;
2830 }
2831 __PACKAGE__->register_method(
2832     api_name  => "open-ils.storage.search.xref",
2833     method    => 'xref_count',
2834     api_level => 1,
2835 );
2836
2837 # Takes an abstract query object and recursively turns it back into a string
2838 # for QueryParser.
2839 sub abstract_query2str {
2840     my ($self, $conn, $query) = @_;
2841
2842     return QueryParser::Canonicalize::abstract_query2str_impl($query, 0);
2843 }
2844
2845 __PACKAGE__->register_method(
2846         api_name        => "open-ils.storage.query_parser.abstract_query.canonicalize",
2847         method          => "abstract_query2str",
2848         api_level       => 1,
2849     signature   => {
2850         params  => [
2851             {desc => q/
2852 Abstract query parser object, with complete config data. For example input,
2853 see the 'abstract_query' part of the output of an API call like
2854 open-ils.search.biblio.multiclass.query, when called with the return_abstract
2855 flag set to true./,
2856                 type => "object"}
2857         ],
2858         return => { type => "string", desc => "String representation of abstract query object" }
2859     }
2860 );
2861
2862 sub str2abstract_query {
2863     my ($self, $conn, $query, $qp_opts, $with_config) = @_;
2864
2865     my %use_opts = ( # reasonable defaults? should these even be hardcoded here?
2866         superpage => 1,
2867         superpage_size => 1000,
2868         core_limit => 25000,
2869         query => $query,
2870         (ref $opts eq 'HASH' ? %$opts : ())
2871     );
2872
2873     $with_config ||= 0;
2874
2875     # grab the query parser and initialize it
2876     my $parser = $OpenILS::Application::Storage::QParser;
2877     $parser->use;
2878
2879     _initialize_parser($parser) unless $parser->initialization_complete;
2880
2881     my $query = $parser->new(%use_opts)->parse;
2882
2883     return $query->parse_tree->to_abstract_query(with_config => $with_config);
2884 }
2885
2886 __PACKAGE__->register_method(
2887         api_name        => "open-ils.storage.query_parser.abstract_query.from_string",
2888         method          => "str2abstract_query",
2889         api_level       => 1,
2890     signature   => {
2891         params  => [
2892             {desc => "Query", type => "string"},
2893             {desc => q/Arguments for initializing QueryParser (optional)/,
2894                 type => "object"},
2895             {desc => q/Flag enabling inclusion of QP config in returned object (optional, default false)/,
2896                 type => "bool"}
2897         ],
2898         return => { type => "object", desc => "abstract representation of query parser query" }
2899     }
2900 );
2901
2902 sub query_parser_fts {
2903     my $self = shift;
2904     my $client = shift;
2905     my %args = @_;
2906
2907
2908     # grab the query parser and initialize it
2909     my $parser = $OpenILS::Application::Storage::QParser;
2910     $parser->use;
2911
2912     _initialize_parser($parser) unless $parser->initialization_complete;
2913
2914     # populate the locale/language map
2915     if (!$locale_map{COMPLETE}) {
2916
2917         my @locales = config::i18n_locale->search_where({ code => { '<>' => '' } });
2918         for my $locale ( @locales ) {
2919             $locale_map{lc($locale->code)} = $locale->marc_code;
2920         }
2921         $locale_map{COMPLETE} = 1;
2922
2923     }
2924
2925     # I hope we have a query!
2926         if (! $args{query} ) {
2927                 die "No query was passed to ".$self->api_name;
2928         }
2929
2930     my $default_CD_modifiers = OpenSRF::Utils::SettingsClient->new->config_value(
2931         apps => 'open-ils.search' => app_settings => 'default_CD_modifiers'
2932     );
2933
2934     # Protect against empty / missing default_CD_modifiers setting
2935     if ($default_CD_modifiers and !ref($default_CD_modifiers)) {
2936         $args{query} = "$default_CD_modifiers $args{query}";
2937     }
2938
2939     my $simple_plan = $args{_simple_plan};
2940     # remove bad chunks of the %args hash
2941     for my $bad ( grep { /^_/ } keys(%args)) {
2942         delete($args{$bad});
2943     }
2944
2945
2946     # parse the query and supply any query-level %arg-based defaults
2947     # we expect, and make use of, query, superpage, superpage_size, debug and core_limit args
2948     my $query = $parser->new( %args )->parse;
2949
2950     my $config = OpenSRF::Utils::SettingsClient->new();
2951
2952     # set the locale-based default preferred location
2953     if (!$query->parse_tree->find_filter('preferred_language')) {
2954         $parser->default_preferred_language( $args{preferred_language} );
2955
2956         if (!$parser->default_preferred_language) {
2957                     my $ses_locale = $client->session ? $client->session->session_locale : '';
2958             $parser->default_preferred_language( $locale_map{ lc($ses_locale) } );
2959         }
2960
2961         if (!$parser->default_preferred_language) { # still nothing...
2962             my $tmp_dpl = $config->config_value(
2963                 apps => 'open-ils.search' => app_settings => 'default_preferred_language'
2964             ) || $config->config_value(
2965                 apps => 'open-ils.storage' => app_settings => 'default_preferred_language'
2966             );
2967
2968             $parser->default_preferred_language( $tmp_dpl )
2969         }
2970     }
2971
2972
2973     # set the global default language multiplier
2974     if (!$query->parse_tree->find_filter('preferred_language_weight') and !$query->parse_tree->find_filter('preferred_language_multiplier')) {
2975         my $tmp_dplw;
2976
2977         if ($tmp_dplw = $args{preferred_language_weight} || $args{preferred_language_multiplier} ) {
2978             $parser->default_preferred_language_multiplier($tmp_dplw);
2979
2980         } else {
2981             $tmp_dplw = $config->config_value(
2982                 apps => 'open-ils.search' => app_settings => 'default_preferred_language_weight'
2983             ) || $config->config_value(
2984                 apps => 'open-ils.storage' => app_settings => 'default_preferred_language_weight'
2985             );
2986
2987             $parser->default_preferred_language_multiplier( $tmp_dplw );
2988         }
2989     }
2990
2991     # gather the site, if one is specified, defaulting to the in-query version
2992         my $ou = $args{org_unit};
2993         if (my ($filter) = $query->parse_tree->find_filter('site')) {
2994             $ou = $filter->args->[0] if (@{$filter->args});
2995     }
2996     $ou = actor::org_unit->search( { shortname => $ou } )->next->id if ($ou and $ou !~ /^(-)?\d+$/);
2997
2998     # gather lasso, as with $ou
2999         my $lasso = $args{lasso};
3000         if (my ($filter) = $query->parse_tree->find_filter('lasso')) {
3001             $lasso = $filter->args->[0] if (@{$filter->args});
3002     }
3003         $lasso = actor::org_lasso->search( { name => $lasso } )->next->id if ($lasso and $lasso !~ /^\d+$/);
3004     $lasso = -$lasso if ($lasso);
3005
3006
3007 #    # XXX once we have org_unit containers, we can make user-defined lassos .. WHEEE
3008 #    # gather user lasso, as with $ou and lasso
3009 #    my $mylasso = $args{my_lasso};
3010 #    if (my ($filter) = $query->parse_tree->find_filter('my_lasso')) {
3011 #            $mylasso = $filter->args->[0] if (@{$filter->args});
3012 #    }
3013 #    $mylasso = actor::org_unit->search( { name => $mylasso } )->next->id if ($mylasso and $mylasso !~ /^\d+$/);
3014
3015
3016     # if we have a lasso, go with that, otherwise ... ou
3017     $ou = $lasso if ($lasso);
3018
3019     # gather the preferred OU, if one is specified, as with $ou
3020     my $pref_ou = $args{pref_ou};
3021         $log->info("pref_ou = $pref_ou");
3022         if (my ($filter) = $query->parse_tree->find_filter('pref_ou')) {
3023             $pref_ou = $filter->args->[0] if (@{$filter->args});
3024     }
3025     $pref_ou = actor::org_unit->search( { shortname => $pref_ou } )->next->id if ($pref_ou and $pref_ou !~ /^(-)?\d+$/);
3026
3027     # get the default $ou if we have nothing
3028         $ou = actor::org_unit->search( { parent_ou => undef } )->next->id if (!$ou and !$lasso and !$mylasso);
3029
3030
3031     # XXX when user lassos are here, check to make sure we don't have one -- it'll be passed in the depth, with an ou of 0
3032     # gather the depth, if one is specified, defaulting to the in-query version
3033         my $depth = $args{depth};
3034         if (my ($filter) = $query->parse_tree->find_filter('depth')) {
3035             $depth = $filter->args->[0] if (@{$filter->args});
3036     }
3037         $depth = actor::org_unit->search_where( [{ name => $depth },{ opac_label => $depth }], {limit => 1} )->next->id if ($depth and $depth !~ /^\d+$/);
3038
3039
3040     # gather the limit or default to 10
3041         my $limit = $args{check_limit} || 'NULL';
3042         if (my ($filter) = $query->parse_tree->find_filter('limit')) {
3043             $limit = $filter->args->[0] if (@{$filter->args});
3044     }
3045         if (my ($filter) = $query->parse_tree->find_filter('check_limit')) {
3046             $limit = $filter->args->[0] if (@{$filter->args});
3047     }
3048
3049
3050     # gather the offset or default to 0
3051         my $offset = $args{skip_check} || $args{offset} || 0;
3052         if (my ($filter) = $query->parse_tree->find_filter('offset')) {
3053             $offset = $filter->args->[0] if (@{$filter->args});
3054     }
3055         if (my ($filter) = $query->parse_tree->find_filter('skip_check')) {
3056             $offset = $filter->args->[0] if (@{$filter->args});
3057     }
3058
3059
3060     # gather the estimation strategy or default to inclusion
3061     my $estimation_strategy = $args{estimation_strategy} || 'inclusion';
3062         if (my ($filter) = $query->parse_tree->find_filter('estimation_strategy')) {
3063             $estimation_strategy = $filter->args->[0] if (@{$filter->args});
3064     }
3065
3066
3067     # gather the estimation strategy or default to inclusion
3068     my $core_limit = $args{core_limit};
3069         if (my ($filter) = $query->parse_tree->find_filter('core_limit')) {
3070             $core_limit = $filter->args->[0] if (@{$filter->args});
3071     }
3072
3073
3074     # gather statuses, and then forget those if we have an #available modifier
3075     my @statuses;
3076     if (my ($filter) = $query->parse_tree->find_filter('statuses')) {
3077         @statuses = @{$filter->args} if (@{$filter->args});
3078     }
3079     @statuses = (0,7,12) if ($query->parse_tree->find_modifier('available'));
3080
3081
3082     # gather locations
3083     my @location;
3084     if (my ($filter) = $query->parse_tree->find_filter('locations')) {
3085         @location = @{$filter->args} if (@{$filter->args});
3086     }
3087
3088     # gather location_groups
3089     if (my ($filter) = $query->parse_tree->find_filter('location_groups')) {
3090         my @loc_groups = @{$filter->args} if (@{$filter->args});
3091
3092         # collect the mapped locations and add them to the locations() filter
3093         if (@loc_groups) {
3094
3095             my $cstore = OpenSRF::AppSession->create( 'open-ils.cstore' );
3096             my $maps = $cstore->request(
3097                 'open-ils.cstore.direct.asset.copy_location_group_map.search.atomic',
3098                 {lgroup => \@loc_groups})->gather(1);
3099
3100             push(@location, $_->location) for @$maps;
3101         }
3102     }
3103
3104
3105     my $param_check = $limit || $query->superpage_size || 'NULL';
3106     my $param_offset = $offset || 'NULL';
3107     my $param_limit = $core_limit || 'NULL';
3108
3109     my $sp = $query->superpage || 1;
3110     if ($sp > 1) {
3111         $param_offset = ($sp - 1) * $sp_size;
3112     }
3113
3114         my $param_search_ou = $ou;
3115         my $param_depth = $depth; $param_depth = 'NULL' unless (defined($depth) and length($depth) > 0 );
3116         my $param_core_query = "\$core_query_$$\$" . $query->parse_tree->toSQL . "\$core_query_$$\$";
3117         my $param_statuses = '$${' . join(',', map { s/\$//go; "\"$_\""} @statuses) . '}$$';
3118         my $param_locations = '$${' . join(',', map { s/\$//go; "\"$_\""} @location) . '}$$';
3119         my $staff = ($self->api_name =~ /staff/ or $query->parse_tree->find_modifier('staff')) ? "'t'" : "'f'";
3120         my $deleted_search = ($query->parse_tree->find_modifier('deleted')) ? "'t'" : "'f'";
3121         my $metarecord = ($self->api_name =~ /metabib/ or $query->parse_tree->find_modifier('metabib') or $query->parse_tree->find_modifier('metarecord')) ? "'t'" : "'f'";
3122         my $param_pref_ou = $pref_ou || 'NULL';
3123
3124         my $sth = metabib::metarecord_source_map->db_Main->prepare(<<"    SQL");
3125         SELECT  * -- bib search: $args{query}
3126           FROM  search.query_parser_fts(
3127                     $param_search_ou\:\:INT,
3128                     $param_depth\:\:INT,
3129                     $param_core_query\:\:TEXT,
3130                     $param_statuses\:\:INT[],
3131                     $param_locations\:\:INT[],
3132                     $param_offset\:\:INT,
3133                     $param_check\:\:INT,
3134                     $param_limit\:\:INT,
3135                     $metarecord\:\:BOOL,
3136                     $staff\:\:BOOL,
3137                     $deleted_search\:\:BOOL,
3138                     $param_pref_ou\:\:INT
3139                 );
3140     SQL
3141
3142     $sth->execute;
3143
3144     my $recs = $sth->fetchall_arrayref({});
3145     my $summary_row = pop @$recs;
3146
3147     my $total    = $$summary_row{total};
3148     my $checked  = $$summary_row{checked};
3149     my $visible  = $$summary_row{visible};
3150     my $deleted  = $$summary_row{deleted};
3151     my $excluded = $$summary_row{excluded};
3152
3153     my $estimate = $visible;
3154     if ( $total > $checked && $checked ) {
3155
3156         $$summary_row{hit_estimate} = FTS_paging_estimate($self, $client, $checked, $visible, $excluded, $deleted, $total);
3157         $estimate = $$summary_row{estimated_hit_count} = $$summary_row{hit_estimate}{$estimation_strategy};
3158
3159     }
3160
3161     delete $$summary_row{id};
3162     delete $$summary_row{rel};
3163     delete $$summary_row{record};
3164
3165     if (defined($simple_plan)) {
3166         $$summary_row{complex_query} = $simple_plan ? 0 : 1;
3167     } else {
3168         $$summary_row{complex_query} = $query->simple_plan ? 0 : 1;
3169     }
3170
3171     $client->respond( $summary_row );
3172
3173         $log->debug("Search yielded ".scalar(@$recs)." checked, visible results with an approximate visible total of $estimate.",DEBUG);
3174
3175         for my $rec (@$recs) {
3176         delete $$rec{checked};
3177         delete $$rec{visible};
3178         delete $$rec{excluded};
3179         delete $$rec{deleted};
3180         delete $$rec{total};
3181         $$rec{rel} = sprintf('%0.3f',$$rec{rel});
3182
3183                 $client->respond( $rec );
3184         }
3185         return undef;
3186 }
3187 __PACKAGE__->register_method(
3188         api_name        => "open-ils.storage.query_parser_search",
3189         method          => 'query_parser_fts',
3190         api_level       => 1,
3191         stream          => 1,
3192         cachable        => 1,
3193 );
3194
3195 sub query_parser_fts_wrapper {
3196         my $self = shift;
3197         my $client = shift;
3198         my %args = @_;
3199
3200         $log->debug("Entering compatability wrapper function for old-style staged search", DEBUG);
3201     # grab the query parser and initialize it
3202     my $parser = $OpenILS::Application::Storage::QParser;
3203     $parser->use;
3204
3205     _initialize_parser($parser) unless $parser->initialization_complete;
3206
3207         if (! scalar( keys %{$args{searches}} )) {
3208                 die "No search arguments were passed to ".$self->api_name;
3209         }
3210
3211         $log->debug("Constructing QueryParser query from staged search hash ...", DEBUG);
3212     my $base_query = '';
3213     for my $sclass ( keys %{$args{searches}} ) {
3214             $log->debug(" --> staged search key: $sclass --> term: $args{searches}{$sclass}{term}", DEBUG);
3215         $base_query .= " $sclass: $args{searches}{$sclass}{term}";
3216     }
3217
3218     my $query = $base_query;
3219     $log->debug("Full base query: $base_query", DEBUG);
3220
3221     $query = "$args{facets} $query" if  ($args{facets});
3222
3223     if (!$locale_map{COMPLETE}) {
3224
3225         my @locales = config::i18n_locale->search_where({ code => { '<>' => '' } });
3226         for my $locale ( @locales ) {
3227             $locale_map{lc($locale->code)} = $locale->marc_code;
3228         }
3229         $locale_map{COMPLETE} = 1;
3230
3231     }
3232
3233     my $base_plan = $parser->new( query => $base_query )->parse;
3234
3235     $query = "$query preferred_language($args{preferred_language})"
3236         if ($args{preferred_language} and !$base_plan->parse_tree->find_filter('preferred_language'));
3237     $query = "$query preferred_language_weight($args{preferred_language_weight})"
3238         if ($args{preferred_language_weight} and !$base_plan->parse_tree->find_filter('preferred_language_weight') and !$base_plan->parse_tree->find_filter('preferred_language_multiplier'));
3239
3240
3241     # we add these to the end of the query (last-wins) because in wrapper mode we want to retain the behaviour
3242     # of separately specified options taking precidenc -- IOW, the user should not be able to cause a change in,
3243     # say, superpage size by adjusting the query string.
3244     $query = "$query estimation_strategy($args{estimation_strategy})" if ($args{estimation_strategy});
3245     $query = "$query site($args{org_unit})" if ($args{org_unit});
3246     $query = "$query depth($args{depth})" if (defined($args{depth}));
3247     $query = "$query sort($args{sort})" if ($args{sort});
3248     $query = "$query limit($args{limit})" if ($args{limit});
3249     $query = "$query core_limit($args{core_limit})" if ($args{core_limit});
3250     $query = "$query skip_check($args{skip_check})" if ($args{skip_check});
3251     $query = "$query superpage($args{superpage})" if ($args{superpage});
3252     $query = "$query offset($args{offset})" if ($args{offset});
3253     $query = "$query #metarecord" if ($self->api_name =~ /metabib/);
3254     $query = "$query #available" if ($args{available});
3255     $query = "$query #descending" if ($args{sort_dir} && $args{sort_dir} =~ /^d/i);
3256     $query = "$query #staff" if ($self->api_name =~ /staff/);
3257     $query = "$query before($args{before})" if (defined($args{before}) and $args{before} =~ /^\d+$/);
3258     $query = "$query after($args{after})" if (defined($args{after}) and $args{after} =~ /^\d+$/);
3259     $query = "$query during($args{during})" if (defined($args{during}) and $args{during} =~ /^\d+$/);
3260     $query = "$query between($args{between}[0],$args{between}[1])"
3261         if ( ref($args{between}) and @{$args{between}} == 2 and $args{between}[0] =~ /^\d+$/ and $args{between}[1] =~ /^\d+$/ );
3262
3263
3264         my (@between,@statuses,@locations,@location_groups,@types,@forms,@lang,@aud,@lit_form,@vformats,@bib_level);
3265
3266         # XXX legacy format and item type support
3267         if ($args{format}) {
3268                 my ($t, $f) = split '-', $args{format};
3269                 $args{item_type} = [ split '', $t ];
3270                 $args{item_form} = [ split '', $f ];
3271         }
3272
3273     for my $filter ( qw/locations location_groups statuses between audience language lit_form item_form item_type bib_level vr_format/ ) {
3274         if (my $s = $args{$filter}) {
3275                 $s = [$s] if (!ref($s));
3276
3277                 my @filter_list = @$s;
3278
3279             next if ($filter eq 'between' and scalar(@filter_list) != 2);
3280             next if (@filter_list == 0);
3281
3282             my $filter_string = join ',', @filter_list;
3283             $query = "$query $filter($filter_string)";
3284             }
3285     }
3286
3287     $log->debug("Full QueryParser query: $query", DEBUG);
3288
3289     return query_parser_fts($self, $client, query => $query, _simple_plan => $base_plan->simple_plan );
3290 }
3291 __PACKAGE__->register_method(
3292         api_name        => "open-ils.storage.biblio.multiclass.staged.search_fts",
3293         method          => 'query_parser_fts_wrapper',
3294         api_level       => 1,
3295         stream          => 1,
3296         cachable        => 1,
3297 );
3298 __PACKAGE__->register_method(
3299         api_name        => "open-ils.storage.biblio.multiclass.staged.search_fts.staff",
3300         method          => 'query_parser_fts_wrapper',
3301         api_level       => 1,
3302         stream          => 1,
3303         cachable        => 1,
3304 );
3305 __PACKAGE__->register_method(
3306         api_name        => "open-ils.storage.metabib.multiclass.staged.search_fts",
3307         method          => 'query_parser_fts_wrapper',
3308         api_level       => 1,
3309         stream          => 1,
3310         cachable        => 1,
3311 );
3312 __PACKAGE__->register_method(
3313         api_name        => "open-ils.storage.metabib.multiclass.staged.search_fts.staff",
3314         method          => 'query_parser_fts_wrapper',
3315         api_level       => 1,
3316         stream          => 1,
3317         cachable        => 1,
3318 );
3319
3320
3321 1;
3322