Open-ILS/src/perlmods/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 Data::Dumper;
  10 use Digest::MD5 qw/md5_hex/;
  11
  12
  13 my $log = 'OpenSRF::Utils::Logger';
  14
  15 $VERSION = 1;
  16
  17 sub ordered_records_from_metarecord {
  18         my $self = shift;
  19         my $client = shift;
  20         my $mr = shift;
  21         my $formats = shift;
  22         my $org = shift || 1;
  23         my $depth = shift;
  24
  25         my (@types,@forms);
  26
  27         if ($formats) {
  28                 my ($t, $f) = split '-', $formats;
  29                 @types = split '', $t;
  30                 @forms = split '', $f;
  31         }
  32
  33         my $descendants =
  34                 defined($depth) ?
  35                         "actor.org_unit_descendants($org, $depth)" :
  36                         "actor.org_unit_descendants($org)" ;
  37
  38
  39         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
  40         $copies_visible = '' if ($self->api_name =~ /staff/o);
  41
  42         my $sm_table = metabib::metarecord_source_map->table;
  43         my $rd_table = metabib::record_descriptor->table;
  44         my $fr_table = metabib::full_rec->table;
  45         my $cn_table = asset::call_number->table;
  46         my $cl_table = asset::copy_location->table;
  47         my $cp_table = asset::copy->table;
  48         my $cs_table = config::copy_status->table;
  49         my $out_table = actor::org_unit_type->table;
  50         my $br_table = biblio::record_entry->table;
  51
  52         my $sql = <<"   SQL";
  53                 SELECT  record,
  54                         item_type,
  55                         item_form,
  56                         quality,
  57                         FIRST(COALESCE(LTRIM(SUBSTR( value, COALESCE(SUBSTRING(ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')) AS title
  58                 FROM    (
  59                         SELECT  rd.record,
  60                                 rd.item_type,
  61                                 rd.item_form,
  62                                 br.quality,
  63                                 fr.tag,
  64                                 fr.subfield,
  65                                 fr.value,
  66                                 fr.ind2
  67         SQL
  68
  69         if ($copies_visible) {
  70                 $sql .= <<"             SQL";
  71                           FROM  $cn_table cn,
  72                                 $sm_table sm,
  73                                 $br_table br,
  74                                 $fr_table fr,
  75                                 $rd_table rd
  76                           WHERE rd.record = sm.source
  77                                 AND fr.record = sm.source
  78                                 AND br.id = sm.source
  79                                 AND cn.record = sm.source
  80                                 AND sm.metarecord = ?
  81                                 AND EXISTS ((SELECT     1
  82                                                 FROM    $cp_table cp
  83                                                         JOIN $cs_table cs ON (cp.status = cs.id)
  84                                                         JOIN $cl_table cl ON (cp.location = cl.id)
  85                                                         JOIN $descendants d ON (cp.circ_lib = d.id)
  86                                                 WHERE   cn.id = cp.call_number
  87                                                         $copies_visible
  88                                                 LIMIT 1))
  89                 SQL
  90         } else {
  91                 $sql .= <<"             SQL";
  92                           FROM  $sm_table sm
  93                                 JOIN $br_table br ON (sm.source = br.id)
  94                                 JOIN $fr_table fr ON (fr.record = br.id)
  95                                 JOIN $rd_table rd ON (rd.record = br.id)
  96                           WHERE sm.metarecord = ?
  97                                 AND (   EXISTS (
  98                                                 SELECT  1
  99                                                   FROM  $cp_table cp,
 100                                                         $cn_table cn,
 101                                                         $descendants d
 102                                                   WHERE cn.record = br.id
 103                                                         AND cn.deleted = FALSE
 104                                                         AND cp.deleted = FALSE
 105                                                         AND cp.circ_lib = d.id
 106                                                         AND cn.id = cp.call_number
 107                                                   LIMIT 1
 108                                         ) OR NOT EXISTS (
 109                                                 SELECT  1
 110                                                   FROM  $cp_table cp,
 111                                                         $cn_table cn
 112                                                   WHERE cn.record = br.id
 113                                                         AND cn.deleted = FALSE
 114                                                         AND cp.deleted = FALSE
 115                                                         AND cn.id = cp.call_number
 116                                                   LIMIT 1
 117                                         )
 118                                 )
 119                 SQL
 120         }
 121
 122         if (@types) {
 123                 $sql .= '                               AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 124         }
 125
 126         if (@forms) {
 127                 $sql .= '                               AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 128         }
 129
 130
 131
 132         $sql .= <<"     SQL";
 133                           OFFSET 0
 134                         ) AS x
 135           WHERE tag = '245'
 136                 AND subfield = 'a'
 137           GROUP BY record, item_type, item_form, quality
 138           ORDER BY
 139                 CASE
 140                         WHEN item_type IS NULL -- default
 141                                 THEN 0
 142                         WHEN item_type = '' -- default
 143                                 THEN 0
 144                         WHEN item_type IN ('a','t') -- books
 145                                 THEN 1
 146                         WHEN item_type = 'g' -- movies
 147                                 THEN 2
 148                         WHEN item_type IN ('i','j') -- sound recordings
 149                                 THEN 3
 150                         WHEN item_type = 'm' -- software
 151                                 THEN 4
 152                         WHEN item_type = 'k' -- images
 153                                 THEN 5
 154                         WHEN item_type IN ('e','f') -- maps
 155                                 THEN 6
 156                         WHEN item_type IN ('o','p') -- mixed
 157                                 THEN 7
 158                         WHEN item_type IN ('c','d') -- music
 159                                 THEN 8
 160                         WHEN item_type = 'r' -- 3d
 161                                 THEN 9
 162                 END,
 163                 title ASC,
 164                 quality DESC
 165         SQL
 166
 167         my $ids = metabib::metarecord_source_map->db_Main->selectcol_arrayref($sql, {}, "$mr", @types, @forms);
 168         return $ids if ($self->api_name =~ /atomic$/o);
 169
 170         $client->respond( $_ ) for ( @$ids );
 171         return undef;
 172
 173 }
 174 __PACKAGE__->register_method(
 175         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records',
 176         method          => 'ordered_records_from_metarecord',
 177         api_level       => 1,
 178         cachable        => 1,
 179 );
 180 __PACKAGE__->register_method(
 181         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.staff',
 182         method          => 'ordered_records_from_metarecord',
 183         api_level       => 1,
 184         cachable        => 1,
 185 );
 186
 187 __PACKAGE__->register_method(
 188         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.atomic',
 189         method          => 'ordered_records_from_metarecord',
 190         api_level       => 1,
 191         cachable        => 1,
 192 );
 193 __PACKAGE__->register_method(
 194         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.staff.atomic',
 195         method          => 'ordered_records_from_metarecord',
 196         api_level       => 1,
 197         cachable        => 1,
 198 );
 199
 200 sub isxn_search {
 201         my $self = shift;
 202         my $client = shift;
 203         my $isxn = shift;
 204
 205         my $tag = ($self->api_name =~ /isbn/o) ? '020' : '022';
 206
 207         my $fr_table = metabib::full_rec->table;
 208
 209         my $sql = <<"   SQL";
 210                 SELECT  record
 211                   FROM  $fr_table
 212                   WHERE tag = ?
 213                         AND value LIKE ?
 214         SQL
 215
 216         my $list = metabib::metarecord_source_map->db_Main->selectcol_arrayref($sql, {}, $tag, "$isxn%");
 217         $client->respond($_) for (@$list);
 218         return undef;
 219 }
 220 __PACKAGE__->register_method(
 221         api_name        => 'open-ils.storage.id_list.biblio.record_entry.search.isbn',
 222         method          => 'isxn_search',
 223         api_level       => 1,
 224         stream          => 1,
 225 );
 226 __PACKAGE__->register_method(
 227         api_name        => 'open-ils.storage.id_list.biblio.record_entry.search.issn',
 228         method          => 'isxn_search',
 229         api_level       => 1,
 230         stream          => 1,
 231 );
 232
 233 sub metarecord_copy_count {
 234         my $self = shift;
 235         my $client = shift;
 236
 237         my %args = @_;
 238
 239         my $sm_table = metabib::metarecord_source_map->table;
 240         my $rd_table = metabib::record_descriptor->table;
 241         my $cn_table = asset::call_number->table;
 242         my $cp_table = asset::copy->table;
 243         my $cl_table = asset::copy_location->table;
 244         my $cs_table = config::copy_status->table;
 245         my $out_table = actor::org_unit_type->table;
 246         my $descendants = "actor.org_unit_descendants(u.id)";
 247         my $ancestors = "actor.org_unit_ancestors(?)";
 248
 249         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
 250         $copies_visible = '' if ($self->api_name =~ /staff/o);
 251
 252         my (@types,@forms);
 253         my ($t_filter, $f_filter) = ('','');
 254
 255         if ($args{format}) {
 256                 my ($t, $f) = split '-', $args{format};
 257                 @types = split '', $t;
 258                 @forms = split '', $f;
 259                 if (@types) {
 260                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 261                 }
 262
 263                 if (@forms) {
 264                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 265                 }
 266         }
 267
 268         my $sql = <<"   SQL";
 269                 SELECT  t.depth,
 270                         u.id AS org_unit,
 271                         sum(
 272                                 (SELECT count(cp.id)
 273                                   FROM  $sm_table r
 274                                         JOIN $cn_table cn ON (cn.record = r.source)
 275                                         JOIN $rd_table rd ON (cn.record = rd.record)
 276                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 277                                         JOIN $cs_table cs ON (cp.status = cs.id)
 278                                         JOIN $cl_table cl ON (cp.location = cl.id)
 279                                         JOIN $descendants a ON (cp.circ_lib = a.id)
 280                                   WHERE r.metarecord = ?
 281                                         AND cn.deleted IS FALSE
 282                                         AND cp.deleted IS FALSE
 283                                         $copies_visible
 284                                         $t_filter
 285                                         $f_filter
 286                                 )
 287                         ) AS count,
 288                         sum(
 289                                 (SELECT count(cp.id)
 290                                   FROM  $sm_table r
 291                                         JOIN $cn_table cn ON (cn.record = r.source)
 292                                         JOIN $rd_table rd ON (cn.record = rd.record)
 293                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 294                                         JOIN $cs_table cs ON (cp.status = cs.id)
 295                                         JOIN $cl_table cl ON (cp.location = cl.id)
 296                                         JOIN $descendants a ON (cp.circ_lib = a.id)
 297                                   WHERE r.metarecord = ?
 298                                         AND cp.status = 0
 299                                         AND cn.deleted IS FALSE
 300                                         AND cp.deleted IS FALSE
 301                                         $copies_visible
 302                                         $t_filter
 303                                         $f_filter
 304                                 )
 305                         ) AS available,
 306                         sum(
 307                                 (SELECT count(cp.id)
 308                                   FROM  $sm_table r
 309                                         JOIN $cn_table cn ON (cn.record = r.source)
 310                                         JOIN $rd_table rd ON (cn.record = rd.record)
 311                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 312                                         JOIN $cs_table cs ON (cp.status = cs.id)
 313                                         JOIN $cl_table cl ON (cp.location = cl.id)
 314                                   WHERE r.metarecord = ?
 315                                         AND cn.deleted IS FALSE
 316                                         AND cp.deleted IS FALSE
 317                                         AND cp.opac_visible IS TRUE
 318                                         AND cs.holdable IS TRUE
 319                                         AND cl.opac_visible IS TRUE
 320                                         $t_filter
 321                                         $f_filter
 322                                 )
 323                         ) AS unshadow
 324
 325                   FROM  $ancestors u
 326                         JOIN $out_table t ON (u.ou_type = t.id)
 327                   GROUP BY 1,2
 328         SQL
 329
 330         my $sth = metabib::metarecord_source_map->db_Main->prepare_cached($sql);
 331         $sth->execute(  ''.$args{metarecord},
 332                         @types,
 333                         @forms,
 334                         ''.$args{metarecord},
 335                         @types,
 336                         @forms,
 337                         ''.$args{metarecord},
 338                         @types,
 339                         @forms,
 340                         ''.$args{org_unit},
 341         );
 342
 343         while ( my $row = $sth->fetchrow_hashref ) {
 344                 $client->respond( $row );
 345         }
 346         return undef;
 347 }
 348 __PACKAGE__->register_method(
 349         api_name        => 'open-ils.storage.metabib.metarecord.copy_count',
 350         method          => 'metarecord_copy_count',
 351         api_level       => 1,
 352         stream          => 1,
 353         cachable        => 1,
 354 );
 355 __PACKAGE__->register_method(
 356         api_name        => 'open-ils.storage.metabib.metarecord.copy_count.staff',
 357         method          => 'metarecord_copy_count',
 358         api_level       => 1,
 359         stream          => 1,
 360         cachable        => 1,
 361 );
 362
 363 sub biblio_multi_search_full_rec {
 364         my $self = shift;
 365         my $client = shift;
 366
 367         my %args = @_;
 368         my $class_join = $args{class_join} || 'AND';
 369         my $limit = $args{limit} || 100;
 370         my $offset = $args{offset} || 0;
 371         my $sort = $args{'sort'};
 372         my $sort_dir = $args{sort_dir} || 'DESC';
 373
 374         my @binds;
 375         my @selects;
 376
 377         for my $arg (@{ $args{searches} }) {
 378                 my $term = $$arg{term};
 379                 my $limiters = $$arg{restrict};
 380
 381                 my ($index_col) = metabib::full_rec->columns('FTS');
 382                 $index_col ||= 'value';
 383                 my $search_table = metabib::full_rec->table;
 384
 385                 my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
 386
 387                 my $fts_where = $fts->sql_where_clause();
 388                 my @fts_ranks = $fts->fts_rank;
 389
 390                 my $rank = join(' + ', @fts_ranks);
 391
 392                 my @wheres;
 393                 for my $limit (@$limiters) {
 394                         push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
 395                         push @binds, $$limit{tag}, $$limit{subfield};
 396                         $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
 397                 }
 398                 my $where = join(' OR ', @wheres);
 399
 400                 push @selects, "SELECT id, record, $rank as sum FROM $search_table WHERE $where";
 401
 402         }
 403
 404         my $descendants = defined($args{depth}) ?
 405                                 "actor.org_unit_descendants($args{org_unit}, $args{depth})" :
 406                                 "actor.org_unit_descendants($args{org_unit})" ;
 407
 408
 409         my $metabib_record_descriptor = metabib::record_descriptor->table;
 410         my $metabib_full_rec = metabib::full_rec->table;
 411         my $asset_call_number_table = asset::call_number->table;
 412         my $asset_copy_table = asset::copy->table;
 413         my $cs_table = config::copy_status->table;
 414         my $cl_table = asset::copy_location->table;
 415         my $br_table = biblio::record_entry->table;
 416
 417         my $cj = 'HAVING COUNT(x.id) = ' . scalar(@selects) if ($class_join eq 'AND');
 418         my $search_table =
 419                 '(SELECT x.record, sum(x.sum) FROM (('.
 420                         join(') UNION ALL (', @selects).
 421                         ")) x GROUP BY 1 $cj ORDER BY 2 DESC )";
 422
 423         my $has_vols = 'AND cn.owning_lib = d.id';
 424         my $has_copies = 'AND cp.call_number = cn.id';
 425         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
 426
 427         if ($self->api_name =~ /staff/o) {
 428                 $copies_visible = '';
 429                 $has_copies = '' if ($ou_type == 0);
 430                 $has_vols = '' if ($ou_type == 0);
 431         }
 432
 433         my ($t_filter, $f_filter) = ('','');
 434         my ($a_filter, $l_filter, $lf_filter) = ('','','');
 435
 436         if (my $a = $args{audience}) {
 437                 $a = [$a] if (!ref($a));
 438                 my @aud = @$a;
 439
 440                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
 441                 push @binds, @aud;
 442         }
 443
 444         if (my $l = $args{language}) {
 445                 $l = [$l] if (!ref($l));
 446                 my @lang = @$l;
 447
 448                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
 449                 push @binds, @lang;
 450         }
 451
 452         if (my $f = $args{lit_form}) {
 453                 $f = [$f] if (!ref($f));
 454                 my @lit_form = @$f;
 455
 456                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
 457                 push @binds, @lit_form;
 458         }
 459
 460         if (my $f = $args{item_form}) {
 461                 $f = [$f] if (!ref($f));
 462                 my @forms = @$f;
 463
 464                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 465                 push @binds, @forms;
 466         }
 467
 468         if (my $t = $args{item_type}) {
 469                 $t = [$t] if (!ref($t));
 470                 my @types = @$t;
 471
 472                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 473                 push @binds, @types;
 474         }
 475
 476
 477         if ($args{format}) {
 478                 my ($t, $f) = split '-', $args{format};
 479                 my @types = split '', $t;
 480                 my @forms = split '', $f;
 481                 if (@types) {
 482                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 483                 }
 484
 485                 if (@forms) {
 486                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 487                 }
 488                 push @binds, @types, @forms;
 489         }
 490
 491         my $relevance = 'sum(f.sum)';
 492         $relevance = 1 if (!$copies_visible);
 493
 494         my $rank = $relevance;
 495         if (lc($sort) eq 'pubdate') {
 496                 $rank = <<"             RANK";
 497                         ( FIRST ((
 498                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d+'),'9999')::INT
 499                                   FROM  $metabib_full_rec frp
 500                                   WHERE frp.record = f.record
 501                                         AND frp.tag = '260'
 502                                         AND frp.subfield = 'c'
 503                                   LIMIT 1
 504                         )) )
 505                 RANK
 506         } elsif (lc($sort) eq 'create_date') {
 507                 $rank = <<"             RANK";
 508                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = f.record)) )
 509                 RANK
 510         } elsif (lc($sort) eq 'edit_date') {
 511                 $rank = <<"             RANK";
 512                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = f.record)) )
 513                 RANK
 514         } elsif (lc($sort) eq 'title') {
 515                 $rank = <<"             RANK";
 516                         ( FIRST ((
 517                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
 518                                   FROM  $metabib_full_rec frt
 519                                   WHERE frt.record = f.record
 520                                         AND frt.tag = '245'
 521                                         AND frt.subfield = 'a'
 522                                   LIMIT 1
 523                         )) )
 524                 RANK
 525         } elsif (lc($sort) eq 'author') {
 526                 $rank = <<"             RANK";
 527                         ( FIRST((
 528                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
 529                                   FROM  $metabib_full_rec fra
 530                                   WHERE fra.record = f.record
 531                                         AND fra.tag LIKE '1%'
 532                                         AND fra.subfield = 'a'
 533                                   ORDER BY fra.tag::text::int
 534                                   LIMIT 1
 535                         )) )
 536                 RANK
 537         } else {
 538                 $sort = undef;
 539         }
 540
 541
 542         if ($copies_visible) {
 543                 $select = <<"           SQL";
 544                         SELECT  f.record, $relevance, count(DISTINCT cp.id), $rank
 545                         FROM    $search_table f,
 546                                 $asset_call_number_table cn,
 547                                 $asset_copy_table cp,
 548                                 $cs_table cs,
 549                                 $cl_table cl,
 550                                 $br_table br,
 551                                 $metabib_record_descriptor rd,
 552                                 $descendants d
 553                         WHERE   br.id = f.record
 554                                 AND cn.record = f.record
 555                                 AND rd.record = f.record
 556                                 AND cp.status = cs.id
 557                                 AND cp.location = cl.id
 558                                 AND br.deleted IS FALSE
 559                                 AND cn.deleted IS FALSE
 560                                 AND cp.deleted IS FALSE
 561                                 $has_vols
 562                                 $has_copies
 563                                 $copies_visible
 564                                 $t_filter
 565                                 $f_filter
 566                                 $a_filter
 567                                 $l_filter
 568                                 $lf_filter
 569                         GROUP BY f.record HAVING count(DISTINCT cp.id) > 0
 570                         ORDER BY 4 $sort_dir,3 DESC
 571                 SQL
 572         } else {
 573                 $select = <<"           SQL";
 574                         SELECT  f.record, 1, 1, $rank
 575                         FROM    $search_table f,
 576                                 $br_table br,
 577                                 $metabib_record_descriptor rd
 578                         WHERE   br.id = f.record
 579                                 AND rd.record = f.record
 580                                 AND br.deleted IS FALSE
 581                                 $t_filter
 582                                 $f_filter
 583                                 $a_filter
 584                                 $l_filter
 585                                 $lf_filter
 586                         GROUP BY 1,2,3
 587                         ORDER BY 4 $sort_dir
 588                 SQL
 589         }
 590
 591
 592         $log->debug("Search SQL :: [$select]",DEBUG);
 593
 594         my $recs = metabib::full_rec->db_Main->selectall_arrayref("$select;", {}, @binds);
 595         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 596
 597         my $max = 0;
 598         $max = 1 if (!@$recs);
 599         for (@$recs) {
 600                 $max = $$_[1] if ($$_[1] > $max);
 601         }
 602
 603         my $count = @$recs;
 604         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
 605                 next unless ($$rec[0]);
 606                 my ($rid,$rank,$junk,$skip) = @$rec;
 607                 $client->respond( [$rid, sprintf('%0.3f',$rank/$max), $count] );
 608         }
 609         return undef;
 610 }
 611 __PACKAGE__->register_method(
 612         api_name        => 'open-ils.storage.biblio.full_rec.multi_search',
 613         method          => 'biblio_multi_search_full_rec',
 614         api_level       => 1,
 615         stream          => 1,
 616         cachable        => 1,
 617 );
 618 __PACKAGE__->register_method(
 619         api_name        => 'open-ils.storage.biblio.full_rec.multi_search.staff',
 620         method          => 'biblio_multi_search_full_rec',
 621         api_level       => 1,
 622         stream          => 1,
 623         cachable        => 1,
 624 );
 625
 626 sub search_full_rec {
 627         my $self = shift;
 628         my $client = shift;
 629
 630         my %args = @_;
 631
 632         my $term = $args{term};
 633         my $limiters = $args{restrict};
 634
 635         my ($index_col) = metabib::full_rec->columns('FTS');
 636         $index_col ||= 'value';
 637         my $search_table = metabib::full_rec->table;
 638
 639         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
 640
 641         my $fts_where = $fts->sql_where_clause();
 642         my @fts_ranks = $fts->fts_rank;
 643
 644         my $rank = join(' + ', @fts_ranks);
 645
 646         my @binds;
 647         my @wheres;
 648         for my $limit (@$limiters) {
 649                 push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
 650                 push @binds, $$limit{tag}, $$limit{subfield};
 651                 $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
 652         }
 653         my $where = join(' OR ', @wheres);
 654
 655         my $select = "SELECT record, sum($rank) FROM $search_table WHERE $where GROUP BY 1 ORDER BY 2 DESC;";
 656
 657         $log->debug("Search SQL :: [$select]",DEBUG);
 658
 659         my $recs = metabib::full_rec->db_Main->selectall_arrayref($select, {}, @binds);
 660         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 661
 662         $client->respond($_) for (@$recs);
 663         return undef;
 664 }
 665 __PACKAGE__->register_method(
 666         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.value',
 667         method          => 'search_full_rec',
 668         api_level       => 1,
 669         stream          => 1,
 670         cachable        => 1,
 671 );
 672 __PACKAGE__->register_method(
 673         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.index_vector',
 674         method          => 'search_full_rec',
 675         api_level       => 1,
 676         stream          => 1,
 677         cachable        => 1,
 678 );
 679
 680
 681 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 682 sub search_class_fts {
 683         my $self = shift;
 684         my $client = shift;
 685         my %args = @_;
 686
 687         my $term = $args{term};
 688         my $ou = $args{org_unit};
 689         my $ou_type = $args{depth};
 690         my $limit = $args{limit};
 691         my $offset = $args{offset};
 692
 693         my $limit_clause = '';
 694         my $offset_clause = '';
 695
 696         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
 697         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
 698
 699         my (@types,@forms);
 700         my ($t_filter, $f_filter) = ('','');
 701
 702         if ($args{format}) {
 703                 my ($t, $f) = split '-', $args{format};
 704                 @types = split '', $t;
 705                 @forms = split '', $f;
 706                 if (@types) {
 707                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 708                 }
 709
 710                 if (@forms) {
 711                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 712                 }
 713         }
 714
 715
 716
 717         my $descendants = defined($ou_type) ?
 718                                 "actor.org_unit_descendants($ou, $ou_type)" :
 719                                 "actor.org_unit_descendants($ou)";
 720
 721         my $class = $self->{cdbi};
 722         my $search_table = $class->table;
 723
 724         my $metabib_record_descriptor = metabib::record_descriptor->table;
 725         my $metabib_metarecord = metabib::metarecord->table;
 726         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
 727         my $asset_call_number_table = asset::call_number->table;
 728         my $asset_copy_table = asset::copy->table;
 729         my $cs_table = config::copy_status->table;
 730         my $cl_table = asset::copy_location->table;
 731
 732         my ($index_col) = $class->columns('FTS');
 733         $index_col ||= 'value';
 734
 735         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
 736
 737         my $fts_where = $fts->sql_where_clause;
 738         my @fts_ranks = $fts->fts_rank;
 739
 740         my $rank = join(' + ', @fts_ranks);
 741
 742         my $has_vols = 'AND cn.owning_lib = d.id';
 743         my $has_copies = 'AND cp.call_number = cn.id';
 744         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
 745
 746         my $visible_count = ', count(DISTINCT cp.id)';
 747         my $visible_count_test = 'HAVING count(DISTINCT cp.id) > 0';
 748
 749         if ($self->api_name =~ /staff/o) {
 750                 $copies_visible = '';
 751                 $visible_count_test = '';
 752                 $has_copies = '' if ($ou_type == 0);
 753                 $has_vols = '' if ($ou_type == 0);
 754         }
 755
 756         my $rank_calc = <<"     RANK";
 757                 , (SUM( $rank
 758                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
 759                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
 760                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
 761                 )/COUNT(m.source)), MIN(COALESCE(CHAR_LENGTH(f.value),1))
 762         RANK
 763
 764         $rank_calc = ',1 , 1' if ($self->api_name =~ /unordered/o);
 765
 766         if ($copies_visible) {
 767                 $select = <<"           SQL";
 768                         SELECT  m.metarecord $rank_calc $visible_count, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
 769                         FROM    $search_table f,
 770                                 $metabib_metarecord_source_map_table m,
 771                                 $asset_call_number_table cn,
 772                                 $asset_copy_table cp,
 773                                 $cs_table cs,
 774                                 $cl_table cl,
 775                                 $metabib_record_descriptor rd,
 776                                 $descendants d
 777                         WHERE   $fts_where
 778                                 AND m.source = f.source
 779                                 AND cn.record = m.source
 780                                 AND rd.record = m.source
 781                                 AND cp.status = cs.id
 782                                 AND cp.location = cl.id
 783                                 $has_vols
 784                                 $has_copies
 785                                 $copies_visible
 786                                 $t_filter
 787                                 $f_filter
 788                         GROUP BY 1 $visible_count_test
 789                         ORDER BY 2 DESC,3
 790                         $limit_clause $offset_clause
 791                 SQL
 792         } else {
 793                 $select = <<"           SQL";
 794                         SELECT  m.metarecord $rank_calc, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
 795                         FROM    $search_table f,
 796                                 $metabib_metarecord_source_map_table m,
 797                                 $metabib_record_descriptor rd
 798                         WHERE   $fts_where
 799                                 AND m.source = f.source
 800                                 AND rd.record = m.source
 801                                 $t_filter
 802                                 $f_filter
 803                         GROUP BY 1, 4
 804                         ORDER BY 2 DESC,3
 805                         $limit_clause $offset_clause
 806                 SQL
 807         }
 808
 809         $log->debug("Field Search SQL :: [$select]",DEBUG);
 810
 811         my $SQLstring = join('%',$fts->words);
 812         my $REstring = join('\\s+',$fts->words);
 813         my $first_word = ($fts->words)[0].'%';
 814         my $recs = ($self->api_name =~ /unordered/o) ?
 815                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
 816                         $class->db_Main->selectall_arrayref($select, {},
 817                                 '%'.lc($SQLstring).'%',                 # phrase order match
 818                                 lc($first_word),                        # first word match
 819                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
 820                                 @types, @forms
 821                         );
 822
 823         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 824
 825         $client->respond($_) for (map { [@$_[0,1,3,4]] } @$recs);
 826         return undef;
 827 }
 828
 829 for my $class ( qw/title author subject keyword series/ ) {
 830         __PACKAGE__->register_method(
 831                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord",
 832                 method          => 'search_class_fts',
 833                 api_level       => 1,
 834                 stream          => 1,
 835                 cdbi            => "metabib::${class}_field_entry",
 836                 cachable        => 1,
 837         );
 838         __PACKAGE__->register_method(
 839                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.unordered",
 840                 method          => 'search_class_fts',
 841                 api_level       => 1,
 842                 stream          => 1,
 843                 cdbi            => "metabib::${class}_field_entry",
 844                 cachable        => 1,
 845         );
 846         __PACKAGE__->register_method(
 847                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff",
 848                 method          => 'search_class_fts',
 849                 api_level       => 1,
 850                 stream          => 1,
 851                 cdbi            => "metabib::${class}_field_entry",
 852                 cachable        => 1,
 853         );
 854         __PACKAGE__->register_method(
 855                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff.unordered",
 856                 method          => 'search_class_fts',
 857                 api_level       => 1,
 858                 stream          => 1,
 859                 cdbi            => "metabib::${class}_field_entry",
 860                 cachable        => 1,
 861         );
 862 }
 863
 864 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 865 sub search_class_fts_count {
 866         my $self = shift;
 867         my $client = shift;
 868         my %args = @_;
 869
 870         my $term = $args{term};
 871         my $ou = $args{org_unit};
 872         my $ou_type = $args{depth};
 873         my $limit = $args{limit} || 100;
 874         my $offset = $args{offset} || 0;
 875
 876         my $descendants = defined($ou_type) ?
 877                                 "actor.org_unit_descendants($ou, $ou_type)" :
 878                                 "actor.org_unit_descendants($ou)";
 879
 880         my (@types,@forms);
 881         my ($t_filter, $f_filter) = ('','');
 882
 883         if ($args{format}) {
 884                 my ($t, $f) = split '-', $args{format};
 885                 @types = split '', $t;
 886                 @forms = split '', $f;
 887                 if (@types) {
 888                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 889                 }
 890
 891                 if (@forms) {
 892                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 893                 }
 894         }
 895
 896
 897         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
 898
 899         my $class = $self->{cdbi};
 900         my $search_table = $class->table;
 901
 902         my $metabib_record_descriptor = metabib::record_descriptor->table;
 903         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
 904         my $asset_call_number_table = asset::call_number->table;
 905         my $asset_copy_table = asset::copy->table;
 906         my $cs_table = config::copy_status->table;
 907         my $cl_table = asset::copy_location->table;
 908
 909         my ($index_col) = $class->columns('FTS');
 910         $index_col ||= 'value';
 911
 912         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
 913
 914         my $fts_where = $fts->sql_where_clause;
 915
 916         my $has_vols = 'AND cn.owning_lib = d.id';
 917         my $has_copies = 'AND cp.call_number = cn.id';
 918         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
 919         if ($self->api_name =~ /staff/o) {
 920                 $copies_visible = '';
 921                 $has_vols = '' if ($ou_type == 0);
 922                 $has_copies = '' if ($ou_type == 0);
 923         }
 924
 925         # XXX test an "EXISTS version of descendant checking...
 926         my $select;
 927         if ($copies_visible) {
 928                 $select = <<"           SQL";
 929                 SELECT  count(distinct  m.metarecord)
 930                   FROM  $search_table f,
 931                         $metabib_metarecord_source_map_table m,
 932                         $metabib_metarecord_source_map_table mr,
 933                         $asset_call_number_table cn,
 934                         $asset_copy_table cp,
 935                         $cs_table cs,
 936                         $cl_table cl,
 937                         $metabib_record_descriptor rd,
 938                         $descendants d
 939                   WHERE $fts_where
 940                         AND mr.source = f.source
 941                         AND mr.metarecord = m.metarecord
 942                         AND cn.record = m.source
 943                         AND rd.record = m.source
 944                         AND cp.status = cs.id
 945                         AND cp.location = cl.id
 946                         $has_vols
 947                         $has_copies
 948                         $copies_visible
 949                         $t_filter
 950                         $f_filter
 951                 SQL
 952         } else {
 953                 $select = <<"           SQL";
 954                 SELECT  count(distinct  m.metarecord)
 955                   FROM  $search_table f,
 956                         $metabib_metarecord_source_map_table m,
 957                         $metabib_metarecord_source_map_table mr,
 958                         $metabib_record_descriptor rd
 959                   WHERE $fts_where
 960                         AND mr.source = f.source
 961                         AND mr.metarecord = m.metarecord
 962                         AND rd.record = m.source
 963                         $t_filter
 964                         $f_filter
 965                 SQL
 966         }
 967
 968         $log->debug("Field Search Count SQL :: [$select]",DEBUG);
 969
 970         my $recs = $class->db_Main->selectrow_arrayref($select, {}, @types, @forms)->[0];
 971
 972         $log->debug("Count Search yielded $recs results.",DEBUG);
 973
 974         return $recs;
 975
 976 }
 977 for my $class ( qw/title author subject keyword series/ ) {
 978         __PACKAGE__->register_method(
 979                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count",
 980                 method          => 'search_class_fts_count',
 981                 api_level       => 1,
 982                 stream          => 1,
 983                 cdbi            => "metabib::${class}_field_entry",
 984                 cachable        => 1,
 985         );
 986         __PACKAGE__->register_method(
 987                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count.staff",
 988                 method          => 'search_class_fts_count',
 989                 api_level       => 1,
 990                 stream          => 1,
 991                 cdbi            => "metabib::${class}_field_entry",
 992                 cachable        => 1,
 993         );
 994 }
 995
 996
 997 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 998 sub postfilter_search_class_fts {
 999         my $self = shift;
1000         my $client = shift;
1001         my %args = @_;
1002
1003         my $term = $args{term};
1004         my $sort = $args{'sort'};
1005         my $sort_dir = $args{sort_dir} || 'DESC';
1006         my $ou = $args{org_unit};
1007         my $ou_type = $args{depth};
1008         my $limit = $args{limit} || 10;
1009         my $offset = $args{offset} || 0;
1010
1011         my $outer_limit = 1000;
1012
1013         my $limit_clause = '';
1014         my $offset_clause = '';
1015
1016         $limit_clause = "LIMIT $outer_limit";
1017         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1018
1019         my (@types,@forms,@lang,@aud,@lit_form);
1020         my ($t_filter, $f_filter) = ('','');
1021         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1022         my ($ot_filter, $of_filter) = ('','');
1023         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1024
1025         if (my $a = $args{audience}) {
1026                 $a = [$a] if (!ref($a));
1027                 @aud = @$a;
1028
1029                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1030                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1031         }
1032
1033         if (my $l = $args{language}) {
1034                 $l = [$l] if (!ref($l));
1035                 @lang = @$l;
1036
1037                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1038                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1039         }
1040
1041         if (my $f = $args{lit_form}) {
1042                 $f = [$f] if (!ref($f));
1043                 @lit_form = @$f;
1044
1045                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1046                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1047         }
1048
1049         if ($args{format}) {
1050                 my ($t, $f) = split '-', $args{format};
1051                 @types = split '', $t;
1052                 @forms = split '', $f;
1053                 if (@types) {
1054                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1055                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1056                 }
1057
1058                 if (@forms) {
1059                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1060                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1061                 }
1062         }
1063
1064
1065         my $descendants = defined($ou_type) ?
1066                                 "actor.org_unit_descendants($ou, $ou_type)" :
1067                                 "actor.org_unit_descendants($ou)";
1068
1069         my $class = $self->{cdbi};
1070         my $search_table = $class->table;
1071
1072         my $metabib_full_rec = metabib::full_rec->table;
1073         my $metabib_record_descriptor = metabib::record_descriptor->table;
1074         my $metabib_metarecord = metabib::metarecord->table;
1075         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1076         my $asset_call_number_table = asset::call_number->table;
1077         my $asset_copy_table = asset::copy->table;
1078         my $cs_table = config::copy_status->table;
1079         my $cl_table = asset::copy_location->table;
1080         my $br_table = biblio::record_entry->table;
1081
1082         my ($index_col) = $class->columns('FTS');
1083         $index_col ||= 'value';
1084
1085         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
1086
1087         my $SQLstring = join('%',map { lc($_) } $fts->words);
1088         my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1089         my $first_word = lc(($fts->words)[0]).'%';
1090
1091         my $fts_where = $fts->sql_where_clause;
1092         my @fts_ranks = $fts->fts_rank;
1093
1094         my %bonus = ();
1095         $bonus{'metabib::keyword_field_entry'} = [ { 'CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END' => $SQLstring } ];
1096         $bonus{'metabib::title_field_entry'} =
1097                 $bonus{'metabib::series_field_entry'} = [
1098                         { 'CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END' => $first_word },
1099                         { 'CASE WHEN f.value ~* ? THEN 2 ELSE 1 END' => $REstring },
1100                         @{ $bonus{'metabib::keyword_field_entry'} }
1101                 ];
1102
1103         my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$class} };
1104         $bonus_list ||= '1';
1105
1106         my @bonus_values = map { values %$_ } @{ $bonus{$class} };
1107
1108         my $relevance = join(' + ', @fts_ranks);
1109         $relevance = <<"        RANK";
1110                         (SUM( ( $relevance )  * ( $bonus_list ) )/COUNT(m.source))
1111         RANK
1112
1113         my $rank = $relevance;
1114         if (lc($sort) eq 'pubdate') {
1115                 $rank = <<"             RANK";
1116                         ( FIRST ((
1117                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d+'),'9999')::INT
1118                                   FROM  $metabib_full_rec frp
1119                                   WHERE frp.record = mr.master_record
1120                                         AND frp.tag = '260'
1121                                         AND frp.subfield = 'c'
1122                                   LIMIT 1
1123                         )) )
1124                 RANK
1125         } elsif (lc($sort) eq 'create_date') {
1126                 $rank = <<"             RANK";
1127                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1128                 RANK
1129         } elsif (lc($sort) eq 'edit_date') {
1130                 $rank = <<"             RANK";
1131                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1132                 RANK
1133         } elsif (lc($sort) eq 'title') {
1134                 $rank = <<"             RANK";
1135                         ( FIRST ((
1136                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
1137                                   FROM  $metabib_full_rec frt
1138                                   WHERE frt.record = mr.master_record
1139                                         AND frt.tag = '245'
1140                                         AND frt.subfield = 'a'
1141                                   LIMIT 1
1142                         )) )
1143                 RANK
1144         } elsif (lc($sort) eq 'author') {
1145                 $rank = <<"             RANK";
1146                         ( FIRST((
1147                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
1148                                   FROM  $metabib_full_rec fra
1149                                   WHERE fra.record = mr.master_record
1150                                         AND fra.tag LIKE '1%'
1151                                         AND fra.subfield = 'a'
1152                                   ORDER BY fra.tag::text::int
1153                                   LIMIT 1
1154                         )) )
1155                 RANK
1156         } else {
1157                 $sort = undef;
1158         }
1159
1160         my $select = <<"        SQL";
1161                 SELECT  m.metarecord,
1162                         $relevance,
1163                         CASE WHEN COUNT(DISTINCT smrs.source) = 1 THEN MIN(m.source) ELSE 0 END,
1164                         $rank
1165                 FROM    $search_table f,
1166                         $metabib_metarecord_source_map_table m,
1167                         $metabib_metarecord_source_map_table smrs,
1168                         $metabib_metarecord mr,
1169                         $metabib_record_descriptor rd
1170                 WHERE   $fts_where
1171                         AND smrs.metarecord = mr.id
1172                         AND m.source = f.source
1173                         AND m.metarecord = mr.id
1174                         AND rd.record = smrs.source
1175                         $t_filter
1176                         $f_filter
1177                         $a_filter
1178                         $l_filter
1179                         $lf_filter
1180                 GROUP BY m.metarecord
1181                 ORDER BY 4 $sort_dir, MIN(COALESCE(CHAR_LENGTH(f.value),1))
1182                 LIMIT 2000
1183         SQL
1184
1185         if (0) {
1186                 $select = <<"           SQL";
1187
1188                         SELECT  DISTINCT s.*
1189                           FROM  $asset_call_number_table cn,
1190                                 $metabib_metarecord_source_map_table mrs,
1191                                 $asset_copy_table cp,
1192                                 $cs_table cs,
1193                                 $cl_table cl,
1194                                 $br_table br,
1195                                 $descendants d,
1196                                 $metabib_record_descriptor ord,
1197                                 ($select) s
1198                           WHERE mrs.metarecord = s.metarecord
1199                                 AND br.id = mrs.source
1200                                 AND cn.record = mrs.source
1201                                 AND cp.status = cs.id
1202                                 AND cp.location = cl.id
1203                                 AND cn.owning_lib = d.id
1204                                 AND cp.call_number = cn.id
1205                                 AND cp.opac_visible IS TRUE
1206                                 AND cs.holdable IS TRUE
1207                                 AND cl.opac_visible IS TRUE
1208                                 AND br.active IS TRUE
1209                                 AND br.deleted IS FALSE
1210                                 AND ord.record = mrs.source
1211                                 $ot_filter
1212                                 $of_filter
1213                                 $oa_filter
1214                                 $ol_filter
1215                                 $olf_filter
1216                           ORDER BY 4 $sort_dir
1217                 SQL
1218         } elsif ($self->api_name !~ /staff/o) {
1219                 $select = <<"           SQL";
1220
1221                         SELECT  DISTINCT s.*
1222                           FROM  ($select) s
1223                           WHERE EXISTS (
1224                                 SELECT  1
1225                                   FROM  $asset_call_number_table cn,
1226                                         $metabib_metarecord_source_map_table mrs,
1227                                         $asset_copy_table cp,
1228                                         $cs_table cs,
1229                                         $cl_table cl,
1230                                         $br_table br,
1231                                         $descendants d,
1232                                         $metabib_record_descriptor ord
1233
1234                                   WHERE mrs.metarecord = s.metarecord
1235                                         AND br.id = mrs.source
1236                                         AND cn.record = mrs.source
1237                                         AND cp.status = cs.id
1238                                         AND cp.location = cl.id
1239                                         AND cn.owning_lib = d.id
1240                                         AND cp.call_number = cn.id
1241                                         AND cp.opac_visible IS TRUE
1242                                         AND cs.holdable IS TRUE
1243                                         AND cl.opac_visible IS TRUE
1244                                         AND br.active IS TRUE
1245                                         AND br.deleted IS FALSE
1246                                         AND ord.record = mrs.source
1247                                         $ot_filter
1248                                         $of_filter
1249                                         $oa_filter
1250                                         $ol_filter
1251                                         $olf_filter
1252                                   LIMIT 1
1253                                 )
1254                           ORDER BY 4 $sort_dir
1255                 SQL
1256         } else {
1257                 $select = <<"           SQL";
1258
1259                         SELECT  DISTINCT s.*
1260                           FROM  ($select) s
1261                           WHERE EXISTS (
1262                                 SELECT  1
1263                                   FROM  $asset_call_number_table cn,
1264                                         $metabib_metarecord_source_map_table mrs,
1265                                         $br_table br,
1266                                         $descendants d,
1267                                         $metabib_record_descriptor ord
1268
1269                                   WHERE mrs.metarecord = s.metarecord
1270                                         AND br.id = mrs.source
1271                                         AND cn.record = mrs.source
1272                                         AND cn.owning_lib = d.id
1273                                         AND br.deleted IS FALSE
1274                                         AND ord.record = mrs.source
1275                                         $ot_filter
1276                                         $of_filter
1277                                         $oa_filter
1278                                         $ol_filter
1279                                         $olf_filter
1280                                   LIMIT 1
1281                                 )
1282                                 OR NOT EXISTS (
1283                                 SELECT  1
1284                                   FROM  $asset_call_number_table cn,
1285                                         $metabib_metarecord_source_map_table mrs,
1286                                         $metabib_record_descriptor ord
1287                                   WHERE mrs.metarecord = s.metarecord
1288                                         AND cn.record = mrs.source
1289                                         AND ord.record = mrs.source
1290                                         $ot_filter
1291                                         $of_filter
1292                                         $oa_filter
1293                                         $ol_filter
1294                                         $olf_filter
1295                                   LIMIT 1
1296                                 )
1297                           ORDER BY 4 $sort_dir
1298                 SQL
1299         }
1300
1301
1302         $log->debug("Field Search SQL :: [$select]",DEBUG);
1303
1304         my $recs = $class->db_Main->selectall_arrayref(
1305                         $select, {},
1306                         (@bonus_values > 0 ? @bonus_values : () ),
1307                         ( (!$sort && @bonus_values > 0) ? @bonus_values : () ),
1308                         @types, @forms, @aud, @lang, @lit_form,
1309                         @types, @forms, @aud, @lang, @lit_form,
1310                         ($self->api_name =~ /staff/o ? (@types, @forms, @aud, @lang, @lit_form) : () ) );
1311
1312         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1313
1314         my $max = 0;
1315         $max = 1 if (!@$recs);
1316         for (@$recs) {
1317                 $max = $$_[1] if ($$_[1] > $max);
1318         }
1319
1320         my $count = scalar(@$recs);
1321         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1322                 my ($mrid,$rank,$skip) = @$rec;
1323                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $skip, $count] );
1324         }
1325         return undef;
1326 }
1327
1328 for my $class ( qw/title author subject keyword series/ ) {
1329         __PACKAGE__->register_method(
1330                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord",
1331                 method          => 'postfilter_search_class_fts',
1332                 api_level       => 1,
1333                 stream          => 1,
1334                 cdbi            => "metabib::${class}_field_entry",
1335                 cachable        => 1,
1336         );
1337         __PACKAGE__->register_method(
1338                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord.staff",
1339                 method          => 'postfilter_search_class_fts',
1340                 api_level       => 1,
1341                 stream          => 1,
1342                 cdbi            => "metabib::${class}_field_entry",
1343                 cachable        => 1,
1344         );
1345 }
1346
1347
1348
1349 my $_cdbi = {   title   => "metabib::title_field_entry",
1350                 author  => "metabib::author_field_entry",
1351                 subject => "metabib::subject_field_entry",
1352                 keyword => "metabib::keyword_field_entry",
1353                 series  => "metabib::series_field_entry",
1354 };
1355
1356 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1357 sub postfilter_search_multi_class_fts {
1358         my $self = shift;
1359         my $client = shift;
1360         my %args = @_;
1361
1362         my $sort = $args{'sort'};
1363         my $sort_dir = $args{sort_dir} || 'DESC';
1364         my $ou = $args{org_unit};
1365         my $ou_type = $args{depth};
1366         my $limit = $args{limit} || 10;;
1367         my $offset = $args{offset} || 0;
1368
1369         if (!$ou) {
1370                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
1371         }
1372
1373         if (!defined($args{org_unit})) {
1374                 die "No target organizational unit passed to ".$self->api_name;
1375         }
1376
1377         if (! scalar( keys %{$args{searches}} )) {
1378                 die "No search arguments were passed to ".$self->api_name;
1379         }
1380
1381         my $outer_limit = 1000;
1382
1383         my $limit_clause = '';
1384         my $offset_clause = '';
1385
1386         $limit_clause = "LIMIT $outer_limit";
1387         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1388
1389         my (@types,@forms,@lang,@aud,@lit_form);
1390         my ($t_filter, $f_filter) = ('','');
1391         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1392         my ($ot_filter, $of_filter) = ('','');
1393         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1394
1395         if (my $a = $args{audience}) {
1396                 $a = [$a] if (!ref($a));
1397                 @aud = @$a;
1398
1399                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1400                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1401         }
1402
1403         if (my $l = $args{language}) {
1404                 $l = [$l] if (!ref($l));
1405                 @lang = @$l;
1406
1407                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1408                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1409         }
1410
1411         if (my $f = $args{lit_form}) {
1412                 $f = [$f] if (!ref($f));
1413                 @lit_form = @$f;
1414
1415                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1416                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1417         }
1418
1419         if (my $f = $args{item_form}) {
1420                 $f = [$f] if (!ref($f));
1421                 @forms = @$f;
1422
1423                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1424                 $of_filter = ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1425         }
1426
1427         if (my $t = $args{item_type}) {
1428                 $t = [$t] if (!ref($t));
1429                 @types = @$t;
1430
1431                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1432                 $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1433         }
1434
1435
1436         # XXX legacy format and item type support
1437         if ($args{format}) {
1438                 my ($t, $f) = split '-', $args{format};
1439                 @types = split '', $t;
1440                 @forms = split '', $f;
1441                 if (@types) {
1442                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1443                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1444                 }
1445
1446                 if (@forms) {
1447                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1448                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1449                 }
1450         }
1451
1452
1453
1454         my $descendants = defined($ou_type) ?
1455                                 "actor.org_unit_descendants($ou, $ou_type)" :
1456                                 "actor.org_unit_descendants($ou)";
1457
1458         my $search_table_list = '';
1459         my $fts_list = '';
1460         my $join_table_list = '';
1461         my @rank_list;
1462
1463         my @bonus_lists;
1464         my @bonus_values;
1465         my $prev_search_class;
1466         my $curr_search_class;
1467         for my $search_class (sort keys %{$args{searches}}) {
1468                 $prev_search_class = $curr_search_class if ($curr_search_class);
1469
1470                 $curr_search_class = $search_class;
1471
1472                 my $class = $_cdbi->{$search_class};
1473                 my $search_table = $class->table;
1474
1475                 my ($index_col) = $class->columns('FTS');
1476                 $index_col ||= 'value';
1477
1478
1479                 my $fts = OpenILS::Application::Storage::FTS->compile($args{searches}{$search_class}{term}, $search_class.'.value', "$search_class.$index_col");
1480
1481                 my $fts_where = $fts->sql_where_clause;
1482                 my @fts_ranks = $fts->fts_rank;
1483
1484                 my $SQLstring = join('%',map { lc($_) } $fts->words);
1485                 my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1486                 my $first_word = lc(($fts->words)[0]).'%';
1487
1488                 my $rank = join(' + ', @fts_ranks);
1489
1490                 my %bonus = ();
1491                 $bonus{'keyword'} = [ { "CASE WHEN $search_class.value LIKE ? THEN 1.2 ELSE 1 END" => $SQLstring } ];
1492
1493                 $bonus{'series'} = [
1494                         { "CASE WHEN $search_class.value LIKE ? THEN 1.5 ELSE 1 END" => $first_word },
1495                         { "CASE WHEN $search_class.value ~ ? THEN 20 ELSE 1 END" => $REstring },
1496                 ];
1497
1498                 $bonus{'title'} = [ @{ $bonus{'series'} }, @{ $bonus{'keyword'} } ];
1499
1500                 my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$search_class} };
1501                 $bonus_list ||= '1';
1502
1503                 push @bonus_lists, $bonus_list;
1504                 push @bonus_values, map { values %$_ } @{ $bonus{$search_class} };
1505
1506
1507                 #---------------------
1508
1509                 $search_table_list .= "$search_table $search_class, ";
1510                 push @rank_list,$rank;
1511                 $fts_list .= " AND $fts_where AND m.source = $search_class.source";
1512
1513                 if ($prev_search_class) {
1514                         $join_table_list .= " AND $prev_search_class.source = $curr_search_class.source";
1515                 }
1516         }
1517
1518         my $metabib_record_descriptor = metabib::record_descriptor->table;
1519         my $metabib_full_rec = metabib::full_rec->table;
1520         my $metabib_metarecord = metabib::metarecord->table;
1521         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1522         my $asset_call_number_table = asset::call_number->table;
1523         my $asset_copy_table = asset::copy->table;
1524         my $cs_table = config::copy_status->table;
1525         my $cl_table = asset::copy_location->table;
1526         my $br_table = biblio::record_entry->table;
1527
1528         my $bonuses = join (' * ', @bonus_lists);
1529         my $relevance = join (' + ', @rank_list);
1530         $relevance = "SUM( ($relevance) * ($bonuses) )/COUNT(DISTINCT smrs.source)";
1531
1532
1533         my $secondary_sort = <<"        SORT";
1534                 ( FIRST ((
1535                         SELECT  COALESCE(LTRIM(SUBSTR( sfrt.value, COALESCE(SUBSTRING(sfrt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
1536                           FROM  $metabib_full_rec sfrt,
1537                                 $metabib_metarecord mr
1538                           WHERE sfrt.record = mr.master_record
1539                                 AND sfrt.tag = '245'
1540                                 AND sfrt.subfield = 'a'
1541                           LIMIT 1
1542                 )) )
1543         SORT
1544
1545         my $rank = $relevance;
1546         if (lc($sort) eq 'pubdate') {
1547                 $rank = <<"             RANK";
1548                         ( FIRST ((
1549                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d+'),'9999')::INT
1550                                   FROM  $metabib_full_rec frp
1551                                   WHERE frp.record = mr.master_record
1552                                         AND frp.tag = '260'
1553                                         AND frp.subfield = 'c'
1554                                   LIMIT 1
1555                         )) )
1556                 RANK
1557         } elsif (lc($sort) eq 'create_date') {
1558                 $rank = <<"             RANK";
1559                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1560                 RANK
1561         } elsif (lc($sort) eq 'edit_date') {
1562                 $rank = <<"             RANK";
1563                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1564                 RANK
1565         } elsif (lc($sort) eq 'title') {
1566                 $rank = <<"             RANK";
1567                         ( FIRST ((
1568                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
1569                                   FROM  $metabib_full_rec frt
1570                                   WHERE frt.record = mr.master_record
1571                                         AND frt.tag = '245'
1572                                         AND frt.subfield = 'a'
1573                                   LIMIT 1
1574                         )) )
1575                 RANK
1576                 $secondary_sort = <<"           SORT";
1577                         ( FIRST ((
1578                                 SELECT  COALESCE(SUBSTRING(sfrp.value FROM '\\\\d+'),'9999')::INT
1579                                   FROM  $metabib_full_rec sfrp,
1580                                         $metabib_metarecord mr
1581                                   WHERE sfrp.record = mr.master_record
1582                                         AND sfrp.tag = '260'
1583                                         AND sfrp.subfield = 'c'
1584                                   LIMIT 1
1585                         )) )
1586                 SORT
1587         } elsif (lc($sort) eq 'author') {
1588                 $rank = <<"             RANK";
1589                         ( FIRST((
1590                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
1591                                   FROM  $metabib_full_rec fra
1592                                   WHERE fra.record = mr.master_record
1593                                         AND fra.tag LIKE '1%'
1594                                         AND fra.subfield = 'a'
1595                                   ORDER BY fra.tag::text::int
1596                                   LIMIT 1
1597                         )) )
1598                 RANK
1599         } else {
1600                 push @bonus_values, @bonus_values;
1601                 $sort = undef;
1602         }
1603
1604
1605         my $select = <<"        SQL";
1606                 SELECT  m.metarecord,
1607                         $relevance,
1608                         CASE WHEN COUNT(DISTINCT smrs.source) = 1 THEN FIRST(m.source) ELSE 0 END,
1609                         $rank,
1610                         $secondary_sort
1611                 FROM    $search_table_list
1612                         $metabib_metarecord_source_map_table m,
1613                         $metabib_metarecord_source_map_table smrs
1614                 WHERE   m.metarecord = smrs.metarecord
1615                         $fts_list
1616                         $join_table_list
1617                 GROUP BY m.metarecord
1618                 -- ORDER BY 4 $sort_dir
1619                 LIMIT 2000
1620         SQL
1621
1622         if ($self->api_name !~ /staff/o) {
1623                 $select = <<"           SQL";
1624
1625                         SELECT  s.*
1626                           FROM  ($select) s
1627                           WHERE EXISTS (
1628                                 SELECT  1
1629                                   FROM  $asset_call_number_table cn,
1630                                         $metabib_metarecord_source_map_table mrs,
1631                                         $asset_copy_table cp,
1632                                         $cs_table cs,
1633                                         $cl_table cl,
1634                                         $br_table br,
1635                                         $descendants d,
1636                                         $metabib_record_descriptor ord
1637                                   WHERE mrs.metarecord = s.metarecord
1638                                         AND br.id = mrs.source
1639                                         AND cn.record = mrs.source
1640                                         AND cp.status = cs.id
1641                                         AND cp.location = cl.id
1642                                         AND cn.owning_lib = d.id
1643                                         AND cp.call_number = cn.id
1644                                         AND cp.opac_visible IS TRUE
1645                                         AND cs.holdable IS TRUE
1646                                         AND cl.opac_visible IS TRUE
1647                                         AND br.active IS TRUE
1648                                         AND br.deleted IS FALSE
1649                                         AND cp.deleted IS FALSE
1650                                         AND cn.deleted IS FALSE
1651                                         AND ord.record = mrs.source
1652                                         $ot_filter
1653                                         $of_filter
1654                                         $oa_filter
1655                                         $ol_filter
1656                                         $olf_filter
1657                                   LIMIT 1
1658                                 )
1659                           ORDER BY 4 $sort_dir, 5
1660                 SQL
1661         } else {
1662                 $select = <<"           SQL";
1663
1664                         SELECT  DISTINCT s.*
1665                           FROM  ($select) s,
1666                                 $metabib_metarecord_source_map_table omrs,
1667                                 $metabib_record_descriptor ord
1668                           WHERE omrs.metarecord = s.metarecord
1669                                 AND ord.record = omrs.source
1670                                 AND (   EXISTS (
1671                                                 SELECT  1
1672                                                   FROM  $asset_call_number_table cn,
1673                                                         $descendants d,
1674                                                         $br_table br
1675                                                   WHERE br.id = omrs.source
1676                                                         AND cn.record = omrs.source
1677                                                         AND cn.owning_lib = d.id
1678                                                         AND br.deleted IS FALSE
1679                                                         AND cn.deleted IS FALSE
1680                                                   LIMIT 1
1681                                         )
1682                                         OR NOT EXISTS (
1683                                                 SELECT  1
1684                                                   FROM  $asset_call_number_table cn
1685                                                   WHERE cn.record = omrs.source
1686                                                         AND cn.deleted IS FALSE
1687                                                   LIMIT 1
1688                                         )
1689                                 )
1690                                 $ot_filter
1691                                 $of_filter
1692                                 $oa_filter
1693                                 $ol_filter
1694                                 $olf_filter
1695
1696                           ORDER BY 4 $sort_dir, 5
1697                 SQL
1698         }
1699
1700
1701         $log->debug("Field Search SQL :: [$select]",DEBUG);
1702
1703         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
1704                         $select, {},
1705                         @bonus_values,
1706                         @types, @forms, @aud, @lang, @lit_form,
1707                         # @types, @forms, @aud, @lang, @lit_form,
1708                         # ($self->api_name =~ /staff/o ? (@types, @forms, @aud, @lang, @lit_form) : () )
1709         );
1710
1711         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1712
1713         my $max = 0;
1714         $max = 1 if (!@$recs);
1715         for (@$recs) {
1716                 $max = $$_[1] if ($$_[1] > $max);
1717         }
1718
1719         my $count = scalar(@$recs);
1720         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1721                 next unless ($$rec[0]);
1722                 my ($mrid,$rank,$skip) = @$rec;
1723                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $skip, $count] );
1724         }
1725         return undef;
1726 }
1727
1728 __PACKAGE__->register_method(
1729         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord",
1730         method          => 'postfilter_search_multi_class_fts',
1731         api_level       => 1,
1732         stream          => 1,
1733         cachable        => 1,
1734 );
1735 __PACKAGE__->register_method(
1736         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord.staff",
1737         method          => 'postfilter_search_multi_class_fts',
1738         api_level       => 1,
1739         stream          => 1,
1740         cachable        => 1,
1741 );
1742
1743 __PACKAGE__->register_method(
1744         api_name        => "open-ils.storage.metabib.multiclass.search_fts",
1745         method          => 'postfilter_search_multi_class_fts',
1746         api_level       => 1,
1747         stream          => 1,
1748         cachable        => 1,
1749 );
1750 __PACKAGE__->register_method(
1751         api_name        => "open-ils.storage.metabib.multiclass.search_fts.staff",
1752         method          => 'postfilter_search_multi_class_fts',
1753         api_level       => 1,
1754         stream          => 1,
1755         cachable        => 1,
1756 );
1757
1758 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1759 sub biblio_search_multi_class_fts {
1760         my $self = shift;
1761         my $client = shift;
1762         my %args = @_;
1763
1764         my $sort = $args{'sort'};
1765         my $sort_dir = $args{sort_dir} || 'DESC';
1766         my $ou = $args{org_unit};
1767         my $ou_type = $args{depth};
1768         my $limit = $args{limit} || 10;
1769         my $offset = $args{offset} || 0;
1770
1771         if (!$ou) {
1772                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
1773         }
1774
1775         if (!defined($args{org_unit})) {
1776                 die "No target organizational unit passed to ".$self->api_name;
1777         }
1778
1779         if (! scalar( keys %{$args{searches}} )) {
1780                 die "No search arguments were passed to ".$self->api_name;
1781         }
1782
1783         my $outer_limit = 1000;
1784
1785         my $limit_clause = '';
1786         my $offset_clause = '';
1787
1788         $limit_clause = "LIMIT $outer_limit";
1789         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1790
1791         my (@types,@forms,@lang,@aud,@lit_form);
1792         my ($t_filter, $f_filter) = ('','');
1793         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1794         my ($ot_filter, $of_filter) = ('','');
1795         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1796
1797         if (my $a = $args{audience}) {
1798                 $a = [$a] if (!ref($a));
1799                 @aud = @$a;
1800
1801                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1802                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1803         }
1804
1805         if (my $l = $args{language}) {
1806                 $l = [$l] if (!ref($l));
1807                 @lang = @$l;
1808
1809                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1810                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1811         }
1812
1813         if (my $f = $args{lit_form}) {
1814                 $f = [$f] if (!ref($f));
1815                 @lit_form = @$f;
1816
1817                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1818                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1819         }
1820
1821         if (my $f = $args{item_form}) {
1822                 $f = [$f] if (!ref($f));
1823                 @forms = @$f;
1824
1825                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1826                 $of_filter = ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1827         }
1828
1829         if (my $t = $args{item_type}) {
1830                 $t = [$t] if (!ref($t));
1831                 @types = @$t;
1832
1833                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1834                 $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1835         }
1836
1837
1838         # XXX legacy format and item type support
1839         if ($args{format}) {
1840                 my ($t, $f) = split '-', $args{format};
1841                 @types = split '', $t;
1842                 @forms = split '', $f;
1843                 if (@types) {
1844                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1845                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1846                 }
1847
1848                 if (@forms) {
1849                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1850                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1851                 }
1852         }
1853
1854
1855         my $descendants = defined($ou_type) ?
1856                                 "actor.org_unit_descendants($ou, $ou_type)" :
1857                                 "actor.org_unit_descendants($ou)";
1858
1859         my $search_table_list = '';
1860         my $fts_list = '';
1861         my $join_table_list = '';
1862         my @rank_list;
1863
1864
1865         my @bonus_lists;
1866         my @bonus_values;
1867         my $prev_search_class;
1868         my $curr_search_class;
1869         for my $search_class (sort keys %{$args{searches}}) {
1870                 $prev_search_class = $curr_search_class if ($curr_search_class);
1871
1872                 $curr_search_class = $search_class;
1873
1874                 my $class = $_cdbi->{$search_class};
1875                 my $search_table = $class->table;
1876
1877                 my ($index_col) = $class->columns('FTS');
1878                 $index_col ||= 'value';
1879
1880
1881                 my $fts = OpenILS::Application::Storage::FTS->compile($args{searches}{$search_class}{term}, $search_class.'.value', "$search_class.$index_col");
1882
1883                 my $fts_where = $fts->sql_where_clause;
1884                 my @fts_ranks = $fts->fts_rank;
1885
1886                 my $SQLstring = join('%',map { lc($_) } $fts->words);
1887                 my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1888                 my $first_word = lc(($fts->words)[0]).'%';
1889
1890                 my $rank = join(' + ', @fts_ranks);
1891
1892                 my %bonus = ();
1893                 $bonus{'keyword'} = [ { "CASE WHEN $search_class.value ILIKE ? THEN 1.2 ELSE 1 END" => $SQLstring } ];
1894
1895                 $bonus{'series'} = [
1896                         { "CASE WHEN $search_class.value ILIKE ? THEN 1.5 ELSE 1 END" => $first_word },
1897                         { "CASE WHEN $search_class.value ~ ? THEN 200 ELSE 1 END" => $REstring },
1898                 ];
1899
1900                 $bonus{'title'} = [ @{ $bonus{'series'} }, @{ $bonus{'keyword'} } ];
1901
1902                 my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$search_class} };
1903                 $bonus_list ||= '1';
1904
1905                 push @bonus_lists, $bonus_list;
1906                 push @bonus_values, map { values %$_ } @{ $bonus{$search_class} };
1907
1908                 #---------------------
1909
1910                 $search_table_list .= "$search_table $search_class, ";
1911                 push @rank_list,$rank;
1912                 $fts_list .= " AND $fts_where AND b.id = $search_class.source";
1913
1914                 if ($prev_search_class) {
1915                         $join_table_list .= " AND $prev_search_class.source = $curr_search_class.source";
1916                 }
1917         }
1918
1919         my $metabib_record_descriptor = metabib::record_descriptor->table;
1920         my $metabib_full_rec = metabib::full_rec->table;
1921         my $metabib_metarecord = metabib::metarecord->table;
1922         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1923         my $asset_call_number_table = asset::call_number->table;
1924         my $asset_copy_table = asset::copy->table;
1925         my $cs_table = config::copy_status->table;
1926         my $cl_table = asset::copy_location->table;
1927         my $br_table = biblio::record_entry->table;
1928
1929
1930         my $bonuses = join (' * ', @bonus_lists);
1931         my $relevance = join (' + ', @rank_list);
1932         $relevance = "AVG( ($relevance) * ($bonuses) )";
1933
1934
1935         my $rank = $relevance;
1936         if (lc($sort) eq 'pubdate') {
1937                 $rank = <<"             RANK";
1938                         ( FIRST ((
1939                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d{4}'),'9999')::INT
1940                                   FROM  $metabib_full_rec frp
1941                                   WHERE frp.record = b.id
1942                                         AND frp.tag = '260'
1943                                         AND frp.subfield = 'c'
1944                                   LIMIT 1
1945                         )) )
1946                 RANK
1947         } elsif (lc($sort) eq 'create_date') {
1948                 $rank = <<"             RANK";
1949                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = b.id)) )
1950                 RANK
1951         } elsif (lc($sort) eq 'edit_date') {
1952                 $rank = <<"             RANK";
1953                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = b.id)) )
1954                 RANK
1955         } elsif (lc($sort) eq 'title') {
1956                 $rank = <<"             RANK";
1957                         ( FIRST ((
1958                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
1959                                   FROM  $metabib_full_rec frt
1960                                   WHERE frt.record = b.id
1961                                         AND frt.tag = '245'
1962                                         AND frt.subfield = 'a'
1963                                   LIMIT 1
1964                         )) )
1965                 RANK
1966         } elsif (lc($sort) eq 'author') {
1967                 $rank = <<"             RANK";
1968                         ( FIRST((
1969                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
1970                                   FROM  $metabib_full_rec fra
1971                                   WHERE fra.record = b.id
1972                                         AND fra.tag LIKE '1%'
1973                                         AND fra.subfield = 'a'
1974                                   ORDER BY fra.tag::text::int
1975                                   LIMIT 1
1976                         )) )
1977                 RANK
1978         } else {
1979                 push @bonus_values, @bonus_values;
1980                 $sort = undef;
1981         }
1982
1983
1984         my $select = <<"        SQL";
1985                 SELECT  b.id,
1986                         $relevance AS rel,
1987                         $rank AS rank
1988                 FROM    $search_table_list
1989                         $metabib_record_descriptor rd,
1990                         $br_table b
1991                 WHERE   rd.record = b.id
1992                         AND b.active IS TRUE
1993                         AND b.deleted IS FALSE
1994                         $fts_list
1995                         $join_table_list
1996                         $t_filter
1997                         $f_filter
1998                         $a_filter
1999                         $l_filter
2000                         $lf_filter
2001                 GROUP BY b.id
2002                 ORDER BY 3 $sort_dir
2003                 LIMIT 2000
2004         SQL
2005
2006         if ($self->api_name !~ /staff/o) {
2007                 $select = <<"           SQL";
2008
2009                         SELECT  s.*
2010                           FROM  ($select) s
2011                           WHERE EXISTS (
2012                                 SELECT  1
2013                                   FROM  $asset_call_number_table cn,
2014                                         $asset_copy_table cp,
2015                                         $cs_table cs,
2016                                         $cl_table cl,
2017                                         $descendants d
2018                                   WHERE cn.record = s.id
2019                                         AND cp.status = cs.id
2020                                         AND cp.location = cl.id
2021                                         AND cn.owning_lib = d.id
2022                                         AND cp.call_number = cn.id
2023                                         AND cp.opac_visible IS TRUE
2024                                         AND cs.holdable IS TRUE
2025                                         AND cl.opac_visible IS TRUE
2026                                         AND cp.deleted IS FALSE
2027                                         AND cn.deleted IS FALSE
2028                                   LIMIT 1
2029                                 )
2030                           ORDER BY 3 $sort_dir
2031                 SQL
2032         } else {
2033                 $select = <<"           SQL";
2034
2035                         SELECT  s.*
2036                           FROM  ($select) s
2037                           WHERE EXISTS (
2038                                 SELECT  1
2039                                   FROM  $asset_call_number_table cn,
2040                                         $descendants d
2041                                   WHERE cn.record = s.id
2042                                         AND cn.owning_lib = d.id
2043                                         AND cn.deleted IS FALSE
2044                                   LIMIT 1
2045                                 )
2046                                 OR NOT EXISTS (
2047                                 SELECT  1
2048                                   FROM  $asset_call_number_table cn
2049                                   WHERE cn.record = s.id
2050                                   LIMIT 1
2051                                 )
2052                           ORDER BY 3 $sort_dir
2053                 SQL
2054         }
2055
2056
2057         $log->debug("Field Search SQL :: [$select]",DEBUG);
2058
2059         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
2060                         $select, {},
2061                         @bonus_values, @types, @forms, @aud, @lang, @lit_form
2062         );
2063
2064         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
2065
2066         my $max = 0;
2067         $max = 1 if (!@$recs);
2068         for (@$recs) {
2069                 $max = $$_[1] if ($$_[1] > $max);
2070         }
2071
2072         my $count = scalar(@$recs);
2073         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
2074                 next unless ($$rec[0]);
2075                 my ($mrid,$rank) = @$rec;
2076                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $count] );
2077         }
2078         return undef;
2079 }
2080
2081 __PACKAGE__->register_method(
2082         api_name        => "open-ils.storage.biblio.multiclass.search_fts.record",
2083         method          => 'biblio_search_multi_class_fts',
2084         api_level       => 1,
2085         stream          => 1,
2086         cachable        => 1,
2087 );
2088 __PACKAGE__->register_method(
2089         api_name        => "open-ils.storage.biblio.multiclass.search_fts.record.staff",
2090         method          => 'biblio_search_multi_class_fts',
2091         api_level       => 1,
2092         stream          => 1,
2093         cachable        => 1,
2094 );
2095
2096
2097
2098 __PACKAGE__->register_method(
2099         api_name        => "open-ils.storage.biblio.multiclass.search_fts",
2100         method          => 'biblio_search_multi_class_fts',
2101         api_level       => 1,
2102         stream          => 1,
2103         cachable        => 1,
2104 );
2105 __PACKAGE__->register_method(
2106         api_name        => "open-ils.storage.biblio.multiclass.search_fts.staff",
2107         method          => 'biblio_search_multi_class_fts',
2108         api_level       => 1,
2109         stream          => 1,
2110         cachable        => 1,
2111 );
2112
2113
2114 1;
2115