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';
  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 $cp_table = asset::copy->table;
  42         my $cs_table = config::copy_status->table;
  43         my $out_table = actor::org_unit_type->table;
  44
  45         my $sql = <<"   SQL";
  46          SELECT *
  47            FROM (
  48                 SELECT  rd.record,
  49                         rd.item_type,
  50                         rd.item_form,
  51         SQL
  52
  53         if ($copies_visible) {
  54                 $sql .= <<"             SQL";
  55                         sum((SELECT     count(cp.id)
  56                                FROM     $cp_table cp
  57                                         JOIN $cs_table cs ON (cp.status = cs.id)
  58                                WHERE    cn.id = cp.call_number
  59                                         $copies_visible
  60                           )) AS count
  61                 SQL
  62         } else {
  63                 $sql .= '0 AS count';
  64         }
  65
  66         if ($copies_visible) {
  67                 $sql .= <<"             SQL";
  68                   FROM  $cn_table cn,
  69                         $sm_table sm,
  70                         $rd_table rd
  71                   WHERE rd.record = sm.source
  72                         AND cn.record = rd.record
  73                         AND sm.metarecord = ?
  74                 SQL
  75         } else {
  76                 $sql .= <<"             SQL";
  77                   FROM  $sm_table sm,
  78                         $rd_table rd
  79                   WHERE rd.record = sm.source
  80                         AND sm.metarecord = ?
  81                 SQL
  82         }
  83
  84         $sql .= <<"     SQL";
  85                   GROUP BY rd.record, rd.item_type, rd.item_form
  86                   ORDER BY
  87                         CASE
  88                                 WHEN rd.item_type IS NULL -- default
  89                                         THEN 0
  90                                 WHEN rd.item_type = '' -- default
  91                                         THEN 0
  92                                 WHEN rd.item_type IN ('a','t') -- books
  93                                         THEN 1
  94                                 WHEN rd.item_type = 'g' -- movies
  95                                         THEN 2
  96                                 WHEN rd.item_type IN ('i','j') -- sound recordings
  97                                         THEN 3
  98                                 WHEN rd.item_type = 'm' -- software
  99                                         THEN 4
 100                                 WHEN rd.item_type = 'k' -- images
 101                                         THEN 5
 102                                 WHEN rd.item_type IN ('e','f') -- maps
 103                                         THEN 6
 104                                 WHEN rd.item_type IN ('o','p') -- mixed
 105                                         THEN 7
 106                                 WHEN rd.item_type IN ('c','d') -- music
 107                                         THEN 8
 108                                 WHEN rd.item_type = 'r' -- 3d
 109                                         THEN 9
 110                         END,
 111                         count DESC
 112                 ) x
 113         SQL
 114
 115         if ($copies_visible) {
 116                 $sql .= ' WHERE x.count > 0'
 117         }
 118
 119         if (@types) {
 120                 $sql .= ' AND x.item_type IN ('.join(',',map{'?'}@types).')';
 121         }
 122
 123         if (@forms) {
 124                 $sql .= ' AND x.item_form IN ('.join(',',map{'?'}@forms).')';
 125         }
 126
 127         my $sth = metabib::metarecord_source_map->db_Main->prepare_cached($sql);
 128         $sth->execute("$mr", @types, @forms);
 129         while ( my $row = $sth->fetchrow_arrayref ) {
 130                 $client->respond( $$row[0] );
 131         }
 132         return undef;
 133
 134 }
 135 __PACKAGE__->register_method(
 136         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records',
 137         method          => 'ordered_records_from_metarecord',
 138         api_level       => 1,
 139         stream          => 1,
 140         cachable        => 1,
 141 );
 142 __PACKAGE__->register_method(
 143         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.staff',
 144         method          => 'ordered_records_from_metarecord',
 145         api_level       => 1,
 146         stream          => 1,
 147         cachable        => 1,
 148 );
 149
 150
 151 sub metarecord_copy_count {
 152         my $self = shift;
 153         my $client = shift;
 154
 155         my %args = @_;
 156
 157         my $sm_table = metabib::metarecord_source_map->table;
 158         my $cn_table = asset::call_number->table;
 159         my $cp_table = asset::copy->table;
 160         my $cs_table = config::copy_status->table;
 161         my $out_table = actor::org_unit_type->table;
 162         my $descendants = "actor.org_unit_descendants(u.id)";
 163         my $ancestors = "actor.org_unit_ancestors(?)";
 164
 165         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE';
 166         $copies_visible = '' if ($self->api_name =~ /staff/o);
 167
 168         my $sql = <<"   SQL";
 169                 SELECT  t.depth,
 170                         u.id AS org_unit,
 171                         sum(
 172                                 (SELECT count(cp.id)
 173                                   FROM  $sm_table r
 174                                         JOIN $cn_table cn ON (cn.record = r.source)
 175                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 176                                         JOIN $cs_table cs ON (cp.status = cs.id)
 177                                         JOIN $descendants a ON (cp.circ_lib = a.id)
 178                                   WHERE r.metarecord = ?
 179                                         $copies_visible
 180                                 )
 181                         ) AS count,
 182                         sum(
 183                                 (SELECT count(cp.id)
 184                                   FROM  $sm_table r
 185                                         JOIN $cn_table cn ON (cn.record = r.source)
 186                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
 187                                         JOIN $cs_table cs ON (cp.status = cs.id)
 188                                         JOIN $descendants a ON (cp.circ_lib = a.id)
 189                                   WHERE r.metarecord = ?
 190                                         AND cp.status = 0
 191                                         $copies_visible
 192                                 )
 193                         ) AS available
 194
 195                   FROM  $ancestors u
 196                         JOIN $out_table t ON (u.ou_type = t.id)
 197                   GROUP BY 1,2
 198         SQL
 199
 200         my $sth = metabib::metarecord_source_map->db_Main->prepare_cached($sql);
 201         $sth->execute(''.$args{metarecord}, ''.$args{metarecord}, ''.$args{org_unit});
 202         while ( my $row = $sth->fetchrow_hashref ) {
 203                 $client->respond( $row );
 204         }
 205         return undef;
 206 }
 207 __PACKAGE__->register_method(
 208         api_name        => 'open-ils.storage.metabib.metarecord.copy_count',
 209         method          => 'metarecord_copy_count',
 210         api_level       => 1,
 211         stream          => 1,
 212         cachable        => 1,
 213 );
 214 __PACKAGE__->register_method(
 215         api_name        => 'open-ils.storage.metabib.metarecord.copy_count.staff',
 216         method          => 'metarecord_copy_count',
 217         api_level       => 1,
 218         stream          => 1,
 219         cachable        => 1,
 220 );
 221
 222 sub search_full_rec {
 223         my $self = shift;
 224         my $client = shift;
 225
 226         my %args = @_;
 227
 228         my $term = $args{term};
 229         my $limiters = $args{restrict};
 230
 231         my ($index_col) = metabib::full_rec->columns('FTS');
 232         $index_col ||= 'value';
 233         my $search_table = metabib::full_rec->table;
 234
 235         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
 236
 237         my $fts_where = $fts->sql_where_clause();
 238         my @fts_ranks = $fts->fts_rank;
 239
 240         my $rank = join(' + ', @fts_ranks);
 241
 242         my @binds;
 243         my @wheres;
 244         for my $limit (@$limiters) {
 245                 push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
 246                 push @binds, $$limit{tag}, $$limit{subfield};
 247                 $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
 248         }
 249         my $where = join(' OR ', @wheres);
 250
 251         my $select = "SELECT record, sum($rank) FROM $search_table WHERE $where GROUP BY 1 ORDER BY 2 DESC;";
 252
 253         $log->debug("Search SQL :: [$select]",DEBUG);
 254
 255         my $recs = metabib::full_rec->db_Main->selectall_arrayref($select, {}, @binds);
 256         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 257
 258         $client->respond($_) for (@$recs);
 259         return undef;
 260 }
 261 __PACKAGE__->register_method(
 262         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.value',
 263         method          => 'search_full_rec',
 264         api_level       => 1,
 265         stream          => 1,
 266         cachable        => 1,
 267 );
 268 __PACKAGE__->register_method(
 269         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.index_vector',
 270         method          => 'search_full_rec',
 271         api_level       => 1,
 272         stream          => 1,
 273         cachable        => 1,
 274 );
 275
 276
 277 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 278 sub search_class_fts {
 279         my $self = shift;
 280         my $client = shift;
 281         my %args = @_;
 282
 283         my $term = $args{term};
 284         my $ou = $args{org_unit};
 285         my $ou_type = $args{depth};
 286         my $limit = $args{limit};
 287         my $offset = $args{offset};
 288
 289         my $limit_clause = '';
 290         my $offset_clause = '';
 291
 292         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
 293         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
 294
 295         my (@types,@forms);
 296         my ($t_filter, $f_filter) = ('','');
 297
 298         if ($args{format}) {
 299                 my ($t, $f) = split '-', $args{format};
 300                 @types = split '', $t;
 301                 @forms = split '', $f;
 302                 if (@types) {
 303                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 304                 }
 305
 306                 if (@forms) {
 307                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 308                 }
 309         }
 310
 311
 312
 313         my $descendants = defined($ou_type) ?
 314                                 "actor.org_unit_descendants($ou, $ou_type)" :
 315                                 "actor.org_unit_descendants($ou)";
 316
 317         my $class = $self->{cdbi};
 318         my $search_table = $class->table;
 319
 320         my $metabib_record_descriptor = metabib::record_descriptor->table;
 321         my $metabib_metarecord = metabib::metarecord->table;
 322         my $metabib_full_rec = metabib::full_rec->table;
 323         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
 324         my $asset_call_number_table = asset::call_number->table;
 325         my $asset_copy_table = asset::copy->table;
 326         my $cs_table = config::copy_status->table;
 327
 328         my ($index_col) = $class->columns('FTS');
 329         $index_col ||= 'value';
 330
 331         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
 332
 333         my $fts_where = $fts->sql_where_clause;
 334         my @fts_ranks = $fts->fts_rank;
 335
 336         my $rank = join(' + ', @fts_ranks);
 337
 338         my $has_vols = 'AND cn.owning_lib = d.id';
 339         my $has_copies = 'AND cp.call_number = cn.id';
 340         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE';
 341
 342         my $visible_count = ', count(DISTINCT cp.id)';
 343         my $visible_count_test = 'HAVING count(DISTINCT cp.id) > 0';
 344
 345         if ($self->api_name =~ /staff/o) {
 346                 $copies_visible = '';
 347                 $visible_count_test = '';
 348                 $has_copies = '' if ($ou_type == 0);
 349                 $has_vols = '' if ($ou_type == 0);
 350         }
 351
 352         my $rank_calc = <<"     RANK";
 353                 , (SUM( $rank
 354                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
 355                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
 356                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
 357                 )/COUNT(m.source)), MIN(COALESCE(CHAR_LENGTH(f.value),1))
 358         RANK
 359
 360         $rank_calc = ',1 , 1' if ($self->api_name =~ /unordered/o);
 361
 362         if ($copies_visible) {
 363                 $select = <<"           SQL";
 364                         SELECT  m.metarecord $rank_calc $visible_count
 365                         FROM    $search_table f,
 366                                 $metabib_metarecord_source_map_table m,
 367                                 $asset_call_number_table cn,
 368                                 $asset_copy_table cp,
 369                                 $cs_table cs,
 370                                 $metabib_record_descriptor rd,
 371                                 $descendants d
 372                         WHERE   $fts_where
 373                                 AND m.source = f.source
 374                                 AND cn.record = m.source
 375                                 AND rd.record = m.source
 376                                 AND cp.status = cs.id
 377                                 $has_vols
 378                                 $has_copies
 379                                 $copies_visible
 380                                 $t_filter
 381                                 $f_filter
 382                         GROUP BY m.metarecord $visible_count_test
 383                         ORDER BY 2 DESC,3
 384                         $limit_clause $offset_clause
 385                 SQL
 386         } else {
 387                 $select .= <<"          SQL";
 388                         SELECT  m.metarecord $rank_calc, 0
 389                         FROM    $search_table f,
 390                                 $metabib_metarecord_source_map_table m,
 391                                 $metabib_record_descriptor rd
 392                         WHERE   $fts_where
 393                                 AND m.source = f.source
 394                                 AND rd.record = m.source
 395                                 $t_filter
 396                                 $f_filter
 397                         GROUP BY 1, 4
 398                         ORDER BY 2 DESC,3
 399                         $limit_clause $offset_clause
 400                 SQL
 401         }
 402
 403         $log->debug("Field Search SQL :: [$select]",DEBUG);
 404
 405         my $SQLstring = join('%',$fts->words);
 406         my $REstring = join('\\s+',$fts->words);
 407         my $first_word = ($fts->words)[0].'%';
 408         my $recs = ($self->api_name =~ /unordered/o) ?
 409                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
 410                         $class->db_Main->selectall_arrayref($select, {},
 411                                 '%'.lc($SQLstring).'%',                 # phrase order match
 412                                 lc($first_word),                        # first word match
 413                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
 414                                 @types, @forms
 415                         );
 416
 417         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
 418
 419         $client->respond($_) for (map { [@$_[0,1,3]] } @$recs);
 420         return undef;
 421 }
 422
 423 for my $class ( qw/title author subject keyword series/ ) {
 424         __PACKAGE__->register_method(
 425                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord",
 426                 method          => 'search_class_fts',
 427                 api_level       => 1,
 428                 stream          => 1,
 429                 cdbi            => "metabib::${class}_field_entry",
 430                 cachable        => 1,
 431         );
 432         __PACKAGE__->register_method(
 433                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.unordered",
 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.staff",
 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.unordered",
 450                 method          => 'search_class_fts',
 451                 api_level       => 1,
 452                 stream          => 1,
 453                 cdbi            => "metabib::${class}_field_entry",
 454                 cachable        => 1,
 455         );
 456 }
 457
 458 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
 459 sub search_class_fts_count {
 460         my $self = shift;
 461         my $client = shift;
 462         my %args = @_;
 463
 464         my $term = $args{term};
 465         my $ou = $args{org_unit};
 466         my $ou_type = $args{depth};
 467         my $limit = $args{limit} || 100;
 468         my $offset = $args{offset} || 0;
 469
 470         my $descendants = defined($ou_type) ?
 471                                 "actor.org_unit_descendants($ou, $ou_type)" :
 472                                 "actor.org_unit_descendants($ou)";
 473
 474         my (@types,@forms);
 475         my ($t_filter, $f_filter) = ('','');
 476
 477         if ($args{format}) {
 478                 my ($t, $f) = split '-', $args{format};
 479                 @types = split '', $t;
 480                 @forms = split '', $f;
 481                 if (@types) {
 482                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
 483                 }
 484
 485                 if (@forms) {
 486                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
 487                 }
 488         }
 489
 490
 491         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
 492
 493         my $class = $self->{cdbi};
 494         my $search_table = $class->table;
 495
 496         my $metabib_record_descriptor = metabib::record_descriptor->table;
 497         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
 498         my $asset_call_number_table = asset::call_number->table;
 499         my $asset_copy_table = asset::copy->table;
 500         my $cs_table = config::copy_status->table;
 501
 502         my ($index_col) = $class->columns('FTS');
 503         $index_col ||= 'value';
 504
 505         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
 506
 507         my $fts_where = $fts->sql_where_clause;
 508
 509         my $has_vols = 'AND cn.owning_lib = d.id';
 510         my $has_copies = 'AND cp.call_number = cn.id';
 511         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE';
 512         if ($self->api_name =~ /staff/o) {
 513                 $copies_visible = '';
 514                 $has_vols = '' if ($ou_type == 0);
 515                 $has_copies = '' if ($ou_type == 0);
 516         }
 517
 518         # XXX test an "EXISTS version of descendant checking...
 519         my $select;
 520         if ($copies_visible) {
 521                 $select = <<"           SQL";
 522                 SELECT  count(distinct  m.metarecord)
 523                   FROM  $search_table f,
 524                         $metabib_metarecord_source_map_table m,
 525                         $asset_call_number_table cn,
 526                         $asset_copy_table cp,
 527                         $cs_table cs,
 528                         $metabib_record_descriptor rd,
 529                         $descendants d
 530                   WHERE $fts_where
 531                         AND m.source = f.source
 532                         AND cn.record = m.source
 533                         AND rd.record = m.source
 534                         AND cp.status = cs.id
 535                         $has_vols
 536                         $has_copies
 537                         $copies_visible
 538                         $t_filter
 539                         $f_filter
 540                 SQL
 541         } else {
 542                 $select = <<"           SQL";
 543                 SELECT  count(distinct  m.metarecord)
 544                   FROM  $search_table f,
 545                         $metabib_metarecord_source_map_table m,
 546                         $metabib_record_descriptor rd
 547                   WHERE $fts_where
 548                         AND m.source = f.source
 549                         AND rd.record = m.source
 550                         $t_filter
 551                         $f_filter
 552                 SQL
 553         }
 554
 555         $log->debug("Field Search Count SQL :: [$select]",DEBUG);
 556
 557         my $recs = $class->db_Main->selectrow_arrayref($select, {}, @types, @forms)->[0];
 558
 559         $log->debug("Count Search yielded $recs results.",DEBUG);
 560
 561         return $recs;
 562
 563 }
 564 for my $class ( qw/title author subject keyword series/ ) {
 565         __PACKAGE__->register_method(
 566                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count",
 567                 method          => 'search_class_fts_count',
 568                 api_level       => 1,
 569                 stream          => 1,
 570                 cdbi            => "metabib::${class}_field_entry",
 571                 cachable        => 1,
 572         );
 573         __PACKAGE__->register_method(
 574                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count.staff",
 575                 method          => 'search_class_fts_count',
 576                 api_level       => 1,
 577                 stream          => 1,
 578                 cdbi            => "metabib::${class}_field_entry",
 579                 cachable        => 1,
 580         );
 581 }
 582
 583
 584 1;