283c94930a55a33c48f0e139172da06a2b12bee3
[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                         @types, 
231                         @forms,
232                         ''.$args{metarecord},
233                         @types, 
234                         @forms,
235                         ''.$args{org_unit}, 
236         ); 
237
238         while ( my $row = $sth->fetchrow_hashref ) {
239                 $client->respond( $row );
240         }
241         return undef;
242 }
243 __PACKAGE__->register_method(
244         api_name        => 'open-ils.storage.metabib.metarecord.copy_count',
245         method          => 'metarecord_copy_count',
246         api_level       => 1,
247         stream          => 1,
248         cachable        => 1,
249 );
250 __PACKAGE__->register_method(
251         api_name        => 'open-ils.storage.metabib.metarecord.copy_count.staff',
252         method          => 'metarecord_copy_count',
253         api_level       => 1,
254         stream          => 1,
255         cachable        => 1,
256 );
257
258 sub multi_search_full_rec {
259         my $self = shift;
260         my $client = shift;
261
262         my %args = @_;  
263         my $class_join = $args{class_join} || 'AND';
264         my $limit = $args{limit} || 100;
265         my $offset = $args{offset} || 0;
266         my @binds;
267         my @selects;
268
269         for my $arg (@{ $args{searches} }) {
270                 my $term = $$arg{term};
271                 my $limiters = $$arg{restrict};
272
273                 my ($index_col) = metabib::full_rec->columns('FTS');
274                 $index_col ||= 'value';
275                 my $search_table = metabib::full_rec->table;
276
277                 my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
278
279                 my $fts_where = $fts->sql_where_clause();
280                 my @fts_ranks = $fts->fts_rank;
281
282                 my $rank = join(' + ', @fts_ranks);
283
284                 my @wheres;
285                 for my $limit (@$limiters) {
286                         push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
287                         push @binds, $$limit{tag}, $$limit{subfield};
288                         $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
289                 }
290                 my $where = join(' OR ', @wheres);
291
292                 push @selects, "SELECT id, record, $rank as sum FROM $search_table WHERE $where";
293
294         }
295
296         my $descendants = defined($args{depth}) ?
297                                 "actor.org_unit_descendants($args{org_unit}, $args{depth})" :
298                                 "actor.org_unit_descendants($args{org_unit})" ;
299
300
301         my $metabib_record_descriptor = metabib::record_descriptor->table;
302         my $metabib_metarecord = metabib::metarecord->table;
303         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
304         my $asset_call_number_table = asset::call_number->table;
305         my $asset_copy_table = asset::copy->table;
306         my $cs_table = config::copy_status->table;
307         my $cl_table = asset::copy_location->table;
308
309         my $cj = ''; $cj = 'HAVING COUNT(x.id) > 1' if ($class_join eq 'AND' && @selects > 1);
310         my $search_table = '(SELECT x.record, sum(x.sum) FROM (('.join(') UNION ALL (', @selects).")) x GROUP BY 1 $cj ORDER BY 2 DESC )";
311
312         my $has_vols = 'AND cn.owning_lib = d.id';
313         my $has_copies = 'AND cp.call_number = cn.id';
314         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
315
316         if ($self->api_name =~ /staff/o) {
317                 $copies_visible = '';
318                 $has_copies = '' if ($ou_type == 0);
319                 $has_vols = '' if ($ou_type == 0);
320         }
321
322         my ($t_filter, $f_filter) = ('','');
323
324         if ($args{format}) {
325                 my ($t, $f) = split '-', $args{format};
326                 my @types = split '', $t;
327                 my @forms = split '', $f;
328                 if (@types) {
329                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
330                 }
331
332                 if (@forms) {
333                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
334                 }
335                 push @binds, @types, @forms;
336         }
337
338
339         if ($copies_visible) {
340                 $select = <<"           SQL";
341                         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
342                         FROM    $search_table f,
343                                 $metabib_metarecord_source_map_table m,
344                                 $asset_call_number_table cn,
345                                 $asset_copy_table cp,
346                                 $cs_table cs,
347                                 $cl_table cl,
348                                 $metabib_record_descriptor rd,
349                                 $descendants d
350                         WHERE   m.source = f.record
351                                 AND cn.record = m.source
352                                 AND rd.record = m.source
353                                 AND cp.status = cs.id
354                                 AND cp.location = cl.id
355                                 $has_vols
356                                 $has_copies
357                                 $copies_visible
358                                 $t_filter
359                                 $f_filter
360                         GROUP BY m.metarecord HAVING count(DISTINCT cp.id) > 0
361                         ORDER BY 2 DESC,3 DESC
362                 SQL
363         } else {
364                 $select = <<"           SQL";
365                         SELECT  m.metarecord, 1, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
366                         FROM    $search_table f,
367                                 $metabib_metarecord_source_map_table m,
368                                 $metabib_record_descriptor rd
369                         WHERE   m.source = f.record
370                                 AND rd.record = m.source
371                                 $t_filter
372                                 $f_filter
373                         GROUP BY 1,2,3 
374                 SQL
375         }
376
377
378         $log->debug("Search SQL :: [$select]",DEBUG);
379
380         my $recs = metabib::full_rec->db_Main->selectall_arrayref("$select;", {}, @binds);
381         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
382
383         my $count = @$recs;
384         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
385                 next unless ($$rec[0]);
386                 my ($mrid,$rank,$junk,$skip) = @$rec;
387                 $client->respond( [$mrid, sprintf('%0.3f',$rank), $skip, $count] );
388         }
389         return undef;
390 }
391 __PACKAGE__->register_method(
392         api_name        => 'open-ils.storage.metabib.full_rec.multi_search',
393         method          => 'multi_search_full_rec',
394         api_level       => 1,
395         stream          => 1,
396         cachable        => 1,
397 );
398 __PACKAGE__->register_method(
399         api_name        => 'open-ils.storage.metabib.full_rec.multi_search.staff',
400         method          => 'multi_search_full_rec',
401         api_level       => 1,
402         stream          => 1,
403         cachable        => 1,
404 );
405
406 sub search_full_rec {
407         my $self = shift;
408         my $client = shift;
409
410         my %args = @_;
411         
412         my $term = $args{term};
413         my $limiters = $args{restrict};
414
415         my ($index_col) = metabib::full_rec->columns('FTS');
416         $index_col ||= 'value';
417         my $search_table = metabib::full_rec->table;
418
419         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
420
421         my $fts_where = $fts->sql_where_clause();
422         my @fts_ranks = $fts->fts_rank;
423
424         my $rank = join(' + ', @fts_ranks);
425
426         my @binds;
427         my @wheres;
428         for my $limit (@$limiters) {
429                 push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
430                 push @binds, $$limit{tag}, $$limit{subfield};
431                 $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
432         }
433         my $where = join(' OR ', @wheres);
434
435         my $select = "SELECT record, sum($rank) FROM $search_table WHERE $where GROUP BY 1 ORDER BY 2 DESC;";
436
437         $log->debug("Search SQL :: [$select]",DEBUG);
438
439         my $recs = metabib::full_rec->db_Main->selectall_arrayref($select, {}, @binds);
440         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
441
442         $client->respond($_) for (@$recs);
443         return undef;
444 }
445 __PACKAGE__->register_method(
446         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.value',
447         method          => 'search_full_rec',
448         api_level       => 1,
449         stream          => 1,
450         cachable        => 1,
451 );
452 __PACKAGE__->register_method(
453         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.index_vector',
454         method          => 'search_full_rec',
455         api_level       => 1,
456         stream          => 1,
457         cachable        => 1,
458 );
459
460
461 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
462 sub search_class_fts {
463         my $self = shift;
464         my $client = shift;
465         my %args = @_;
466         
467         my $term = $args{term};
468         my $ou = $args{org_unit};
469         my $ou_type = $args{depth};
470         my $limit = $args{limit};
471         my $offset = $args{offset};
472
473         my $limit_clause = '';
474         my $offset_clause = '';
475
476         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
477         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
478
479         my (@types,@forms);
480         my ($t_filter, $f_filter) = ('','');
481
482         if ($args{format}) {
483                 my ($t, $f) = split '-', $args{format};
484                 @types = split '', $t;
485                 @forms = split '', $f;
486                 if (@types) {
487                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
488                 }
489
490                 if (@forms) {
491                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
492                 }
493         }
494
495
496
497         my $descendants = defined($ou_type) ?
498                                 "actor.org_unit_descendants($ou, $ou_type)" :
499                                 "actor.org_unit_descendants($ou)";
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 = metabib::metarecord->table;
506         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
507         my $asset_call_number_table = asset::call_number->table;
508         my $asset_copy_table = asset::copy->table;
509         my $cs_table = config::copy_status->table;
510         my $cl_table = asset::copy_location->table;
511
512         my ($index_col) = $class->columns('FTS');
513         $index_col ||= 'value';
514
515         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
516
517         my $fts_where = $fts->sql_where_clause;
518         my @fts_ranks = $fts->fts_rank;
519
520         my $rank = join(' + ', @fts_ranks);
521
522         my $has_vols = 'AND cn.owning_lib = d.id';
523         my $has_copies = 'AND cp.call_number = cn.id';
524         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
525
526         my $visible_count = ', count(DISTINCT cp.id)';
527         my $visible_count_test = 'HAVING count(DISTINCT cp.id) > 0';
528
529         if ($self->api_name =~ /staff/o) {
530                 $copies_visible = '';
531                 $visible_count_test = '';
532                 $has_copies = '' if ($ou_type == 0);
533                 $has_vols = '' if ($ou_type == 0);
534         }
535
536         my $rank_calc = <<"     RANK";
537                 , (SUM( $rank
538                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
539                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
540                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
541                 )/COUNT(m.source)), MIN(COALESCE(CHAR_LENGTH(f.value),1))
542         RANK
543
544         $rank_calc = ',1 , 1' if ($self->api_name =~ /unordered/o);
545
546         if ($copies_visible) {
547                 $select = <<"           SQL";
548                         SELECT  m.metarecord $rank_calc $visible_count, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
549                         FROM    $search_table f,
550                                 $metabib_metarecord_source_map_table m,
551                                 $asset_call_number_table cn,
552                                 $asset_copy_table cp,
553                                 $cs_table cs,
554                                 $cl_table cl,
555                                 $metabib_record_descriptor rd,
556                                 $descendants d
557                         WHERE   $fts_where
558                                 AND m.source = f.source
559                                 AND cn.record = m.source
560                                 AND rd.record = m.source
561                                 AND cp.status = cs.id
562                                 AND cp.location = cl.id
563                                 $has_vols
564                                 $has_copies
565                                 $copies_visible
566                                 $t_filter
567                                 $f_filter
568                         GROUP BY 1 $visible_count_test
569                         ORDER BY 2 DESC,3
570                         $limit_clause $offset_clause
571                 SQL
572         } else {
573                 $select = <<"           SQL";
574                         SELECT  m.metarecord $rank_calc, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
575                         FROM    $search_table f,
576                                 $metabib_metarecord_source_map_table m,
577                                 $metabib_record_descriptor rd
578                         WHERE   $fts_where
579                                 AND m.source = f.source
580                                 AND rd.record = m.source
581                                 $t_filter
582                                 $f_filter
583                         GROUP BY 1, 4
584                         ORDER BY 2 DESC,3
585                         $limit_clause $offset_clause
586                 SQL
587         }
588
589         $log->debug("Field Search SQL :: [$select]",DEBUG);
590
591         my $SQLstring = join('%',$fts->words);
592         my $REstring = join('\\s+',$fts->words);
593         my $first_word = ($fts->words)[0].'%';
594         my $recs = ($self->api_name =~ /unordered/o) ? 
595                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
596                         $class->db_Main->selectall_arrayref($select, {},
597                                 '%'.lc($SQLstring).'%',                 # phrase order match
598                                 lc($first_word),                        # first word match
599                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
600                                 @types, @forms
601                         );
602         
603         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
604
605         $client->respond($_) for (map { [@$_[0,1,3,4]] } @$recs);
606         return undef;
607 }
608
609 for my $class ( qw/title author subject keyword series/ ) {
610         __PACKAGE__->register_method(
611                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord",
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.unordered",
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",
628                 method          => 'search_class_fts',
629                 api_level       => 1,
630                 stream          => 1,
631                 cdbi            => "metabib::${class}_field_entry",
632                 cachable        => 1,
633         );
634         __PACKAGE__->register_method(
635                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff.unordered",
636                 method          => 'search_class_fts',
637                 api_level       => 1,
638                 stream          => 1,
639                 cdbi            => "metabib::${class}_field_entry",
640                 cachable        => 1,
641         );
642 }
643
644 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
645 sub search_class_fts_count {
646         my $self = shift;
647         my $client = shift;
648         my %args = @_;
649         
650         my $term = $args{term};
651         my $ou = $args{org_unit};
652         my $ou_type = $args{depth};
653         my $limit = $args{limit} || 100;
654         my $offset = $args{offset} || 0;
655
656         my $descendants = defined($ou_type) ?
657                                 "actor.org_unit_descendants($ou, $ou_type)" :
658                                 "actor.org_unit_descendants($ou)";
659                 
660         my (@types,@forms);
661         my ($t_filter, $f_filter) = ('','');
662
663         if ($args{format}) {
664                 my ($t, $f) = split '-', $args{format};
665                 @types = split '', $t;
666                 @forms = split '', $f;
667                 if (@types) {
668                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
669                 }
670
671                 if (@forms) {
672                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
673                 }
674         }
675
676
677         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
678
679         my $class = $self->{cdbi};
680         my $search_table = $class->table;
681
682         my $metabib_record_descriptor = metabib::record_descriptor->table;
683         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
684         my $asset_call_number_table = asset::call_number->table;
685         my $asset_copy_table = asset::copy->table;
686         my $cs_table = config::copy_status->table;
687         my $cl_table = asset::copy_location->table;
688
689         my ($index_col) = $class->columns('FTS');
690         $index_col ||= 'value';
691
692         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'value',"$index_col");
693
694         my $fts_where = $fts->sql_where_clause;
695
696         my $has_vols = 'AND cn.owning_lib = d.id';
697         my $has_copies = 'AND cp.call_number = cn.id';
698         my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
699         if ($self->api_name =~ /staff/o) {
700                 $copies_visible = '';
701                 $has_vols = '' if ($ou_type == 0);
702                 $has_copies = '' if ($ou_type == 0);
703         }
704
705         # XXX test an "EXISTS version of descendant checking...
706         my $select;
707         if ($copies_visible) {
708                 $select = <<"           SQL";
709                 SELECT  count(distinct  m.metarecord)
710                   FROM  $search_table f,
711                         $metabib_metarecord_source_map_table m,
712                         $asset_call_number_table cn,
713                         $asset_copy_table cp,
714                         $cs_table cs,
715                         $cl_table cl,
716                         $metabib_record_descriptor rd,
717                         $descendants d
718                   WHERE $fts_where
719                         AND m.source = f.source
720                         AND cn.record = m.source
721                         AND rd.record = m.source
722                         AND cp.status = cs.id
723                         AND cp.location = cl.id
724                         $has_vols
725                         $has_copies
726                         $copies_visible
727                         $t_filter
728                         $f_filter
729                 SQL
730         } else {
731                 $select = <<"           SQL";
732                 SELECT  count(distinct  m.metarecord)
733                   FROM  $search_table f,
734                         $metabib_metarecord_source_map_table m,
735                         $metabib_record_descriptor rd
736                   WHERE $fts_where
737                         AND m.source = f.source
738                         AND rd.record = m.source
739                         $t_filter
740                         $f_filter
741                 SQL
742         }
743
744         $log->debug("Field Search Count SQL :: [$select]",DEBUG);
745
746         my $recs = $class->db_Main->selectrow_arrayref($select, {}, @types, @forms)->[0];
747         
748         $log->debug("Count Search yielded $recs results.",DEBUG);
749
750         return $recs;
751
752 }
753 for my $class ( qw/title author subject keyword series/ ) {
754         __PACKAGE__->register_method(
755                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count",
756                 method          => 'search_class_fts_count',
757                 api_level       => 1,
758                 stream          => 1,
759                 cdbi            => "metabib::${class}_field_entry",
760                 cachable        => 1,
761         );
762         __PACKAGE__->register_method(
763                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count.staff",
764                 method          => 'search_class_fts_count',
765                 api_level       => 1,
766                 stream          => 1,
767                 cdbi            => "metabib::${class}_field_entry",
768                 cachable        => 1,
769         );
770 }
771
772
773 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
774 sub new_search_class_fts {
775         my $self = shift;
776         my $client = shift;
777         my %args = @_;
778         
779         my $term = $args{term};
780         my $ou = $args{org_unit};
781         my $ou_type = $args{depth};
782         my $limit = $args{limit};
783         my $offset = $args{offset} || 0;
784
785         my $limit_clause = '';
786         my $offset_clause = '';
787
788         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
789         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
790
791         my (@types,@forms);
792         my ($t_filter, $f_filter) = ('','');
793
794         if ($args{format}) {
795                 my ($t, $f) = split '-', $args{format};
796                 @types = split '', $t;
797                 @forms = split '', $f;
798                 if (@types) {
799                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
800                 }
801
802                 if (@forms) {
803                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
804                 }
805         }
806
807
808
809         my $descendants = defined($ou_type) ?
810                                 "actor.org_unit_descendants($ou, $ou_type)" :
811                                 "actor.org_unit_descendants($ou)";
812
813         my $class = $self->{cdbi};
814         my $search_table = $class->table;
815
816         my $metabib_record_descriptor = metabib::record_descriptor->table;
817         my $metabib_metarecord = metabib::metarecord->table;
818         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
819         my $asset_call_number_table = asset::call_number->table;
820         my $asset_copy_table = asset::copy->table;
821         my $cs_table = config::copy_status->table;
822         my $cl_table = asset::copy_location->table;
823
824         my ($index_col) = $class->columns('FTS');
825         $index_col ||= 'value';
826
827         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
828
829         my $fts_where = $fts->sql_where_clause;
830         my @fts_ranks = $fts->fts_rank;
831
832         my $rank = join(' + ', @fts_ranks);
833
834         if ($self->api_name !~ /staff/o) {
835                 $select = <<"           SQL";
836                         SELECT  m.metarecord, 
837                                 (SUM(   $rank
838                                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
839                                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
840                                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
841                                 )/COUNT(m.source)),
842                                 CASE WHEN COUNT(DISTINCT rd.record) = 1 THEN MIN(m.source) ELSE 0 END
843                         FROM    $search_table f,
844                                 $metabib_metarecord_source_map_table m,
845                                 $metabib_metarecord_source_map_table mr,
846                                 $metabib_record_descriptor rd
847                         WHERE   $fts_where
848                                 AND m.source = f.source
849                                 AND mr.metarecord = m.metarecord
850                                 AND rd.record = mr.source
851                                 $t_filter
852                                 $f_filter
853                                 AND EXISTS (
854                                         SELECT  TRUE
855                                           FROM  $asset_call_number_table cn,
856                                                 $asset_copy_table cp,
857                                                 $cs_table cs,
858                                                 $cl_table cl,
859                                                 $descendants d
860                                           WHERE cn.record = mr.source
861                                                 AND cp.status = cs.id
862                                                 AND cp.location = cl.id
863                                                 AND cn.owning_lib = d.id
864                                                 AND cp.call_number = cn.id
865                                                 AND cp.opac_visible IS TRUE
866                                                 AND cs.holdable IS TRUE
867                                                 AND cl.opac_visible IS TRUE )
868                         GROUP BY m.metarecord
869                         ORDER BY 2 DESC, MIN(COALESCE(CHAR_LENGTH(f.value),1))
870                 SQL
871         } else {
872                 $select = <<"           SQL";
873                         SELECT  m.metarecord,
874                                 (SUM(   $rank
875                                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
876                                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
877                                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
878                                 )/COUNT(m.source)),
879                                 CASE WHEN COUNT(DISTINCT rd.record) = 1 THEN MIN(m.source) ELSE 0 END
880                         FROM    $search_table f,
881                                 $metabib_metarecord_source_map_table m,
882                                 $metabib_metarecord_source_map_table mr,
883                                 $metabib_record_descriptor rd
884                         WHERE   $fts_where
885                                 AND m.source = f.source
886                                 AND m.metarecord = mr.metarecord
887                                 AND rd.record = m.source
888                                 $t_filter
889                                 $f_filter
890                         GROUP BY m.metarecord
891                         ORDER BY 2 DESC, MIN(COALESCE(CHAR_LENGTH(f.value),1))
892                 SQL
893         }
894
895         $log->debug("Field Search SQL :: [$select]",DEBUG);
896
897         my $SQLstring = join('%',$fts->words);
898         my $REstring = join('\\s+',$fts->words);
899         my $first_word = ($fts->words)[0].'%';
900         my $recs = ($self->api_name =~ /unordered/o) ? 
901                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
902                         $class->db_Main->selectall_arrayref($select, {},
903                                 '%'.lc($SQLstring).'%',                 # phrase order match
904                                 lc($first_word),                        # first word match
905                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
906                                 @types, @forms
907                         );
908         
909         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
910
911         my $count = scalar(@$recs);
912         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
913                 my ($mrid,$rank,$skip) = @$rec;
914                 $client->respond( [$mrid, sprintf('%0.3f',$rank), $skip, $count] );
915         }
916         return undef;
917 }
918
919 for my $class ( qw/title author subject keyword series/ ) {
920         __PACKAGE__->register_method(
921                 api_name        => "open-ils.storage.metabib.$class.new_search_fts.metarecord",
922                 method          => 'new_search_class_fts',
923                 api_level       => 1,
924                 stream          => 1,
925                 cdbi            => "metabib::${class}_field_entry",
926                 cachable        => 1,
927         );
928         __PACKAGE__->register_method(
929                 api_name        => "open-ils.storage.metabib.$class.new_search_fts.metarecord.staff",
930                 method          => 'new_search_class_fts',
931                 api_level       => 1,
932                 stream          => 1,
933                 cdbi            => "metabib::${class}_field_entry",
934                 cachable        => 1,
935         );
936 }
937
938
939
940
941 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
942 sub postfilter_search_class_fts {
943         my $self = shift;
944         my $client = shift;
945         my %args = @_;
946         
947         my $term = $args{term};
948         my $ou = $args{org_unit};
949         my $ou_type = $args{depth};
950         my $limit = $args{limit};
951         my $offset = $args{offset} || 0;
952
953         my $outer_limit = 1000;
954
955         my $limit_clause = '';
956         my $offset_clause = '';
957
958         $limit_clause = "LIMIT $outer_limit";
959         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
960
961         my (@types,@forms);
962         my ($t_filter, $f_filter) = ('','');
963         my ($ot_filter, $of_filter) = ('','');
964
965         if ($args{format}) {
966                 my ($t, $f) = split '-', $args{format};
967                 @types = split '', $t;
968                 @forms = split '', $f;
969                 if (@types) {
970                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
971                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
972                 }
973
974                 if (@forms) {
975                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
976                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
977                 }
978         }
979
980
981
982         my $descendants = defined($ou_type) ?
983                                 "actor.org_unit_descendants($ou, $ou_type)" :
984                                 "actor.org_unit_descendants($ou)";
985
986         my $class = $self->{cdbi};
987         my $search_table = $class->table;
988
989         my $metabib_record_descriptor = metabib::record_descriptor->table;
990         my $metabib_metarecord = metabib::metarecord->table;
991         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
992         my $asset_call_number_table = asset::call_number->table;
993         my $asset_copy_table = asset::copy->table;
994         my $cs_table = config::copy_status->table;
995         my $cl_table = asset::copy_location->table;
996
997         my ($index_col) = $class->columns('FTS');
998         $index_col ||= 'value';
999
1000         my $fts = OpenILS::Application::Storage::FTS->compile($term, 'f.value', "f.$index_col");
1001
1002         my $fts_where = $fts->sql_where_clause;
1003         my @fts_ranks = $fts->fts_rank;
1004
1005         my $rank = join(' + ', @fts_ranks);
1006
1007         my $select = <<"        SQL";
1008                 SELECT  m.metarecord,
1009                         (SUM(   $rank
1010                                 * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
1011                                 * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
1012                                 * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
1013                         )/COUNT(m.source)),
1014                         CASE WHEN COUNT(DISTINCT rd.record) = 1 THEN MIN(m.source) ELSE 0 END
1015                 FROM    $search_table f,
1016                         $metabib_metarecord_source_map_table m,
1017                         $metabib_metarecord_source_map_table mr,
1018                         $metabib_record_descriptor rd
1019                 WHERE   $fts_where
1020                         AND m.source = f.source
1021                         AND m.metarecord = mr.metarecord
1022                         AND rd.record = f.source
1023                         $t_filter
1024                         $f_filter
1025                 GROUP BY m.metarecord
1026                 ORDER BY 2 DESC, MIN(COALESCE(CHAR_LENGTH(f.value),1))
1027                 LIMIT 10000
1028         SQL
1029
1030         if ($self->api_name !~ /staff/o) {
1031                 $select = <<"           SQL";
1032
1033                         SELECT  DISTINCT s.*
1034                           FROM  $asset_call_number_table cn,
1035                                 $metabib_metarecord_source_map_table mrs,
1036                                 $asset_copy_table cp,
1037                                 $cs_table cs,
1038                                 $cl_table cl,
1039                                 $descendants d,
1040                                 $metabib_record_descriptor ord,
1041                                 ($select) s
1042                           WHERE mrs.metarecord = s.metarecord
1043                                 AND cn.record = mrs.source
1044                                 AND cp.status = cs.id
1045                                 AND cp.location = cl.id
1046                                 AND cn.owning_lib = d.id
1047                                 AND cp.call_number = cn.id
1048                                 AND cp.opac_visible IS TRUE
1049                                 AND cs.holdable IS TRUE
1050                                 AND cl.opac_visible IS TRUE
1051                                 AND ord.record = mrs.source
1052                                 $ot_filter
1053                                 $of_filter
1054                           ORDER BY 2 DESC
1055                 SQL
1056         }
1057
1058
1059         $log->debug("Field Search SQL :: [$select]",DEBUG);
1060
1061         my $SQLstring = join('%',$fts->words);
1062         my $REstring = join('\\s+',$fts->words);
1063         my $first_word = ($fts->words)[0].'%';
1064         my $recs = $class->db_Main->selectall_arrayref(
1065                         $select, {},
1066                         '%'.lc($SQLstring).'%',                 # phrase order match
1067                         lc($first_word),                        # first word match
1068                         '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
1069                         @types, @forms,  ($self->api_name !~ /staff/o ? (@types, @forms) : () ) );
1070         
1071         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1072
1073         my $count = scalar(@$recs);
1074         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1075                 my ($mrid,$rank,$skip) = @$rec;
1076                 $client->respond( [$mrid, sprintf('%0.3f',$rank), $skip, $count] );
1077         }
1078         return undef;
1079 }
1080
1081 for my $class ( qw/title author subject keyword series/ ) {
1082         __PACKAGE__->register_method(
1083                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord",
1084                 method          => 'postfilter_search_class_fts',
1085                 api_level       => 1,
1086                 stream          => 1,
1087                 cdbi            => "metabib::${class}_field_entry",
1088                 cachable        => 1,
1089         );
1090         __PACKAGE__->register_method(
1091                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord.staff",
1092                 method          => 'postfilter_search_class_fts',
1093                 api_level       => 1,
1094                 stream          => 1,
1095                 cdbi            => "metabib::${class}_field_entry",
1096                 cachable        => 1,
1097         );
1098 }
1099
1100
1101
1102 my $_cdbi = {   title   => "metabib::title_field_entry",
1103                 author  => "metabib::author_field_entry",
1104                 subject => "metabib::subject_field_entry",
1105                 keyword => "metabib::keyword_field_entry",
1106                 series  => "metabib::series_field_entry",
1107 };
1108
1109 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1110 sub postfilter_search_multi_class_fts {
1111         my $self = shift;
1112         my $client = shift;
1113         my %args = @_;
1114         
1115         my $ou = $args{org_unit};
1116         my $ou_type = $args{depth};
1117         my $limit = $args{limit};
1118         my $offset = $args{offset} || 0;
1119
1120         my $outer_limit = 1000;
1121
1122         my $limit_clause = '';
1123         my $offset_clause = '';
1124
1125         $limit_clause = "LIMIT $outer_limit";
1126         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1127
1128         my (@types,@forms);
1129         my ($t_filter, $f_filter) = ('','');
1130         my ($ot_filter, $of_filter) = ('','');
1131
1132         if ($args{format}) {
1133                 my ($t, $f) = split '-', $args{format};
1134                 @types = split '', $t;
1135                 @forms = split '', $f;
1136                 if (@types) {
1137                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1138                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1139                 }
1140
1141                 if (@forms) {
1142                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1143                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1144                 }
1145         }
1146
1147
1148
1149         my $descendants = defined($ou_type) ?
1150                                 "actor.org_unit_descendants($ou, $ou_type)" :
1151                                 "actor.org_unit_descendants($ou)";
1152
1153         my $search_table_list = '';
1154         my $fts_list = '';
1155         my $join_table_list = '';
1156         my $rank_list = '';
1157
1158         my $prev_search_class;
1159         my $curr_search_class;
1160         for my $search_class (sort keys %{$args{searches}}) {
1161                 $prev_search_class = $curr_search_class if ($curr_search_class);
1162
1163                 $curr_search_class = $search_class;
1164
1165                 my $class = $_cdbi->{$search_class};
1166                 my $search_table = $class->table;
1167
1168                 my ($index_col) = $class->columns('FTS');
1169                 $index_col ||= 'value';
1170
1171                 
1172                 my $fts = OpenILS::Application::Storage::FTS->compile($args{searches}{$search_class}{term}, $search_class.'.value', "$search_class.$index_col");
1173
1174                 my $fts_where = $fts->sql_where_clause;
1175                 my @fts_ranks = $fts->fts_rank;
1176
1177                 my $rank = join(' + ', @fts_ranks);
1178
1179                 #---------------------
1180
1181                 $search_table_list .= "$search_table $search_class, ";
1182                 $rank_list .= " $rank +";
1183                 $fts_list .= " AND $fts_where AND m.source = $search_class.source";
1184
1185                 if ($prev_search_class) {
1186                         $join_table_list .= " AND $prev_search_class.source = $curr_search_class.source";
1187                 }
1188         }
1189
1190         chop $rank_list; # bleh ... ugly, ugly
1191
1192         my $metabib_record_descriptor = metabib::record_descriptor->table;
1193         my $metabib_metarecord = metabib::metarecord->table;
1194         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1195         my $asset_call_number_table = asset::call_number->table;
1196         my $asset_copy_table = asset::copy->table;
1197         my $cs_table = config::copy_status->table;
1198         my $cl_table = asset::copy_location->table;
1199
1200
1201         my $select = <<"        SQL";
1202                 SELECT  m.metarecord,
1203                         SUM( $rank_list ),
1204                         CASE WHEN COUNT(DISTINCT rd.record) = 1 THEN MIN(m.source) ELSE 0 END
1205                 FROM    $search_table_list
1206                         $metabib_metarecord_source_map_table m,
1207                         $metabib_metarecord_source_map_table mr,
1208                         $metabib_record_descriptor rd
1209                 WHERE   m.metarecord = mr.metarecord
1210                         $fts_list
1211                         $join_table_list
1212                         AND rd.record = m.source
1213                         $t_filter
1214                         $f_filter
1215                 GROUP BY m.metarecord
1216                 ORDER BY 2 DESC
1217                 LIMIT 10000
1218         SQL
1219
1220         if ($self->api_name !~ /staff/o) {
1221                 $select = <<"           SQL";
1222
1223                         SELECT  DISTINCT s.*
1224                           FROM  $asset_call_number_table cn,
1225                                 $metabib_metarecord_source_map_table mrs,
1226                                 $asset_copy_table cp,
1227                                 $cs_table cs,
1228                                 $cl_table cl,
1229                                 $descendants d,
1230                                 $metabib_record_descriptor ord,
1231                                 ($select) s
1232                           WHERE mrs.metarecord = s.metarecord
1233                                 AND cn.record = mrs.source
1234                                 AND cp.status = cs.id
1235                                 AND cp.location = cl.id
1236                                 AND cn.owning_lib = d.id
1237                                 AND cp.call_number = cn.id
1238                                 AND cp.opac_visible IS TRUE
1239                                 AND cs.holdable IS TRUE
1240                                 AND cl.opac_visible IS TRUE
1241                                 AND ord.record = mrs.source
1242                                 $ot_filter
1243                                 $of_filter
1244                           ORDER BY 2 DESC
1245                 SQL
1246         }
1247
1248
1249         $log->debug("Field Search SQL :: [$select]",DEBUG);
1250
1251         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
1252                         $select, {},
1253                         @types, @forms,  ($self->api_name !~ /staff/o ? (@types, @forms) : () ) );
1254         
1255         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1256
1257         my $count = scalar(@$recs);
1258         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1259                 next unless ($$rec[0]);
1260                 my ($mrid,$rank,$skip) = @$rec;
1261                 $client->respond( [$mrid, sprintf('%0.3f',$rank), $skip, $count] );
1262         }
1263         return undef;
1264 }
1265
1266 __PACKAGE__->register_method(
1267         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord",
1268         method          => 'postfilter_search_multi_class_fts',
1269         api_level       => 1,
1270         stream          => 1,
1271         cachable        => 1,
1272 );
1273 __PACKAGE__->register_method(
1274         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord.staff",
1275         method          => 'postfilter_search_multi_class_fts',
1276         api_level       => 1,
1277         stream          => 1,
1278         cachable        => 1,
1279 );
1280
1281
1282
1283
1284 1;