fc5c79479b05449a65255e70d264ad6c78b9ccd5
[Evergreen.git] / 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 $rd_table = metabib::record_descriptor->table;
161         my $cn_table = asset::call_number->table;
162         my $cp_table = asset::copy->table;
163         my $cl_table = asset::copy_location->table;
164         my $cs_table = config::copy_status->table;
165         my $out_table = actor::org_unit_type->table;
166         my $descendants = "actor.org_unit_descendants(u.id)";
167         my $ancestors = "actor.org_unit_ancestors(?)";
168
169         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
170         $copies_visible = '' if ($self->api_name =~ /staff/o);
171
172         my (@types,@forms);
173         my ($t_filter, $f_filter) = ('','');
174
175         if ($args{format}) {
176                 my ($t, $f) = split '-', $args{format};
177                 @types = split '', $t;
178                 @forms = split '', $f;
179                 if (@types) {
180                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
181                 }
182
183                 if (@forms) {
184                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
185                 }
186         }
187
188         my $sql = <<"   SQL";
189                 SELECT  t.depth,
190                         u.id AS org_unit,
191                         sum(
192                                 (SELECT count(cp.id)
193                                   FROM  $sm_table r
194                                         JOIN $cn_table cn ON (cn.record = r.source)
195                                         JOIN $rd_table rd ON (cn.record = rd.record)
196                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
197                                         JOIN $cs_table cs ON (cp.status = cs.id)
198                                         JOIN $cl_table cl ON (cp.location = cl.id)
199                                         JOIN $descendants a ON (cp.circ_lib = a.id)
200                                   WHERE r.metarecord = ?
201                                         $copies_visible
202                                         $t_filter
203                                         $f_filter
204                                 )
205                         ) AS count,
206                         sum(
207                                 (SELECT count(cp.id)
208                                   FROM  $sm_table r
209                                         JOIN $cn_table cn ON (cn.record = r.source)
210                                         JOIN $rd_table rd ON (cn.record = rd.record)
211                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
212                                         JOIN $cs_table cs ON (cp.status = cs.id)
213                                         JOIN $cl_table cl ON (cp.location = cl.id)
214                                         JOIN $descendants a ON (cp.circ_lib = a.id)
215                                   WHERE r.metarecord = ?
216                                         AND cp.status = 0
217                                         $copies_visible
218                                         $t_filter
219                                         $f_filter
220                                 )
221                         ) AS available
222
223                   FROM  $ancestors u
224                         JOIN $out_table t ON (u.ou_type = t.id)
225                   GROUP BY 1,2
226         SQL
227
228         my $sth = metabib::metarecord_source_map->db_Main->prepare_cached($sql);
229         $sth->execute(  ''.$args{metarecord},
230                         ''.$args{metarecord},
231                         ''.$args{org_unit}, 
232                         @types, 
233                         @forms ); 
234
235         while ( my $row = $sth->fetchrow_hashref ) {
236                 $client->respond( $row );
237         }
238         return undef;
239 }
240 __PACKAGE__->register_method(
241         api_name        => 'open-ils.storage.metabib.metarecord.copy_count',
242         method          => 'metarecord_copy_count',
243         api_level       => 1,
244         stream          => 1,
245         cachable        => 1,
246 );
247 __PACKAGE__->register_method(
248         api_name        => 'open-ils.storage.metabib.metarecord.copy_count.staff',
249         method          => 'metarecord_copy_count',
250         api_level       => 1,
251         stream          => 1,
252         cachable        => 1,
253 );
254
255 sub multi_search_full_rec {
256         my $self = shift;
257         my $client = shift;
258
259         my %args = @_;  
260         my $class_join = $args{class_join} || 'AND';
261         my @binds;
262         my @selects;
263
264         for my $arg (@{ $args{searches} }) {
265                 my $term = $$arg{term};
266                 my $limiters = $$arg{restrict};
267
268                 my ($index_col) = metabib::full_rec->columns('FTS');
269                 $index_col ||= 'value';
270                 my $search_table = metabib::full_rec->table;
271
272                 my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
273
274                 my $fts_where = $fts->sql_where_clause();
275                 my @fts_ranks = $fts->fts_rank;
276
277                 my $rank = join(' + ', @fts_ranks);
278
279                 my @wheres;
280                 for my $limit (@$limiters) {
281                         push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
282                         push @binds, $$limit{tag}, $$limit{subfield};
283                         $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
284                 }
285                 my $where = join(' OR ', @wheres);
286
287                 push @selects, "SELECT record, sum($rank) FROM $search_table WHERE $where GROUP BY 1 ORDER BY 2 DESC";
288
289         }
290
291         my $descendants = defined($args{depth}) ?
292                                 "actor.org_unit_descendants($args{org_unit}, $args{depth})" :
293                                 defined($args{depth}) ?
294                                         "actor.org_unit_descendants($args{org_unit})" :
295                                         "actor.org_unit";
296
297
298         my $metabib_record_descriptor = metabib::record_descriptor->table;
299         my $metabib_metarecord = metabib::metarecord->table;
300         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
301         my $asset_call_number_table = asset::call_number->table;
302         my $asset_copy_table = asset::copy->table;
303         my $cs_table = config::copy_status->table;
304         my $cl_table = asset::copy_location->table;
305
306         my $cj = ''; $cj = 'HAVING COUNT(x.record) > 1' if ($class_join eq 'AND');
307         my $search_table = '(SELECT x.record, sum(x.sum) FROM (('.join(') UNION ALL (', @selects).")) x GROUP BY 1 $cj )";
308
309         my $has_vols = 'AND cn.owning_lib = d.id';
310         my $has_copies = 'AND cp.call_number = cn.id';
311         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
312
313         if ($self->api_name =~ /staff/o) {
314                 $copies_visible = '';
315                 $has_copies = '' if ($ou_type == 0);
316                 $has_vols = '' if ($ou_type == 0);
317         }
318
319         my ($t_filter, $f_filter) = ('','');
320
321         if ($args{format}) {
322                 my ($t, $f) = split '-', $args{format};
323                 my @types = split '', $t;
324                 my @forms = split '', $f;
325                 if (@types) {
326                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
327                 }
328
329                 if (@forms) {
330                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
331                 }
332                 push @binds, @types, @forms;
333         }
334
335
336         if ($copies_visible) {
337                 $select = <<"           SQL";
338                         SELECT  m.metarecord, sum(f.sum), count(DISTINCT cp.id), CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
339                         FROM    $search_table f,
340                                 $metabib_metarecord_source_map_table m,
341                                 $asset_call_number_table cn,
342                                 $asset_copy_table cp,
343                                 $cs_table cs,
344                                 $cl_table cl,
345                                 $metabib_record_descriptor rd,
346                                 $descendants d
347                         WHERE   m.source = f.record
348                                 AND cn.record = m.source
349                                 AND rd.record = m.source
350                                 AND cp.status = cs.id
351                                 AND cp.location = cl.id
352                                 $has_vols
353                                 $has_copies
354                                 $copies_visible
355                                 $t_filter
356                                 $f_filter
357                         GROUP BY m.metarecord HAVING count(DISTINCT cp.id) > 0
358                         ORDER BY 2 DESC,3 DESC
359                 SQL
360         } else {
361                 $select = <<"           SQL";
362                         SELECT  m.metarecord, 1, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
363                         FROM    $search_table f,
364                                 $metabib_metarecord_source_map_table m,
365                                 $metabib_record_descriptor rd
366                         WHERE   m.source = f.record
367                                 AND rd.record = m.source
368                                 $t_filter
369                                 $f_filter
370                         GROUP BY 1,2,3 
371                 SQL
372         }
373
374
375         $log->debug("Search SQL :: [$select]",DEBUG);
376
377         my $recs = metabib::full_rec->db_Main->selectall_arrayref("$select;", {}, @binds);
378         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
379
380         $client->respond($_) for (@$recs);
381         return undef;
382 }
383 __PACKAGE__->register_method(
384         api_name        => 'open-ils.storage.metabib.full_rec.multi_search',
385         method          => 'multi_search_full_rec',
386         api_level       => 1,
387         stream          => 1,
388         cachable        => 1,
389 );
390 __PACKAGE__->register_method(
391         api_name        => 'open-ils.storage.metabib.full_rec.multi_search.staff',
392         method          => 'multi_search_full_rec',
393         api_level       => 1,
394         stream          => 1,
395         cachable        => 1,
396 );
397
398 sub search_full_rec {
399         my $self = shift;
400         my $client = shift;
401
402         my %args = @_;
403         
404         my $term = $args{term};
405         my $limiters = $args{restrict};
406
407         my ($index_col) = metabib::full_rec->columns('FTS');
408         $index_col ||= 'value';
409         my $search_table = metabib::full_rec->table;
410
411         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
412
413         my $fts_where = $fts->sql_where_clause();
414         my @fts_ranks = $fts->fts_rank;
415
416         my $rank = join(' + ', @fts_ranks);
417
418         my @binds;
419         my @wheres;
420         for my $limit (@$limiters) {
421                 push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
422                 push @binds, $$limit{tag}, $$limit{subfield};
423                 $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
424         }
425         my $where = join(' OR ', @wheres);
426
427         my $select = "SELECT record, sum($rank) FROM $search_table WHERE $where GROUP BY 1 ORDER BY 2 DESC;";
428
429         $log->debug("Search SQL :: [$select]",DEBUG);
430
431         my $recs = metabib::full_rec->db_Main->selectall_arrayref($select, {}, @binds);
432         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
433
434         $client->respond($_) for (@$recs);
435         return undef;
436 }
437 __PACKAGE__->register_method(
438         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.value',
439         method          => 'search_full_rec',
440         api_level       => 1,
441         stream          => 1,
442         cachable        => 1,
443 );
444 __PACKAGE__->register_method(
445         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.index_vector',
446         method          => 'search_full_rec',
447         api_level       => 1,
448         stream          => 1,
449         cachable        => 1,
450 );
451
452
453 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
454 sub search_class_fts {
455         my $self = shift;
456         my $client = shift;
457         my %args = @_;
458         
459         my $term = $args{term};
460         my $ou = $args{org_unit};
461         my $ou_type = $args{depth};
462         my $limit = $args{limit};
463         my $offset = $args{offset};
464
465         my $limit_clause = '';
466         my $offset_clause = '';
467
468         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
469         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
470
471         my (@types,@forms);
472         my ($t_filter, $f_filter) = ('','');
473
474         if ($args{format}) {
475                 my ($t, $f) = split '-', $args{format};
476                 @types = split '', $t;
477                 @forms = split '', $f;
478                 if (@types) {
479                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
480                 }
481
482                 if (@forms) {
483                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
484                 }
485         }
486
487
488
489         my $descendants = defined($ou_type) ?
490                                 "actor.org_unit_descendants($ou, $ou_type)" :
491                                 "actor.org_unit_descendants($ou)";
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 = metabib::metarecord->table;
498         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
499         my $asset_call_number_table = asset::call_number->table;
500         my $asset_copy_table = asset::copy->table;
501         my $cs_table = config::copy_status->table;
502         my $cl_table = asset::copy_location->table;
503
504         my ($index_col) = $class->columns('FTS');
505         $index_col ||= 'value';
506
507         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
508
509         my $fts_where = $fts->sql_where_clause;
510         my @fts_ranks = $fts->fts_rank;
511
512         my $rank = join(' + ', @fts_ranks);
513
514         my $has_vols = 'AND cn.owning_lib = d.id';
515         my $has_copies = 'AND cp.call_number = cn.id';
516         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
517
518         my $visible_count = ', count(DISTINCT cp.id)';
519         my $visible_count_test = 'HAVING count(DISTINCT cp.id) > 0';
520
521         if ($self->api_name =~ /staff/o) {
522                 $copies_visible = '';
523                 $visible_count_test = '';
524                 $has_copies = '' if ($ou_type == 0);
525                 $has_vols = '' if ($ou_type == 0);
526         }
527
528         my $rank_calc = <<"     RANK";
529                 , (SUM( $rank
530                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
531                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
532                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
533                 )/COUNT(m.source)), MIN(COALESCE(CHAR_LENGTH(f.value),1))
534         RANK
535
536         $rank_calc = ',1 , 1' if ($self->api_name =~ /unordered/o);
537
538         if ($copies_visible) {
539                 $select = <<"           SQL";
540                         SELECT  m.metarecord $rank_calc $visible_count, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
541                         FROM    $search_table f,
542                                 $metabib_metarecord_source_map_table m,
543                                 $asset_call_number_table cn,
544                                 $asset_copy_table cp,
545                                 $cs_table cs,
546                                 $cl_table cl,
547                                 $metabib_record_descriptor rd,
548                                 $descendants d
549                         WHERE   $fts_where
550                                 AND m.source = f.source
551                                 AND cn.record = m.source
552                                 AND rd.record = m.source
553                                 AND cp.status = cs.id
554                                 AND cp.location = cl.id
555                                 $has_vols
556                                 $has_copies
557                                 $copies_visible
558                                 $t_filter
559                                 $f_filter
560                         GROUP BY 1 $visible_count_test
561                         ORDER BY 2 DESC,3
562                         $limit_clause $offset_clause
563                 SQL
564         } else {
565                 $select = <<"           SQL";
566                         SELECT  m.metarecord $rank_calc, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
567                         FROM    $search_table f,
568                                 $metabib_metarecord_source_map_table m,
569                                 $metabib_record_descriptor rd
570                         WHERE   $fts_where
571                                 AND m.source = f.source
572                                 AND rd.record = m.source
573                                 $t_filter
574                                 $f_filter
575                         GROUP BY 1, 4
576                         ORDER BY 2 DESC,3
577                         $limit_clause $offset_clause
578                 SQL
579         }
580
581         $log->debug("Field Search SQL :: [$select]",DEBUG);
582
583         my $SQLstring = join('%',$fts->words);
584         my $REstring = join('\\s+',$fts->words);
585         my $first_word = ($fts->words)[0].'%';
586         my $recs = ($self->api_name =~ /unordered/o) ? 
587                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
588                         $class->db_Main->selectall_arrayref($select, {},
589                                 '%'.lc($SQLstring).'%',                 # phrase order match
590                                 lc($first_word),                        # first word match
591                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
592                                 @types, @forms
593                         );
594         
595         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
596
597         $client->respond($_) for (map { [@$_[0,1,3,4]] } @$recs);
598         return undef;
599 }
600
601 for my $class ( qw/title author subject keyword series/ ) {
602         __PACKAGE__->register_method(
603                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord",
604                 method          => 'search_class_fts',
605                 api_level       => 1,
606                 stream          => 1,
607                 cdbi            => "metabib::${class}_field_entry",
608                 cachable        => 1,
609         );
610         __PACKAGE__->register_method(
611                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.unordered",
612                 method          => 'search_class_fts',
613                 api_level       => 1,
614                 stream          => 1,
615                 cdbi            => "metabib::${class}_field_entry",
616                 cachable        => 1,
617         );
618         __PACKAGE__->register_method(
619                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff",
620                 method          => 'search_class_fts',
621                 api_level       => 1,
622                 stream          => 1,
623                 cdbi            => "metabib::${class}_field_entry",
624                 cachable        => 1,
625         );
626         __PACKAGE__->register_method(
627                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff.unordered",
628                 method          => 'search_class_fts',
629                 api_level       => 1,
630                 stream          => 1,
631                 cdbi            => "metabib::${class}_field_entry",
632                 cachable        => 1,
633         );
634 }
635
636 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
637 sub search_class_fts_count {
638         my $self = shift;
639         my $client = shift;
640         my %args = @_;
641         
642         my $term = $args{term};
643         my $ou = $args{org_unit};
644         my $ou_type = $args{depth};
645         my $limit = $args{limit} || 100;
646         my $offset = $args{offset} || 0;
647
648         my $descendants = defined($ou_type) ?
649                                 "actor.org_unit_descendants($ou, $ou_type)" :
650                                 "actor.org_unit_descendants($ou)";
651                 
652         my (@types,@forms);
653         my ($t_filter, $f_filter) = ('','');
654
655         if ($args{format}) {
656                 my ($t, $f) = split '-', $args{format};
657                 @types = split '', $t;
658                 @forms = split '', $f;
659                 if (@types) {
660                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
661                 }
662
663                 if (@forms) {
664                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
665                 }
666         }
667
668
669         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
670
671         my $class = $self->{cdbi};
672         my $search_table = $class->table;
673
674         my $metabib_record_descriptor = metabib::record_descriptor->table;
675         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
676         my $asset_call_number_table = asset::call_number->table;
677         my $asset_copy_table = asset::copy->table;
678         my $cs_table = config::copy_status->table;
679         my $cl_table = asset::copy_location->table;
680
681         my ($index_col) = $class->columns('FTS');
682         $index_col ||= 'value';
683
684         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
685
686         my $fts_where = $fts->sql_where_clause;
687
688         my $has_vols = 'AND cn.owning_lib = d.id';
689         my $has_copies = 'AND cp.call_number = cn.id';
690         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
691         if ($self->api_name =~ /staff/o) {
692                 $copies_visible = '';
693                 $has_vols = '' if ($ou_type == 0);
694                 $has_copies = '' if ($ou_type == 0);
695         }
696
697         # XXX test an "EXISTS version of descendant checking...
698         my $select;
699         if ($copies_visible) {
700                 $select = <<"           SQL";
701                 SELECT  count(distinct  m.metarecord)
702                   FROM  $search_table f,
703                         $metabib_metarecord_source_map_table m,
704                         $asset_call_number_table cn,
705                         $asset_copy_table cp,
706                         $cs_table cs,
707                         $cl_table cl,
708                         $metabib_record_descriptor rd,
709                         $descendants d
710                   WHERE $fts_where
711                         AND m.source = f.source
712                         AND cn.record = m.source
713                         AND rd.record = m.source
714                         AND cp.status = cs.id
715                         AND cp.location = cl.id
716                         $has_vols
717                         $has_copies
718                         $copies_visible
719                         $t_filter
720                         $f_filter
721                 SQL
722         } else {
723                 $select = <<"           SQL";
724                 SELECT  count(distinct  m.metarecord)
725                   FROM  $search_table f,
726                         $metabib_metarecord_source_map_table m,
727                         $metabib_record_descriptor rd
728                   WHERE $fts_where
729                         AND m.source = f.source
730                         AND rd.record = m.source
731                         $t_filter
732                         $f_filter
733                 SQL
734         }
735
736         $log->debug("Field Search Count SQL :: [$select]",DEBUG);
737
738         my $recs = $class->db_Main->selectrow_arrayref($select, {}, @types, @forms)->[0];
739         
740         $log->debug("Count Search yielded $recs results.",DEBUG);
741
742         return $recs;
743
744 }
745 for my $class ( qw/title author subject keyword series/ ) {
746         __PACKAGE__->register_method(
747                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count",
748                 method          => 'search_class_fts_count',
749                 api_level       => 1,
750                 stream          => 1,
751                 cdbi            => "metabib::${class}_field_entry",
752                 cachable        => 1,
753         );
754         __PACKAGE__->register_method(
755                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count.staff",
756                 method          => 'search_class_fts_count',
757                 api_level       => 1,
758                 stream          => 1,
759                 cdbi            => "metabib::${class}_field_entry",
760                 cachable        => 1,
761         );
762 }
763
764
765
766
767
768 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
769 sub new_search_class_fts {
770         my $self = shift;
771         my $client = shift;
772         my %args = @_;
773         
774         my $term = $args{term};
775         my $ou = $args{org_unit};
776         my $ou_type = $args{depth};
777         my $limit = $args{limit};
778         my $offset = $args{offset} || 0;
779
780         my $limit_clause = '';
781         my $offset_clause = '';
782
783         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
784         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
785
786         my (@types,@forms);
787         my ($t_filter, $f_filter) = ('','');
788
789         if ($args{format}) {
790                 my ($t, $f) = split '-', $args{format};
791                 @types = split '', $t;
792                 @forms = split '', $f;
793                 if (@types) {
794                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
795                 }
796
797                 if (@forms) {
798                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
799                 }
800         }
801
802
803
804         my $descendants = defined($ou_type) ?
805                                 "actor.org_unit_descendants($ou, $ou_type)" :
806                                 "actor.org_unit_descendants($ou)";
807
808         my $class = $self->{cdbi};
809         my $search_table = $class->table;
810
811         my $metabib_record_descriptor = metabib::record_descriptor->table;
812         my $metabib_metarecord = metabib::metarecord->table;
813         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
814         my $asset_call_number_table = asset::call_number->table;
815         my $asset_copy_table = asset::copy->table;
816         my $cs_table = config::copy_status->table;
817         my $cl_table = asset::copy_location->table;
818
819         my ($index_col) = $class->columns('FTS');
820         $index_col ||= 'value';
821
822         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
823
824         my $fts_where = $fts->sql_where_clause;
825         my @fts_ranks = $fts->fts_rank;
826
827         my $rank = join(' + ', @fts_ranks);
828
829         if ($self->api_name !~ /staff/o) {
830                 $select = <<"           SQL";
831                         SELECT  m.metarecord, 
832                                 (SUM(   $rank
833                                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
834                                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
835                                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
836                                 )/COUNT(m.source)),
837                                 CASE WHEN COUNT(DISTINCT rd.record) = 1 THEN MIN(m.source) ELSE 0 END
838                         FROM    $search_table f,
839                                 $metabib_metarecord_source_map_table m,
840                                 $metabib_metarecord_source_map_table mr,
841                                 $metabib_record_descriptor rd
842                         WHERE   $fts_where
843                                 AND m.source = f.source
844                                 AND mr.metarecord = m.metarecord
845                                 AND rd.record = mr.source
846                                 $t_filter
847                                 $f_filter
848                                 AND EXISTS (
849                                         SELECT  TRUE
850                                           FROM  $asset_call_number_table cn,
851                                                 $asset_copy_table cp,
852                                                 $cs_table cs,
853                                                 $cl_table cl,
854                                                 $descendants d
855                                           WHERE cn.record = mr.source
856                                                 AND cp.status = cs.id
857                                                 AND cp.location = cl.id
858                                                 AND cn.owning_lib = d.id
859                                                 AND cp.call_number = cn.id
860                                                 AND cp.opac_visible IS TRUE
861                                                 AND cs.holdable IS TRUE
862                                                 AND cl.opac_visible IS TRUE )
863                         GROUP BY m.metarecord
864                         ORDER BY 2 DESC, MIN(COALESCE(CHAR_LENGTH(f.value),1))
865                 SQL
866         } else {
867                 $select = <<"           SQL";
868                         SELECT  m.metarecord,
869                                 (SUM(   $rank
870                                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
871                                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
872                                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
873                                 )/COUNT(m.source)),
874                                 CASE WHEN COUNT(DISTINCT rd.record) = 1 THEN MIN(m.source) ELSE 0 END
875                         FROM    $search_table f,
876                                 $metabib_metarecord_source_map_table m,
877                                 $metabib_metarecord_source_map_table mr,
878                                 $metabib_record_descriptor rd
879                         WHERE   $fts_where
880                                 AND m.source = f.source
881                                 AND m.metarecord = mr.metarecord
882                                 AND rd.record = m.source
883                                 $t_filter
884                                 $f_filter
885                         GROUP BY m.metarecord
886                         ORDER BY 2 DESC, MIN(COALESCE(CHAR_LENGTH(f.value),1))
887                 SQL
888         }
889
890         $log->debug("Field Search SQL :: [$select]",DEBUG);
891
892         my $SQLstring = join('%',$fts->words);
893         my $REstring = join('\\s+',$fts->words);
894         my $first_word = ($fts->words)[0].'%';
895         my $recs = ($self->api_name =~ /unordered/o) ? 
896                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
897                         $class->db_Main->selectall_arrayref($select, {},
898                                 '%'.lc($SQLstring).'%',                 # phrase order match
899                                 lc($first_word),                        # first word match
900                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
901                                 @types, @forms
902                         );
903         
904         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
905
906         my $count = scalar(@$recs);
907         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
908                 my ($mrid,$rank,$skip) = @$rec;
909                 $client->respond( [$mrid, sprintf('%0.3f',$rank), $skip, $count] );
910         }
911         return undef;
912 }
913
914 for my $class ( qw/title author subject keyword series/ ) {
915         __PACKAGE__->register_method(
916                 api_name        => "open-ils.storage.metabib.$class.new_search_fts.metarecord",
917                 method          => 'new_search_class_fts',
918                 api_level       => 1,
919                 stream          => 1,
920                 cdbi            => "metabib::${class}_field_entry",
921                 cachable        => 1,
922         );
923         __PACKAGE__->register_method(
924                 api_name        => "open-ils.storage.metabib.$class.new_search_fts.metarecord.staff",
925                 method          => 'new_search_class_fts',
926                 api_level       => 1,
927                 stream          => 1,
928                 cdbi            => "metabib::${class}_field_entry",
929                 cachable        => 1,
930         );
931 }
932
933
934 my $_cdbi = {   title   => "metabib::title_field_entry",
935                 author  => "metabib::author_field_entry",
936                 subject => "metabib::subject_field_entry",
937                 keyword => "metabib::keyword_field_entry",
938                 series  => "metabib::series_field_entry",
939 };
940
941
942
943 1;