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

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