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