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 # need to order record IDs by:
  18 #  1) format - text, movie, sound, software, images, maps, mixed, music, 3d
  19 #  2) proximity --- XXX Can't do it cheap...
  20 #  3) count
  21 sub ordered_records_from_metarecord {
  22         my $self = shift;
  23         my $client = shift;
  24         my $mr = shift;
  25         my $formats = shift;
  26
  27         my (@types,@forms);
  28
  29         if ($formats) {
  30                 my ($t, $f) = split '-', $formats;
  31                 @types = split '', $t;
  32                 @forms = split '', $f;
  33         }
  34
  35         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
  36         $copies_visible = '' if ($self->api_name =~ /staff/o);
  37
  38         my $sm_table = metabib::metarecord_source_map->table;
  39         my $rd_table = metabib::record_descriptor->table;
  40         my $cn_table = asset::call_number->table;
  41         my $cl_table = asset::copy_location->table;
  42         my $cp_table = asset::copy->table;
  43         my $cs_table = config::copy_status->table;
  44         my $out_table = actor::org_unit_type->table;
  45
  46         my $sql = <<"   SQL";
  47          SELECT *
  48            FROM (
  49                 SELECT  rd.record,
  50                         rd.item_type,
  51                         rd.item_form,
  52         SQL
  53
  54         if ($copies_visible) {
  55                 $sql .= <<"             SQL";
  56                         sum((SELECT     count(cp.id)
  57                                FROM     $cp_table cp
  58                                         JOIN $cs_table cs ON (cp.status = cs.id)
  59                                         JOIN $cl_table cl ON (cp.location = cl.id)
  60                                WHERE    cn.id = cp.call_number
  61                                         $copies_visible
  62                           )) AS count
  63                 SQL
  64         } else {
  65                 $sql .= '0 AS count';
  66         }
  67
  68         if ($copies_visible) {
  69                 $sql .= <<"             SQL";
  70                   FROM  $cn_table cn,
  71                         $sm_table sm,
  72                         $rd_table rd
  73                   WHERE rd.record = sm.source
  74                         AND cn.record = rd.record
  75                         AND sm.metarecord = ?
  76                 SQL
  77         } else {
  78                 $sql .= <<"             SQL";
  79                   FROM  $sm_table sm,
  80                         $rd_table rd
  81                   WHERE rd.record = sm.source
  82                         AND sm.metarecord = ?
  83                 SQL
  84         }
  85
  86         $sql .= <<"     SQL";
  87                   GROUP BY rd.record, rd.item_type, rd.item_form
  88                   ORDER BY
  89                         CASE
  90                                 WHEN rd.item_type IS NULL -- default
  91                                         THEN 0
  92                                 WHEN rd.item_type = '' -- default
  93                                         THEN 0
  94                                 WHEN rd.item_type IN ('a','t') -- books
  95                                         THEN 1
  96                                 WHEN rd.item_type = 'g' -- movies
  97                                         THEN 2
  98                                 WHEN rd.item_type IN ('i','j') -- sound recordings
  99                                         THEN 3
 100                                 WHEN rd.item_type = 'm' -- software
 101                                         THEN 4
 102                                 WHEN rd.item_type = 'k' -- images
 103                                         THEN 5
 104                                 WHEN rd.item_type IN ('e','f') -- maps
 105                                         THEN 6
 106                                 WHEN rd.item_type IN ('o','p') -- mixed
 107                                         THEN 7
 108                                 WHEN rd.item_type IN ('c','d') -- music
 109                                         THEN 8
 110                                 WHEN rd.item_type = 'r' -- 3d
 111                                         THEN 9
 112                         END,
 113                         count DESC
 114                 ) x
 115         SQL
 116
 117         if ($copies_visible) {
 118                 $sql .= ' WHERE x.count > 0'
 119         }
 120
 121         if (@types) {
 122                 $sql .= ' AND x.item_type IN ('.join(',',map{'?'}@types).')';
 123         }
 124
 125         if (@forms) {
 126                 $sql .= ' AND x.item_form IN ('.join(',',map{'?'}@forms).')';
 127         }
 128
 129         my $sth = metabib::metarecord_source_map->db_Main->prepare_cached($sql);
 130         $sth->execute("$mr", @types, @forms);
 131         while ( my $row = $sth->fetchrow_arrayref ) {
 132                 $client->respond( $$row[0] );
 133         }
 134         return undef;
 135
 136 }
 137 __PACKAGE__->register_method(
 138         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records',
 139         method          => 'ordered_records_from_metarecord',
 140         api_level       => 1,
 141         stream          => 1,
 142         cachable        => 1,
 143 );
 144 __PACKAGE__->register_method(
 145         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.staff',
 146         method          => 'ordered_records_from_metarecord',
 147         api_level       => 1,
 148         stream          => 1,
 149         cachable        => 1,
 150 );
 151
 152
 153 sub metarecord_copy_count {
 154         my $self = shift;
 155         my $client = shift;
 156
 157         my %args = @_;
 158
 159         my $sm_table = metabib::metarecord_source_map->table;
 160         my $cn_table = asset::call_number->table;
 161         my $cp_table = asset::copy->table;
 162         my $cl_table = asset::copy_location->table;
 163         my $cs_table = config::copy_status->table;
 164         my $out_table = actor::org_unit_type->table;
 165         my $descendants = "actor.org_unit_descendants(u.id)";
 166         my $ancestors = "actor.org_unit_ancestors(?)";
 167
 168         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
 169         $copies_visible = '' if ($self->api_name =~ /staff/o);
 170
 171         my $sql = <<"   SQL";
 172                 SELECT  t.depth,
 173                         u.id AS org_unit,
 174                         sum(
 175                                 (SELECT count(cp.id)
 176                                   FROM  $sm_table r
 177                                         JOIN $cn_table cn ON (cn.record = r.source)
 178                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 179                                         JOIN $cs_table cs ON (cp.status = cs.id)
 180                                         JOIN $cl_table cl ON (cp.location = cl.id)
 181                                         JOIN $descendants a ON (cp.circ_lib = a.id)
 182                                   WHERE r.metarecord = ?
 183                                         $copies_visible
 184                                 )
 185                         ) AS count,
 186                         sum(
 187                                 (SELECT count(cp.id)
 188                                   FROM  $sm_table r
 189                                         JOIN $cn_table cn ON (cn.record = r.source)
 190                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 191                                         JOIN $cs_table cs ON (cp.status = cs.id)
 192                                         JOIN $cl_table cl ON (cp.location = cl.id)
 193                                         JOIN $descendants a ON (cp.circ_lib = a.id)
 194                                   WHERE r.metarecord = ?
 195                                         AND cp.status = 0
 196                                         $copies_visible
 197                                 )
 198                         ) AS available
 199
 200                   FROM  $ancestors u
 201                         JOIN $out_table t ON (u.ou_type = t.id)
 202                   GROUP BY 1,2
 203         SQL
 204
 205         my $sth = metabib::metarecord_source_map->db_Main->prepare_cached($sql);
 206         $sth->execute(''.$args{metarecord}, ''.$args{metarecord}, ''.$args{org_unit});
 207         while ( my $row = $sth->fetchrow_hashref ) {
 208                 $client->respond( $row );
 209         }
 210         return undef;
 211 }
 212 __PACKAGE__->register_method(
 213         api_name        => 'open-ils.storage.metabib.metarecord.copy_count',
 214         method          => 'metarecord_copy_count',
 215         api_level       => 1,
 216         stream          => 1,
 217         cachable        => 1,
 218 );
 219 __PACKAGE__->register_method(
 220         api_name        => 'open-ils.storage.metabib.metarecord.copy_count.staff',
 221         method          => 'metarecord_copy_count',
 222         api_level       => 1,
 223         stream          => 1,
 224         cachable        => 1,
 225 );
 226
 227 sub search_full_rec {
 228         my $self = shift;
 229         my $client = shift;
 230
 231         my %args = @_;
 232
 233         my $term = $args{term};
 234         my $limiters = $args{restrict};
 235
 236         my ($index_col) = metabib::full_rec->columns('FTS');
 237         $index_col ||= 'value';
 238         my $search_table = metabib::full_rec->table;
 239
 240         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
 241
 242         my $fts_where = $fts->sql_where_clause();
 243         my @fts_ranks = $fts->fts_rank;
 244
 245         my $rank = join(' + ', @fts_ranks);
 246
 247         my @binds;
 248         my @wheres;
 249         for my $limit (@$limiters) {
 250                 push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
 251                 push @binds, $$limit{tag}, $$limit{subfield};
 252                 $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
 253         }
 254         my $where = join(' OR ', @wheres);
 255
 256         my $select = "SELECT record, sum($rank) FROM $search_table WHERE $where GROUP BY 1 ORDER BY 2 DESC;";
 257
 258         $log->debug("Search SQL :: [$select]",DEBUG);
 259
 260         my $recs = metabib::full_rec->db_Main->selectall_arrayref($select, {}, @binds);
 261         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 262
 263         $client->respond($_) for (@$recs);
 264         return undef;
 265 }
 266 __PACKAGE__->register_method(
 267         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.value',
 268         method          => 'search_full_rec',
 269         api_level       => 1,
 270         stream          => 1,
 271         cachable        => 1,
 272 );
 273 __PACKAGE__->register_method(
 274         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.index_vector',
 275         method          => 'search_full_rec',
 276         api_level       => 1,
 277         stream          => 1,
 278         cachable        => 1,
 279 );
 280
 281
 282 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 283 sub search_class_fts {
 284         my $self = shift;
 285         my $client = shift;
 286         my %args = @_;
 287
 288         my $term = $args{term};
 289         my $ou = $args{org_unit};
 290         my $ou_type = $args{depth};
 291         my $limit = $args{limit};
 292         my $offset = $args{offset};
 293
 294         my $limit_clause = '';
 295         my $offset_clause = '';
 296
 297         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
 298         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
 299
 300         my (@types,@forms);
 301         my ($t_filter, $f_filter) = ('','');
 302
 303         if ($args{format}) {
 304                 my ($t, $f) = split '-', $args{format};
 305                 @types = split '', $t;
 306                 @forms = split '', $f;
 307                 if (@types) {
 308                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 309                 }
 310
 311                 if (@forms) {
 312                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 313                 }
 314         }
 315
 316
 317
 318         my $descendants = defined($ou_type) ?
 319                                 "actor.org_unit_descendants($ou, $ou_type)" :
 320                                 "actor.org_unit_descendants($ou)";
 321
 322         my $class = $self->{cdbi};
 323         my $search_table = $class->table;
 324
 325         my $metabib_record_descriptor = metabib::record_descriptor->table;
 326         my $metabib_metarecord = metabib::metarecord->table;
 327         my $metabib_full_rec = metabib::full_rec->table;
 328         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
 329         my $asset_call_number_table = asset::call_number->table;
 330         my $asset_copy_table = asset::copy->table;
 331         my $cs_table = config::copy_status->table;
 332         my $cl_table = asset::copy_location->table;
 333
 334         my ($index_col) = $class->columns('FTS');
 335         $index_col ||= 'value';
 336
 337         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
 338
 339         my $fts_where = $fts->sql_where_clause;
 340         my @fts_ranks = $fts->fts_rank;
 341
 342         my $rank = join(' + ', @fts_ranks);
 343
 344         my $has_vols = 'AND cn.owning_lib = d.id';
 345         my $has_copies = 'AND cp.call_number = cn.id';
 346         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
 347
 348         my $visible_count = ', count(DISTINCT cp.id)';
 349         my $visible_count_test = 'HAVING count(DISTINCT cp.id) > 0';
 350
 351         if ($self->api_name =~ /staff/o) {
 352                 $copies_visible = '';
 353                 $visible_count_test = '';
 354                 $has_copies = '' if ($ou_type == 0);
 355                 $has_vols = '' if ($ou_type == 0);
 356         }
 357
 358         my $rank_calc = <<"     RANK";
 359                 , (SUM( $rank
 360                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
 361                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
 362                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
 363                 )/COUNT(m.source)), MIN(COALESCE(CHAR_LENGTH(f.value),1))
 364         RANK
 365
 366         $rank_calc = ',1 , 1' if ($self->api_name =~ /unordered/o);
 367
 368         if ($copies_visible) {
 369                 $select = <<"           SQL";
 370                         SELECT  m.metarecord $rank_calc $visible_count, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
 371                         FROM    $search_table f,
 372                                 $metabib_metarecord_source_map_table m,
 373                                 $asset_call_number_table cn,
 374                                 $asset_copy_table cp,
 375                                 $cs_table cs,
 376                                 $cl_table cl,
 377                                 $metabib_record_descriptor rd,
 378                                 $descendants d
 379                         WHERE   $fts_where
 380                                 AND m.source = f.source
 381                                 AND cn.record = m.source
 382                                 AND rd.record = m.source
 383                                 AND cp.status = cs.id
 384                                 AND cp.location = cl.id
 385                                 $has_vols
 386                                 $has_copies
 387                                 $copies_visible
 388                                 $t_filter
 389                                 $f_filter
 390                         GROUP BY 1 $visible_count_test
 391                         ORDER BY 2 DESC,3
 392                         $limit_clause $offset_clause
 393                 SQL
 394         } else {
 395                 $select = <<"           SQL";
 396                         SELECT  m.metarecord $rank_calc, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
 397                         FROM    $search_table f,
 398                                 $metabib_metarecord_source_map_table m,
 399                                 $metabib_record_descriptor rd
 400                         WHERE   $fts_where
 401                                 AND m.source = f.source
 402                                 AND rd.record = m.source
 403                                 $t_filter
 404                                 $f_filter
 405                         GROUP BY 1, 4
 406                         ORDER BY 2 DESC,3
 407                         $limit_clause $offset_clause
 408                 SQL
 409         }
 410
 411         $log->debug("Field Search SQL :: [$select]",DEBUG);
 412
 413         my $SQLstring = join('%',$fts->words);
 414         my $REstring = join('\\s+',$fts->words);
 415         my $first_word = ($fts->words)[0].'%';
 416         my $recs = ($self->api_name =~ /unordered/o) ?
 417                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
 418                         $class->db_Main->selectall_arrayref($select, {},
 419                                 '%'.lc($SQLstring).'%',                 # phrase order match
 420                                 lc($first_word),                        # first word match
 421                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
 422                                 @types, @forms
 423                         );
 424
 425         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 426
 427         $client->respond($_) for (map { [@$_[0,1,3,4]] } @$recs);
 428         return undef;
 429 }
 430
 431 for my $class ( qw/title author subject keyword series/ ) {
 432         __PACKAGE__->register_method(
 433                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord",
 434                 method          => 'search_class_fts',
 435                 api_level       => 1,
 436                 stream          => 1,
 437                 cdbi            => "metabib::${class}_field_entry",
 438                 cachable        => 1,
 439         );
 440         __PACKAGE__->register_method(
 441                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.unordered",
 442                 method          => 'search_class_fts',
 443                 api_level       => 1,
 444                 stream          => 1,
 445                 cdbi            => "metabib::${class}_field_entry",
 446                 cachable        => 1,
 447         );
 448         __PACKAGE__->register_method(
 449                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff",
 450                 method          => 'search_class_fts',
 451                 api_level       => 1,
 452                 stream          => 1,
 453                 cdbi            => "metabib::${class}_field_entry",
 454                 cachable        => 1,
 455         );
 456         __PACKAGE__->register_method(
 457                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff.unordered",
 458                 method          => 'search_class_fts',
 459                 api_level       => 1,
 460                 stream          => 1,
 461                 cdbi            => "metabib::${class}_field_entry",
 462                 cachable        => 1,
 463         );
 464 }
 465
 466 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 467 sub search_class_fts_count {
 468         my $self = shift;
 469         my $client = shift;
 470         my %args = @_;
 471
 472         my $term = $args{term};
 473         my $ou = $args{org_unit};
 474         my $ou_type = $args{depth};
 475         my $limit = $args{limit} || 100;
 476         my $offset = $args{offset} || 0;
 477
 478         my $descendants = defined($ou_type) ?
 479                                 "actor.org_unit_descendants($ou, $ou_type)" :
 480                                 "actor.org_unit_descendants($ou)";
 481
 482         my (@types,@forms);
 483         my ($t_filter, $f_filter) = ('','');
 484
 485         if ($args{format}) {
 486                 my ($t, $f) = split '-', $args{format};
 487                 @types = split '', $t;
 488                 @forms = split '', $f;
 489                 if (@types) {
 490                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 491                 }
 492
 493                 if (@forms) {
 494                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 495                 }
 496         }
 497
 498
 499         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
 500
 501         my $class = $self->{cdbi};
 502         my $search_table = $class->table;
 503
 504         my $metabib_record_descriptor = metabib::record_descriptor->table;
 505         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
 506         my $asset_call_number_table = asset::call_number->table;
 507         my $asset_copy_table = asset::copy->table;
 508         my $cs_table = config::copy_status->table;
 509         my $cl_table = asset::copy_location->table;
 510
 511         my ($index_col) = $class->columns('FTS');
 512         $index_col ||= 'value';
 513
 514         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
 515
 516         my $fts_where = $fts->sql_where_clause;
 517
 518         my $has_vols = 'AND cn.owning_lib = d.id';
 519         my $has_copies = 'AND cp.call_number = cn.id';
 520         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
 521         if ($self->api_name =~ /staff/o) {
 522                 $copies_visible = '';
 523                 $has_vols = '' if ($ou_type == 0);
 524                 $has_copies = '' if ($ou_type == 0);
 525         }
 526
 527         # XXX test an "EXISTS version of descendant checking...
 528         my $select;
 529         if ($copies_visible) {
 530                 $select = <<"           SQL";
 531                 SELECT  count(distinct  m.metarecord)
 532                   FROM  $search_table f,
 533                         $metabib_metarecord_source_map_table m,
 534                         $asset_call_number_table cn,
 535                         $asset_copy_table cp,
 536                         $cs_table cs,
 537                         $cl_table cl,
 538                         $metabib_record_descriptor rd,
 539                         $descendants d
 540                   WHERE $fts_where
 541                         AND m.source = f.source
 542                         AND cn.record = m.source
 543                         AND rd.record = m.source
 544                         AND cp.status = cs.id
 545                         AND cp.location = cl.id
 546                         $has_vols
 547                         $has_copies
 548                         $copies_visible
 549                         $t_filter
 550                         $f_filter
 551                 SQL
 552         } else {
 553                 $select = <<"           SQL";
 554                 SELECT  count(distinct  m.metarecord)
 555                   FROM  $search_table f,
 556                         $metabib_metarecord_source_map_table m,
 557                         $metabib_record_descriptor rd
 558                   WHERE $fts_where
 559                         AND m.source = f.source
 560                         AND rd.record = m.source
 561                         $t_filter
 562                         $f_filter
 563                 SQL
 564         }
 565
 566         $log->debug("Field Search Count SQL :: [$select]",DEBUG);
 567
 568         my $recs = $class->db_Main->selectrow_arrayref($select, {}, @types, @forms)->[0];
 569
 570         $log->debug("Count Search yielded $recs results.",DEBUG);
 571
 572         return $recs;
 573
 574 }
 575 for my $class ( qw/title author subject keyword series/ ) {
 576         __PACKAGE__->register_method(
 577                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count",
 578                 method          => 'search_class_fts_count',
 579                 api_level       => 1,
 580                 stream          => 1,
 581                 cdbi            => "metabib::${class}_field_entry",
 582                 cachable        => 1,
 583         );
 584         __PACKAGE__->register_method(
 585                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count.staff",
 586                 method          => 'search_class_fts_count',
 587                 api_level       => 1,
 588                 stream          => 1,
 589                 cdbi            => "metabib::${class}_field_entry",
 590                 cachable        => 1,
 591         );
 592 }
 593
 594
 595
 596
 597
 598 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 599 sub new_search_class_fts {
 600         my $self = shift;
 601         my $client = shift;
 602         my %args = @_;
 603
 604         my $term = $args{term};
 605         my $ou = $args{org_unit};
 606         my $ou_type = $args{depth};
 607         my $limit = $args{limit};
 608         my $offset = $args{offset} ||= 0;
 609
 610         my $limit_clause = '';
 611         my $offset_clause = '';
 612
 613         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
 614         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
 615
 616         my (@types,@forms);
 617         my ($t_filter, $f_filter) = ('','');
 618
 619         if ($args{format}) {
 620                 my ($t, $f) = split '-', $args{format};
 621                 @types = split '', $t;
 622                 @forms = split '', $f;
 623                 if (@types) {
 624                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 625                 }
 626
 627                 if (@forms) {
 628                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 629                 }
 630         }
 631
 632
 633
 634         my $descendants = defined($ou_type) ?
 635                                 "actor.org_unit_descendants($ou, $ou_type)" :
 636                                 "actor.org_unit_descendants($ou)";
 637
 638         my $class = $self->{cdbi};
 639         my $search_table = $class->table;
 640
 641         my $metabib_record_descriptor = metabib::record_descriptor->table;
 642         my $metabib_metarecord = metabib::metarecord->table;
 643         my $metabib_full_rec = metabib::full_rec->table;
 644         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
 645         my $asset_call_number_table = asset::call_number->table;
 646         my $asset_copy_table = asset::copy->table;
 647         my $cs_table = config::copy_status->table;
 648         my $cl_table = asset::copy_location->table;
 649
 650         my ($index_col) = $class->columns('FTS');
 651         $index_col ||= 'value';
 652
 653         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
 654
 655         my $fts_where = $fts->sql_where_clause;
 656         my @fts_ranks = $fts->fts_rank;
 657
 658         my $rank = join(' + ', @fts_ranks);
 659
 660         my $has_vols = 'AND cn.owning_lib = d.id';
 661         my $has_copies = 'AND cp.call_number = cn.id';
 662         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
 663
 664         my $visible_count = ', count(DISTINCT cp.id)';
 665         my $visible_count_test = 'HAVING count(DISTINCT cp.id) > 0';
 666
 667         if ($self->api_name =~ /staff/o) {
 668                 $copies_visible = '';
 669                 $visible_count_test = '';
 670                 $has_copies = '' if ($ou_type == 0);
 671                 $has_vols = '' if ($ou_type == 0);
 672         }
 673
 674         my $rank_calc = <<"     RANK";
 675                 , (SUM( $rank
 676                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
 677                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
 678                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
 679                 )/COUNT(m.source)), MIN(COALESCE(CHAR_LENGTH(f.value),1))
 680         RANK
 681
 682         $rank_calc = ',1 , 1' if ($self->api_name =~ /unordered/o);
 683
 684         if ($copies_visible) {
 685                 $select = <<"           SQL";
 686                         SELECT  m.metarecord $rank_calc $visible_count, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
 687                         FROM    $search_table f,
 688                                 $metabib_metarecord_source_map_table m,
 689                                 $asset_call_number_table cn,
 690                                 $asset_copy_table cp,
 691                                 $cs_table cs,
 692                                 $cl_table cl,
 693                                 $metabib_record_descriptor rd,
 694                                 $descendants d
 695                         WHERE   $fts_where
 696                                 AND m.source = f.source
 697                                 AND cn.record = m.source
 698                                 AND rd.record = m.source
 699                                 AND cp.status = cs.id
 700                                 AND cp.location = cl.id
 701                                 $has_vols
 702                                 $has_copies
 703                                 $copies_visible
 704                                 $t_filter
 705                                 $f_filter
 706                         GROUP BY m.metarecord $visible_count_test
 707                         ORDER BY 2 DESC,3
 708                 SQL
 709         } else {
 710                 $select = <<"           SQL";
 711                         SELECT  m.metarecord $rank_calc, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
 712                         FROM    $search_table f,
 713                                 $metabib_metarecord_source_map_table m,
 714                                 $metabib_record_descriptor rd
 715                         WHERE   $fts_where
 716                                 AND m.source = f.source
 717                                 AND rd.record = m.source
 718                                 $t_filter
 719                                 $f_filter
 720                         GROUP BY 1, 4
 721                         ORDER BY 2 DESC,3
 722                 SQL
 723         }
 724
 725         $log->debug("Field Search SQL :: [$select]",DEBUG);
 726
 727         my $SQLstring = join('%',$fts->words);
 728         my $REstring = join('\\s+',$fts->words);
 729         my $first_word = ($fts->words)[0].'%';
 730         my $recs = ($self->api_name =~ /unordered/o) ?
 731                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
 732                         $class->db_Main->selectall_arrayref($select, {},
 733                                 '%'.lc($SQLstring).'%',                 # phrase order match
 734                                 lc($first_word),                        # first word match
 735                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
 736                                 @types, @forms
 737                         );
 738
 739         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 740
 741         my $count = scalar(@$recs);
 742         $client->respond($_) for (map { [@$_[0,1,3],$count,$$_[4]] } @$recs[$offset .. $offset + $limit]);
 743         return undef;
 744 }
 745
 746 for my $class ( qw/title author subject keyword series/ ) {
 747         __PACKAGE__->register_method(
 748                 api_name        => "open-ils.storage.metabib.$class.new_search_fts.metarecord",
 749                 method          => 'new_search_class_fts',
 750                 api_level       => 1,
 751                 stream          => 1,
 752                 cdbi            => "metabib::${class}_field_entry",
 753                 cachable        => 1,
 754         );
 755         __PACKAGE__->register_method(
 756                 api_name        => "open-ils.storage.metabib.$class.new_search_fts.metarecord.unordered",
 757                 method          => 'new_search_class_fts',
 758                 api_level       => 1,
 759                 stream          => 1,
 760                 cdbi            => "metabib::${class}_field_entry",
 761                 cachable        => 1,
 762         );
 763         __PACKAGE__->register_method(
 764                 api_name        => "open-ils.storage.metabib.$class.new_search_fts.metarecord.staff",
 765                 method          => 'new_search_class_fts',
 766                 api_level       => 1,
 767                 stream          => 1,
 768                 cdbi            => "metabib::${class}_field_entry",
 769                 cachable        => 1,
 770         );
 771         __PACKAGE__->register_method(
 772                 api_name        => "open-ils.storage.metabib.$class.new_search_fts.metarecord.staff.unordered",
 773                 method          => 'new_search_class_fts',
 774                 api_level       => 1,
 775                 stream          => 1,
 776                 cdbi            => "metabib::${class}_field_entry",
 777                 cachable        => 1,
 778         );
 779 }
 780
 781
 782
 783
 784 1;