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 $visiblity_limit = $args{visiblity_limit} || 5000;
1010         my $offset = $args{offset} || 0;
1011
1012         my $outer_limit = 1000;
1013
1014         my $limit_clause = '';
1015         my $offset_clause = '';
1016
1017         $limit_clause = "LIMIT $outer_limit";
1018         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1019
1020         my (@types,@forms,@lang,@aud,@lit_form);
1021         my ($t_filter, $f_filter) = ('','');
1022         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1023         my ($ot_filter, $of_filter) = ('','');
1024         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1025
1026         if (my $a = $args{audience}) {
1027                 $a = [$a] if (!ref($a));
1028                 @aud = @$a;
1029
1030                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1031                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1032         }
1033
1034         if (my $l = $args{language}) {
1035                 $l = [$l] if (!ref($l));
1036                 @lang = @$l;
1037
1038                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1039                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1040         }
1041
1042         if (my $f = $args{lit_form}) {
1043                 $f = [$f] if (!ref($f));
1044                 @lit_form = @$f;
1045
1046                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1047                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1048         }
1049
1050         if ($args{format}) {
1051                 my ($t, $f) = split '-', $args{format};
1052                 @types = split '', $t;
1053                 @forms = split '', $f;
1054                 if (@types) {
1055                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1056                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1057                 }
1058
1059                 if (@forms) {
1060                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1061                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1062                 }
1063         }
1064
1065
1066         my $descendants = defined($ou_type) ?
1067                                 "actor.org_unit_descendants($ou, $ou_type)" :
1068                                 "actor.org_unit_descendants($ou)";
1069
1070         my $class = $self->{cdbi};
1071         my $search_table = $class->table;
1072
1073         my $metabib_full_rec = metabib::full_rec->table;
1074         my $metabib_record_descriptor = metabib::record_descriptor->table;
1075         my $metabib_metarecord = metabib::metarecord->table;
1076         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1077         my $asset_call_number_table = asset::call_number->table;
1078         my $asset_copy_table = asset::copy->table;
1079         my $cs_table = config::copy_status->table;
1080         my $cl_table = asset::copy_location->table;
1081         my $br_table = biblio::record_entry->table;
1082
1083         my ($index_col) = $class->columns('FTS');
1084         $index_col ||= 'value';
1085
1086         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
1087
1088         my $SQLstring = join('%',map { lc($_) } $fts->words);
1089         my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1090         my $first_word = lc(($fts->words)[0]).'%';
1091
1092         my $fts_where = $fts->sql_where_clause;
1093         my @fts_ranks = $fts->fts_rank;
1094
1095         my %bonus = ();
1096         $bonus{'metabib::keyword_field_entry'} = [ { 'CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END' => $SQLstring } ];
1097         $bonus{'metabib::title_field_entry'} =
1098                 $bonus{'metabib::series_field_entry'} = [
1099                         { 'CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END' => $first_word },
1100                         { 'CASE WHEN f.value ~* ? THEN 2 ELSE 1 END' => $REstring },
1101                         @{ $bonus{'metabib::keyword_field_entry'} }
1102                 ];
1103
1104         my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$class} };
1105         $bonus_list ||= '1';
1106
1107         my @bonus_values = map { values %$_ } @{ $bonus{$class} };
1108
1109         my $relevance = join(' + ', @fts_ranks);
1110         $relevance = <<"        RANK";
1111                         (SUM( ( $relevance )  * ( $bonus_list ) )/COUNT(m.source))
1112         RANK
1113
1114         my $rank = $relevance;
1115         if (lc($sort) eq 'pubdate') {
1116                 $rank = <<"             RANK";
1117                         ( FIRST ((
1118                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d+'),'9999')::INT
1119                                   FROM  $metabib_full_rec frp
1120                                   WHERE frp.record = mr.master_record
1121                                         AND frp.tag = '260'
1122                                         AND frp.subfield = 'c'
1123                                   LIMIT 1
1124                         )) )
1125                 RANK
1126         } elsif (lc($sort) eq 'create_date') {
1127                 $rank = <<"             RANK";
1128                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1129                 RANK
1130         } elsif (lc($sort) eq 'edit_date') {
1131                 $rank = <<"             RANK";
1132                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1133                 RANK
1134         } elsif (lc($sort) eq 'title') {
1135                 $rank = <<"             RANK";
1136                         ( FIRST ((
1137                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
1138                                   FROM  $metabib_full_rec frt
1139                                   WHERE frt.record = mr.master_record
1140                                         AND frt.tag = '245'
1141                                         AND frt.subfield = 'a'
1142                                   LIMIT 1
1143                         )) )
1144                 RANK
1145         } elsif (lc($sort) eq 'author') {
1146                 $rank = <<"             RANK";
1147                         ( FIRST((
1148                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
1149                                   FROM  $metabib_full_rec fra
1150                                   WHERE fra.record = mr.master_record
1151                                         AND fra.tag LIKE '1%'
1152                                         AND fra.subfield = 'a'
1153                                   ORDER BY fra.tag::text::int
1154                                   LIMIT 1
1155                         )) )
1156                 RANK
1157         } else {
1158                 $sort = undef;
1159         }
1160
1161         my $select = <<"        SQL";
1162                 SELECT  m.metarecord,
1163                         $relevance,
1164                         CASE WHEN COUNT(DISTINCT smrs.source) = 1 THEN MIN(m.source) ELSE 0 END,
1165                         $rank
1166                 FROM    $search_table f,
1167                         $metabib_metarecord_source_map_table m,
1168                         $metabib_metarecord_source_map_table smrs,
1169                         $metabib_metarecord mr,
1170                         $metabib_record_descriptor rd
1171                 WHERE   $fts_where
1172                         AND smrs.metarecord = mr.id
1173                         AND m.source = f.source
1174                         AND m.metarecord = mr.id
1175                         AND rd.record = smrs.source
1176                         $t_filter
1177                         $f_filter
1178                         $a_filter
1179                         $l_filter
1180                         $lf_filter
1181                 GROUP BY m.metarecord
1182                 ORDER BY 4 $sort_dir, MIN(COALESCE(CHAR_LENGTH(f.value),1))
1183                 LIMIT $visiblity_limit
1184         SQL
1185
1186         if (0) {
1187                 $select = <<"           SQL";
1188
1189                         SELECT  DISTINCT s.*
1190                           FROM  $asset_call_number_table cn,
1191                                 $metabib_metarecord_source_map_table mrs,
1192                                 $asset_copy_table cp,
1193                                 $cs_table cs,
1194                                 $cl_table cl,
1195                                 $br_table br,
1196                                 $descendants d,
1197                                 $metabib_record_descriptor ord,
1198                                 ($select) s
1199                           WHERE mrs.metarecord = s.metarecord
1200                                 AND br.id = mrs.source
1201                                 AND cn.record = mrs.source
1202                                 AND cp.status = cs.id
1203                                 AND cp.location = cl.id
1204                                 AND cn.owning_lib = d.id
1205                                 AND cp.call_number = cn.id
1206                                 AND cp.opac_visible IS TRUE
1207                                 AND cs.holdable IS TRUE
1208                                 AND cl.opac_visible IS TRUE
1209                                 AND br.active IS TRUE
1210                                 AND br.deleted IS FALSE
1211                                 AND ord.record = mrs.source
1212                                 $ot_filter
1213                                 $of_filter
1214                                 $oa_filter
1215                                 $ol_filter
1216                                 $olf_filter
1217                           ORDER BY 4 $sort_dir
1218                 SQL
1219         } elsif ($self->api_name !~ /staff/o) {
1220                 $select = <<"           SQL";
1221
1222                         SELECT  DISTINCT s.*
1223                           FROM  ($select) s
1224                           WHERE EXISTS (
1225                                 SELECT  1
1226                                   FROM  $asset_call_number_table cn,
1227                                         $metabib_metarecord_source_map_table mrs,
1228                                         $asset_copy_table cp,
1229                                         $cs_table cs,
1230                                         $cl_table cl,
1231                                         $br_table br,
1232                                         $descendants d,
1233                                         $metabib_record_descriptor ord
1234
1235                                   WHERE mrs.metarecord = s.metarecord
1236                                         AND br.id = mrs.source
1237                                         AND cn.record = mrs.source
1238                                         AND cp.status = cs.id
1239                                         AND cp.location = cl.id
1240                                         AND cn.owning_lib = d.id
1241                                         AND cp.call_number = cn.id
1242                                         AND cp.opac_visible IS TRUE
1243                                         AND cs.holdable IS TRUE
1244                                         AND cl.opac_visible IS TRUE
1245                                         AND br.active IS TRUE
1246                                         AND br.deleted IS FALSE
1247                                         AND ord.record = mrs.source
1248                                         $ot_filter
1249                                         $of_filter
1250                                         $oa_filter
1251                                         $ol_filter
1252                                         $olf_filter
1253                                   LIMIT 1
1254                                 )
1255                           ORDER BY 4 $sort_dir
1256                 SQL
1257         } else {
1258                 $select = <<"           SQL";
1259
1260                         SELECT  DISTINCT s.*
1261                           FROM  ($select) s
1262                           WHERE EXISTS (
1263                                 SELECT  1
1264                                   FROM  $asset_call_number_table cn,
1265                                         $metabib_metarecord_source_map_table mrs,
1266                                         $br_table br,
1267                                         $descendants d,
1268                                         $metabib_record_descriptor ord
1269
1270                                   WHERE mrs.metarecord = s.metarecord
1271                                         AND br.id = mrs.source
1272                                         AND cn.record = mrs.source
1273                                         AND cn.owning_lib = d.id
1274                                         AND br.deleted IS FALSE
1275                                         AND ord.record = mrs.source
1276                                         $ot_filter
1277                                         $of_filter
1278                                         $oa_filter
1279                                         $ol_filter
1280                                         $olf_filter
1281                                   LIMIT 1
1282                                 )
1283                                 OR NOT EXISTS (
1284                                 SELECT  1
1285                                   FROM  $asset_call_number_table cn,
1286                                         $metabib_metarecord_source_map_table mrs,
1287                                         $metabib_record_descriptor ord
1288                                   WHERE mrs.metarecord = s.metarecord
1289                                         AND cn.record = mrs.source
1290                                         AND ord.record = mrs.source
1291                                         $ot_filter
1292                                         $of_filter
1293                                         $oa_filter
1294                                         $ol_filter
1295                                         $olf_filter
1296                                   LIMIT 1
1297                                 )
1298                           ORDER BY 4 $sort_dir
1299                 SQL
1300         }
1301
1302
1303         $log->debug("Field Search SQL :: [$select]",DEBUG);
1304
1305         my $recs = $class->db_Main->selectall_arrayref(
1306                         $select, {},
1307                         (@bonus_values > 0 ? @bonus_values : () ),
1308                         ( (!$sort && @bonus_values > 0) ? @bonus_values : () ),
1309                         @types, @forms, @aud, @lang, @lit_form,
1310                         @types, @forms, @aud, @lang, @lit_form,
1311                         ($self->api_name =~ /staff/o ? (@types, @forms, @aud, @lang, @lit_form) : () ) );
1312
1313         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1314
1315         my $max = 0;
1316         $max = 1 if (!@$recs);
1317         for (@$recs) {
1318                 $max = $$_[1] if ($$_[1] > $max);
1319         }
1320
1321         my $count = scalar(@$recs);
1322         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1323                 my ($mrid,$rank,$skip) = @$rec;
1324                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $skip, $count] );
1325         }
1326         return undef;
1327 }
1328
1329 for my $class ( qw/title author subject keyword series/ ) {
1330         __PACKAGE__->register_method(
1331                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord",
1332                 method          => 'postfilter_search_class_fts',
1333                 api_level       => 1,
1334                 stream          => 1,
1335                 cdbi            => "metabib::${class}_field_entry",
1336                 cachable        => 1,
1337         );
1338         __PACKAGE__->register_method(
1339                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord.staff",
1340                 method          => 'postfilter_search_class_fts',
1341                 api_level       => 1,
1342                 stream          => 1,
1343                 cdbi            => "metabib::${class}_field_entry",
1344                 cachable        => 1,
1345         );
1346 }
1347
1348
1349
1350 my $_cdbi = {   title   => "metabib::title_field_entry",
1351                 author  => "metabib::author_field_entry",
1352                 subject => "metabib::subject_field_entry",
1353                 keyword => "metabib::keyword_field_entry",
1354                 series  => "metabib::series_field_entry",
1355 };
1356
1357 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1358 sub postfilter_search_multi_class_fts {
1359         my $self = shift;
1360         my $client = shift;
1361         my %args = @_;
1362
1363         my $sort = $args{'sort'};
1364         my $sort_dir = $args{sort_dir} || 'DESC';
1365         my $ou = $args{org_unit};
1366         my $ou_type = $args{depth};
1367         my $limit = $args{limit} || 10;;
1368         my $visiblity_limit = $args{visiblity_limit} || 5000;;
1369         my $offset = $args{offset} || 0;
1370
1371         if (!$ou) {
1372                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
1373         }
1374
1375         if (!defined($args{org_unit})) {
1376                 die "No target organizational unit passed to ".$self->api_name;
1377         }
1378
1379         if (! scalar( keys %{$args{searches}} )) {
1380                 die "No search arguments were passed to ".$self->api_name;
1381         }
1382
1383         my $outer_limit = 1000;
1384
1385         my $limit_clause = '';
1386         my $offset_clause = '';
1387
1388         $limit_clause = "LIMIT $outer_limit";
1389         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1390
1391         my (@types,@forms,@lang,@aud,@lit_form);
1392         my ($t_filter, $f_filter) = ('','');
1393         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1394         my ($ot_filter, $of_filter) = ('','');
1395         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1396
1397         if (my $a = $args{audience}) {
1398                 $a = [$a] if (!ref($a));
1399                 @aud = @$a;
1400
1401                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1402                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1403         }
1404
1405         if (my $l = $args{language}) {
1406                 $l = [$l] if (!ref($l));
1407                 @lang = @$l;
1408
1409                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1410                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1411         }
1412
1413         if (my $f = $args{lit_form}) {
1414                 $f = [$f] if (!ref($f));
1415                 @lit_form = @$f;
1416
1417                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1418                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1419         }
1420
1421         if (my $f = $args{item_form}) {
1422                 $f = [$f] if (!ref($f));
1423                 @forms = @$f;
1424
1425                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1426                 $of_filter = ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1427         }
1428
1429         if (my $t = $args{item_type}) {
1430                 $t = [$t] if (!ref($t));
1431                 @types = @$t;
1432
1433                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1434                 $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1435         }
1436
1437
1438         # XXX legacy format and item type support
1439         if ($args{format}) {
1440                 my ($t, $f) = split '-', $args{format};
1441                 @types = split '', $t;
1442                 @forms = split '', $f;
1443                 if (@types) {
1444                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1445                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1446                 }
1447
1448                 if (@forms) {
1449                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1450                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1451                 }
1452         }
1453
1454
1455
1456         my $descendants = defined($ou_type) ?
1457                                 "actor.org_unit_descendants($ou, $ou_type)" :
1458                                 "actor.org_unit_descendants($ou)";
1459
1460         my $search_table_list = '';
1461         my $fts_list = '';
1462         my $join_table_list = '';
1463         my @rank_list;
1464
1465         my @bonus_lists;
1466         my @bonus_values;
1467         my $prev_search_class;
1468         my $curr_search_class;
1469         for my $search_class (sort keys %{$args{searches}}) {
1470                 $prev_search_class = $curr_search_class if ($curr_search_class);
1471
1472                 $curr_search_class = $search_class;
1473
1474                 my $class = $_cdbi->{$search_class};
1475                 my $search_table = $class->table;
1476
1477                 my ($index_col) = $class->columns('FTS');
1478                 $index_col ||= 'value';
1479
1480
1481                 my $fts = OpenILS::Application::Storage::FTS->compile($args{searches}{$search_class}{term}, $search_class.'.value', "$search_class.$index_col");
1482
1483                 my $fts_where = $fts->sql_where_clause;
1484                 my @fts_ranks = $fts->fts_rank;
1485
1486                 my $SQLstring = join('%',map { lc($_) } $fts->words);
1487                 my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1488                 my $first_word = lc(($fts->words)[0]).'%';
1489
1490                 my $rank = join(' + ', @fts_ranks);
1491
1492                 my %bonus = ();
1493                 $bonus{'keyword'} = [ { "CASE WHEN $search_class.value LIKE ? THEN 1.2 ELSE 1 END" => $SQLstring } ];
1494
1495                 $bonus{'series'} = [
1496                         { "CASE WHEN $search_class.value LIKE ? THEN 1.5 ELSE 1 END" => $first_word },
1497                         { "CASE WHEN $search_class.value ~ ? THEN 20 ELSE 1 END" => $REstring },
1498                 ];
1499
1500                 $bonus{'title'} = [ @{ $bonus{'series'} }, @{ $bonus{'keyword'} } ];
1501
1502                 my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$search_class} };
1503                 $bonus_list ||= '1';
1504
1505                 push @bonus_lists, $bonus_list;
1506                 push @bonus_values, map { values %$_ } @{ $bonus{$search_class} };
1507
1508
1509                 #---------------------
1510
1511                 $search_table_list .= "$search_table $search_class, ";
1512                 push @rank_list,$rank;
1513                 $fts_list .= " AND $fts_where AND m.source = $search_class.source";
1514
1515                 if ($prev_search_class) {
1516                         $join_table_list .= " AND $prev_search_class.source = $curr_search_class.source";
1517                 }
1518         }
1519
1520         my $metabib_record_descriptor = metabib::record_descriptor->table;
1521         my $metabib_full_rec = metabib::full_rec->table;
1522         my $metabib_metarecord = metabib::metarecord->table;
1523         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1524         my $asset_call_number_table = asset::call_number->table;
1525         my $asset_copy_table = asset::copy->table;
1526         my $cs_table = config::copy_status->table;
1527         my $cl_table = asset::copy_location->table;
1528         my $br_table = biblio::record_entry->table;
1529
1530         my $bonuses = join (' * ', @bonus_lists);
1531         my $relevance = join (' + ', @rank_list);
1532         $relevance = "SUM( ($relevance) * ($bonuses) )/COUNT(DISTINCT smrs.source)";
1533
1534
1535         my $secondary_sort = <<"        SORT";
1536                 ( FIRST ((
1537                         SELECT  COALESCE(LTRIM(SUBSTR( sfrt.value, COALESCE(SUBSTRING(sfrt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
1538                           FROM  $metabib_full_rec sfrt,
1539                                 $metabib_metarecord mr
1540                           WHERE sfrt.record = mr.master_record
1541                                 AND sfrt.tag = '245'
1542                                 AND sfrt.subfield = 'a'
1543                           LIMIT 1
1544                 )) )
1545         SORT
1546
1547         my $rank = $relevance;
1548         if (lc($sort) eq 'pubdate') {
1549                 $rank = <<"             RANK";
1550                         ( FIRST ((
1551                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d+'),'9999')::INT
1552                                   FROM  $metabib_full_rec frp
1553                                   WHERE frp.record = mr.master_record
1554                                         AND frp.tag = '260'
1555                                         AND frp.subfield = 'c'
1556                                   LIMIT 1
1557                         )) )
1558                 RANK
1559         } elsif (lc($sort) eq 'create_date') {
1560                 $rank = <<"             RANK";
1561                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1562                 RANK
1563         } elsif (lc($sort) eq 'edit_date') {
1564                 $rank = <<"             RANK";
1565                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1566                 RANK
1567         } elsif (lc($sort) eq 'title') {
1568                 $rank = <<"             RANK";
1569                         ( FIRST ((
1570                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
1571                                   FROM  $metabib_full_rec frt
1572                                   WHERE frt.record = mr.master_record
1573                                         AND frt.tag = '245'
1574                                         AND frt.subfield = 'a'
1575                                   LIMIT 1
1576                         )) )
1577                 RANK
1578                 $secondary_sort = <<"           SORT";
1579                         ( FIRST ((
1580                                 SELECT  COALESCE(SUBSTRING(sfrp.value FROM '\\\\d+'),'9999')::INT
1581                                   FROM  $metabib_full_rec sfrp
1582                                   WHERE sfrp.record = mr.master_record
1583                                         AND sfrp.tag = '260'
1584                                         AND sfrp.subfield = 'c'
1585                                   LIMIT 1
1586                         )) )
1587                 SORT
1588         } elsif (lc($sort) eq 'author') {
1589                 $rank = <<"             RANK";
1590                         ( FIRST((
1591                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
1592                                   FROM  $metabib_full_rec fra
1593                                   WHERE fra.record = mr.master_record
1594                                         AND fra.tag LIKE '1%'
1595                                         AND fra.subfield = 'a'
1596                                   ORDER BY fra.tag::text::int
1597                                   LIMIT 1
1598                         )) )
1599                 RANK
1600         } else {
1601                 push @bonus_values, @bonus_values;
1602                 $sort = undef;
1603         }
1604
1605
1606         my $select = <<"        SQL";
1607                 SELECT  m.metarecord,
1608                         $relevance,
1609                         CASE WHEN COUNT(DISTINCT smrs.source) = 1 THEN FIRST(m.source) ELSE 0 END,
1610                         $rank,
1611                         $secondary_sort
1612                 FROM    $search_table_list
1613                         $metabib_metarecord mr,
1614                         $metabib_metarecord_source_map_table m,
1615                         $metabib_metarecord_source_map_table smrs
1616                 WHERE   m.metarecord = smrs.metarecord
1617                         AND mr.id = m.metarecord
1618                         $fts_list
1619                         $join_table_list
1620                 GROUP BY m.metarecord
1621                 -- ORDER BY 4 $sort_dir
1622                 LIMIT $visiblity_limit
1623         SQL
1624
1625         if ($self->api_name !~ /staff/o) {
1626                 $select = <<"           SQL";
1627
1628                         SELECT  s.*
1629                           FROM  ($select) s
1630                           WHERE EXISTS (
1631                                 SELECT  1
1632                                   FROM  $asset_call_number_table cn,
1633                                         $metabib_metarecord_source_map_table mrs,
1634                                         $asset_copy_table cp,
1635                                         $cs_table cs,
1636                                         $cl_table cl,
1637                                         $br_table br,
1638                                         $descendants d,
1639                                         $metabib_record_descriptor ord
1640                                   WHERE mrs.metarecord = s.metarecord
1641                                         AND br.id = mrs.source
1642                                         AND cn.record = mrs.source
1643                                         AND cp.status = cs.id
1644                                         AND cp.location = cl.id
1645                                         AND cn.owning_lib = d.id
1646                                         AND cp.call_number = cn.id
1647                                         AND cp.opac_visible IS TRUE
1648                                         AND cs.holdable IS TRUE
1649                                         AND cl.opac_visible IS TRUE
1650                                         AND br.active IS TRUE
1651                                         AND br.deleted IS FALSE
1652                                         AND cp.deleted IS FALSE
1653                                         AND cn.deleted IS FALSE
1654                                         AND ord.record = mrs.source
1655                                         $ot_filter
1656                                         $of_filter
1657                                         $oa_filter
1658                                         $ol_filter
1659                                         $olf_filter
1660                                   LIMIT 1
1661                                 )
1662                           ORDER BY 4 $sort_dir, 5
1663                 SQL
1664         } else {
1665                 $select = <<"           SQL";
1666
1667                         SELECT  DISTINCT s.*
1668                           FROM  ($select) s,
1669                                 $metabib_metarecord_source_map_table omrs,
1670                                 $metabib_record_descriptor ord
1671                           WHERE omrs.metarecord = s.metarecord
1672                                 AND ord.record = omrs.source
1673                                 AND (   EXISTS (
1674                                                 SELECT  1
1675                                                   FROM  $asset_call_number_table cn,
1676                                                         $descendants d,
1677                                                         $br_table br
1678                                                   WHERE br.id = omrs.source
1679                                                         AND cn.record = omrs.source
1680                                                         AND cn.owning_lib = d.id
1681                                                         AND br.deleted IS FALSE
1682                                                         AND cn.deleted IS FALSE
1683                                                   LIMIT 1
1684                                         )
1685                                         OR NOT EXISTS (
1686                                                 SELECT  1
1687                                                   FROM  $asset_call_number_table cn
1688                                                   WHERE cn.record = omrs.source
1689                                                         AND cn.deleted IS FALSE
1690                                                   LIMIT 1
1691                                         )
1692                                 )
1693                                 $ot_filter
1694                                 $of_filter
1695                                 $oa_filter
1696                                 $ol_filter
1697                                 $olf_filter
1698
1699                           ORDER BY 4 $sort_dir, 5
1700                 SQL
1701         }
1702
1703
1704         $log->debug("Field Search SQL :: [$select]",DEBUG);
1705
1706         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
1707                         $select, {},
1708                         @bonus_values,
1709                         @types, @forms, @aud, @lang, @lit_form,
1710                         # @types, @forms, @aud, @lang, @lit_form,
1711                         # ($self->api_name =~ /staff/o ? (@types, @forms, @aud, @lang, @lit_form) : () )
1712         );
1713
1714         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1715
1716         my $max = 0;
1717         $max = 1 if (!@$recs);
1718         for (@$recs) {
1719                 $max = $$_[1] if ($$_[1] > $max);
1720         }
1721
1722         my $count = scalar(@$recs);
1723         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1724                 next unless ($$rec[0]);
1725                 my ($mrid,$rank,$skip) = @$rec;
1726                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $skip, $count] );
1727         }
1728         return undef;
1729 }
1730
1731 __PACKAGE__->register_method(
1732         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord",
1733         method          => 'postfilter_search_multi_class_fts',
1734         api_level       => 1,
1735         stream          => 1,
1736         cachable        => 1,
1737 );
1738 __PACKAGE__->register_method(
1739         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord.staff",
1740         method          => 'postfilter_search_multi_class_fts',
1741         api_level       => 1,
1742         stream          => 1,
1743         cachable        => 1,
1744 );
1745
1746 __PACKAGE__->register_method(
1747         api_name        => "open-ils.storage.metabib.multiclass.search_fts",
1748         method          => 'postfilter_search_multi_class_fts',
1749         api_level       => 1,
1750         stream          => 1,
1751         cachable        => 1,
1752 );
1753 __PACKAGE__->register_method(
1754         api_name        => "open-ils.storage.metabib.multiclass.search_fts.staff",
1755         method          => 'postfilter_search_multi_class_fts',
1756         api_level       => 1,
1757         stream          => 1,
1758         cachable        => 1,
1759 );
1760
1761 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1762 sub biblio_search_multi_class_fts {
1763         my $self = shift;
1764         my $client = shift;
1765         my %args = @_;
1766
1767         my $sort = $args{'sort'};
1768         my $sort_dir = $args{sort_dir} || 'DESC';
1769         my $ou = $args{org_unit};
1770         my $ou_type = $args{depth};
1771         my $limit = $args{limit} || 10;
1772         my $visiblity_limit = $args{visiblity_limit} || 5000;
1773         my $offset = $args{offset} || 0;
1774
1775         if (!$ou) {
1776                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
1777         }
1778
1779         if (!defined($args{org_unit})) {
1780                 die "No target organizational unit passed to ".$self->api_name;
1781         }
1782
1783         if (! scalar( keys %{$args{searches}} )) {
1784                 die "No search arguments were passed to ".$self->api_name;
1785         }
1786
1787         my $outer_limit = 1000;
1788
1789         my $limit_clause = '';
1790         my $offset_clause = '';
1791
1792         $limit_clause = "LIMIT $outer_limit";
1793         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1794
1795         my (@types,@forms,@lang,@aud,@lit_form);
1796         my ($t_filter, $f_filter) = ('','');
1797         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1798         my ($ot_filter, $of_filter) = ('','');
1799         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1800
1801         if (my $a = $args{audience}) {
1802                 $a = [$a] if (!ref($a));
1803                 @aud = @$a;
1804
1805                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1806                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1807         }
1808
1809         if (my $l = $args{language}) {
1810                 $l = [$l] if (!ref($l));
1811                 @lang = @$l;
1812
1813                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1814                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1815         }
1816
1817         if (my $f = $args{lit_form}) {
1818                 $f = [$f] if (!ref($f));
1819                 @lit_form = @$f;
1820
1821                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1822                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1823         }
1824
1825         if (my $f = $args{item_form}) {
1826                 $f = [$f] if (!ref($f));
1827                 @forms = @$f;
1828
1829                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1830                 $of_filter = ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1831         }
1832
1833         if (my $t = $args{item_type}) {
1834                 $t = [$t] if (!ref($t));
1835                 @types = @$t;
1836
1837                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1838                 $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1839         }
1840
1841
1842         # XXX legacy format and item type support
1843         if ($args{format}) {
1844                 my ($t, $f) = split '-', $args{format};
1845                 @types = split '', $t;
1846                 @forms = split '', $f;
1847                 if (@types) {
1848                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1849                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1850                 }
1851
1852                 if (@forms) {
1853                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1854                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1855                 }
1856         }
1857
1858
1859         my $descendants = defined($ou_type) ?
1860                                 "actor.org_unit_descendants($ou, $ou_type)" :
1861                                 "actor.org_unit_descendants($ou)";
1862
1863         my $search_table_list = '';
1864         my $fts_list = '';
1865         my $join_table_list = '';
1866         my @rank_list;
1867
1868
1869         my @bonus_lists;
1870         my @bonus_values;
1871         my $prev_search_class;
1872         my $curr_search_class;
1873         for my $search_class (sort keys %{$args{searches}}) {
1874                 $prev_search_class = $curr_search_class if ($curr_search_class);
1875
1876                 $curr_search_class = $search_class;
1877
1878                 my $class = $_cdbi->{$search_class};
1879                 my $search_table = $class->table;
1880
1881                 my ($index_col) = $class->columns('FTS');
1882                 $index_col ||= 'value';
1883
1884
1885                 my $fts = OpenILS::Application::Storage::FTS->compile($args{searches}{$search_class}{term}, $search_class.'.value', "$search_class.$index_col");
1886
1887                 my $fts_where = $fts->sql_where_clause;
1888                 my @fts_ranks = $fts->fts_rank;
1889
1890                 my $SQLstring = join('%',map { lc($_) } $fts->words);
1891                 my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1892                 my $first_word = lc(($fts->words)[0]).'%';
1893
1894                 my $rank = join(' + ', @fts_ranks);
1895
1896                 my %bonus = ();
1897                 $bonus{'keyword'} = [ { "CASE WHEN $search_class.value ILIKE ? THEN 1.2 ELSE 1 END" => $SQLstring } ];
1898
1899                 $bonus{'series'} = [
1900                         { "CASE WHEN $search_class.value ILIKE ? THEN 1.5 ELSE 1 END" => $first_word },
1901                         { "CASE WHEN $search_class.value ~ ? THEN 200 ELSE 1 END" => $REstring },
1902                 ];
1903
1904                 $bonus{'title'} = [ @{ $bonus{'series'} }, @{ $bonus{'keyword'} } ];
1905
1906                 my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$search_class} };
1907                 $bonus_list ||= '1';
1908
1909                 push @bonus_lists, $bonus_list;
1910                 push @bonus_values, map { values %$_ } @{ $bonus{$search_class} };
1911
1912                 #---------------------
1913
1914                 $search_table_list .= "$search_table $search_class, ";
1915                 push @rank_list,$rank;
1916                 $fts_list .= " AND $fts_where AND b.id = $search_class.source";
1917
1918                 if ($prev_search_class) {
1919                         $join_table_list .= " AND $prev_search_class.source = $curr_search_class.source";
1920                 }
1921         }
1922
1923         my $metabib_record_descriptor = metabib::record_descriptor->table;
1924         my $metabib_full_rec = metabib::full_rec->table;
1925         my $metabib_metarecord = metabib::metarecord->table;
1926         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1927         my $asset_call_number_table = asset::call_number->table;
1928         my $asset_copy_table = asset::copy->table;
1929         my $cs_table = config::copy_status->table;
1930         my $cl_table = asset::copy_location->table;
1931         my $br_table = biblio::record_entry->table;
1932
1933
1934         my $bonuses = join (' * ', @bonus_lists);
1935         my $relevance = join (' + ', @rank_list);
1936         $relevance = "AVG( ($relevance) * ($bonuses) )";
1937
1938
1939         my $rank = $relevance;
1940         if (lc($sort) eq 'pubdate') {
1941                 $rank = <<"             RANK";
1942                         ( FIRST ((
1943                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d{4}'),'9999')::INT
1944                                   FROM  $metabib_full_rec frp
1945                                   WHERE frp.record = b.id
1946                                         AND frp.tag = '260'
1947                                         AND frp.subfield = 'c'
1948                                   LIMIT 1
1949                         )) )
1950                 RANK
1951         } elsif (lc($sort) eq 'create_date') {
1952                 $rank = <<"             RANK";
1953                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = b.id)) )
1954                 RANK
1955         } elsif (lc($sort) eq 'edit_date') {
1956                 $rank = <<"             RANK";
1957                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = b.id)) )
1958                 RANK
1959         } elsif (lc($sort) eq 'title') {
1960                 $rank = <<"             RANK";
1961                         ( FIRST ((
1962                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT )),'zzzzzzzz')
1963                                   FROM  $metabib_full_rec frt
1964                                   WHERE frt.record = b.id
1965                                         AND frt.tag = '245'
1966                                         AND frt.subfield = 'a'
1967                                   LIMIT 1
1968                         )) )
1969                 RANK
1970         } elsif (lc($sort) eq 'author') {
1971                 $rank = <<"             RANK";
1972                         ( FIRST((
1973                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
1974                                   FROM  $metabib_full_rec fra
1975                                   WHERE fra.record = b.id
1976                                         AND fra.tag LIKE '1%'
1977                                         AND fra.subfield = 'a'
1978                                   ORDER BY fra.tag::text::int
1979                                   LIMIT 1
1980                         )) )
1981                 RANK
1982         } else {
1983                 push @bonus_values, @bonus_values;
1984                 $sort = undef;
1985         }
1986
1987
1988         my $select = <<"        SQL";
1989                 SELECT  b.id,
1990                         $relevance AS rel,
1991                         $rank AS rank
1992                 FROM    $search_table_list
1993                         $metabib_record_descriptor rd,
1994                         $br_table b
1995                 WHERE   rd.record = b.id
1996                         AND b.active IS TRUE
1997                         AND b.deleted IS FALSE
1998                         $fts_list
1999                         $join_table_list
2000                         $t_filter
2001                         $f_filter
2002                         $a_filter
2003                         $l_filter
2004                         $lf_filter
2005                 GROUP BY b.id
2006                 ORDER BY 3 $sort_dir
2007                 LIMIT $visiblity_limit
2008         SQL
2009
2010         if ($self->api_name !~ /staff/o) {
2011                 $select = <<"           SQL";
2012
2013                         SELECT  s.*
2014                           FROM  ($select) s
2015                           WHERE EXISTS (
2016                                 SELECT  1
2017                                   FROM  $asset_call_number_table cn,
2018                                         $asset_copy_table cp,
2019                                         $cs_table cs,
2020                                         $cl_table cl,
2021                                         $descendants d
2022                                   WHERE cn.record = s.id
2023                                         AND cp.status = cs.id
2024                                         AND cp.location = cl.id
2025                                         AND cn.owning_lib = d.id
2026                                         AND cp.call_number = cn.id
2027                                         AND cp.opac_visible IS TRUE
2028                                         AND cs.holdable IS TRUE
2029                                         AND cl.opac_visible IS TRUE
2030                                         AND cp.deleted IS FALSE
2031                                         AND cn.deleted IS FALSE
2032                                   LIMIT 1
2033                                 )
2034                           ORDER BY 3 $sort_dir
2035                 SQL
2036         } else {
2037                 $select = <<"           SQL";
2038
2039                         SELECT  s.*
2040                           FROM  ($select) s
2041                           WHERE EXISTS (
2042                                 SELECT  1
2043                                   FROM  $asset_call_number_table cn,
2044                                         $descendants d
2045                                   WHERE cn.record = s.id
2046                                         AND cn.owning_lib = d.id
2047                                         AND cn.deleted IS FALSE
2048                                   LIMIT 1
2049                                 )
2050                                 OR NOT EXISTS (
2051                                 SELECT  1
2052                                   FROM  $asset_call_number_table cn
2053                                   WHERE cn.record = s.id
2054                                   LIMIT 1
2055                                 )
2056                           ORDER BY 3 $sort_dir
2057                 SQL
2058         }
2059
2060
2061         $log->debug("Field Search SQL :: [$select]",DEBUG);
2062
2063         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
2064                         $select, {},
2065                         @bonus_values, @types, @forms, @aud, @lang, @lit_form
2066         );
2067
2068         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
2069
2070         my $max = 0;
2071         $max = 1 if (!@$recs);
2072         for (@$recs) {
2073                 $max = $$_[1] if ($$_[1] > $max);
2074         }
2075
2076         my $count = scalar(@$recs);
2077         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
2078                 next unless ($$rec[0]);
2079                 my ($mrid,$rank) = @$rec;
2080                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $count] );
2081         }
2082         return undef;
2083 }
2084
2085 __PACKAGE__->register_method(
2086         api_name        => "open-ils.storage.biblio.multiclass.search_fts.record",
2087         method          => 'biblio_search_multi_class_fts',
2088         api_level       => 1,
2089         stream          => 1,
2090         cachable        => 1,
2091 );
2092 __PACKAGE__->register_method(
2093         api_name        => "open-ils.storage.biblio.multiclass.search_fts.record.staff",
2094         method          => 'biblio_search_multi_class_fts',
2095         api_level       => 1,
2096         stream          => 1,
2097         cachable        => 1,
2098 );
2099
2100
2101
2102 __PACKAGE__->register_method(
2103         api_name        => "open-ils.storage.biblio.multiclass.search_fts",
2104         method          => 'biblio_search_multi_class_fts',
2105         api_level       => 1,
2106         stream          => 1,
2107         cachable        => 1,
2108 );
2109 __PACKAGE__->register_method(
2110         api_name        => "open-ils.storage.biblio.multiclass.search_fts.staff",
2111         method          => 'biblio_search_multi_class_fts',
2112         api_level       => 1,
2113         stream          => 1,
2114         cachable        => 1,
2115 );
2116
2117
2118 1;
2119