30efda645ec990603befe473d5a310a1f6e64c48
[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 OpenSRF::Utils::JSON;
10 use Data::Dumper;
11 use Digest::MD5 qw/md5_hex/;
12
13
14 my $log = 'OpenSRF::Utils::Logger';
15
16 $VERSION = 1;
17
18 sub ordered_records_from_metarecord {
19         my $self = shift;
20         my $client = shift;
21         my $mr = shift;
22         my $formats = shift;
23         my $org = shift || 1;
24         my $depth = shift;
25
26         my (@types,@forms);
27
28         if ($formats) {
29                 my ($t, $f) = split '-', $formats;
30                 @types = split '', $t;
31                 @forms = split '', $f;
32         }
33
34         my $descendants =
35                 defined($depth) ?
36                         "actor.org_unit_descendants($org, $depth)" :
37                         "actor.org_unit_descendants($org)" ;
38
39
40         my $copies_visible = 'AND d.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
41         $copies_visible = '' if ($self->api_name =~ /staff/o);
42
43         my $sm_table = metabib::metarecord_source_map->table;
44         my $rd_table = metabib::record_descriptor->table;
45         my $fr_table = metabib::full_rec->table;
46         my $cn_table = asset::call_number->table;
47         my $cl_table = asset::copy_location->table;
48         my $cp_table = asset::copy->table;
49         my $cs_table = config::copy_status->table;
50         my $src_table = config::bib_source->table;
51         my $out_table = actor::org_unit_type->table;
52         my $br_table = biblio::record_entry->table;
53
54         my $sql = <<"   SQL";
55                 SELECT  record,
56                         item_type,
57                         item_form,
58                         quality,
59                         FIRST(COALESCE(LTRIM(SUBSTR( value, COALESCE(SUBSTRING(ind2 FROM '\\\\d+'),'0')::INT + 1 )),'zzzzzzzz')) AS title
60                 FROM    (
61                         SELECT  rd.record,
62                                 rd.item_type,
63                                 rd.item_form,
64                                 br.quality,
65                                 fr.tag,
66                                 fr.subfield,
67                                 fr.value,
68                                 fr.ind2
69         SQL
70
71         if ($copies_visible) {
72                 $sql .= <<"             SQL";
73                           FROM  $sm_table sm,
74                                 $br_table br,
75                                 $fr_table fr,
76                                 $rd_table rd
77                           WHERE rd.record = sm.source
78                                 AND fr.record = sm.source
79                                 AND br.id = sm.source
80                                 AND sm.metarecord = ?
81                                 AND (EXISTS ((SELECT    1
82                                                 FROM    $cp_table cp
83                                                         JOIN $cn_table cn ON (cp.call_number = cn.id)
84                                                         JOIN $cs_table cs ON (cp.status = cs.id)
85                                                         JOIN $cl_table cl ON (cp.location = cl.id)
86                                                         JOIN $descendants d ON (cp.circ_lib = d.id)
87                                                 WHERE   cn.record = sm.source
88                                                         $copies_visible
89                                                 LIMIT 1))
90                                         OR EXISTS ((
91                                             SELECT      1
92                                               FROM      $src_table src
93                                               WHERE     src.id = br.source
94                                                         AND src.transcendant IS TRUE))
95                                 )
96                                           
97                 SQL
98         } else {
99                 $sql .= <<"             SQL";
100                           FROM  $sm_table sm
101                                 JOIN $br_table br ON (sm.source = br.id)
102                                 JOIN $fr_table fr ON (fr.record = br.id)
103                                 JOIN $rd_table rd ON (rd.record = br.id)
104                           WHERE sm.metarecord = ?
105                                 AND ((  EXISTS (
106                                                 SELECT  1
107                                                   FROM  $cp_table cp,
108                                                         $cn_table cn,
109                                                         $descendants d
110                                                   WHERE cn.record = br.id
111                                                         AND cn.deleted = FALSE
112                                                         AND cp.deleted = FALSE
113                                                         AND cp.circ_lib = d.id
114                                                         AND cn.id = cp.call_number
115                                                   LIMIT 1
116                                         ) OR NOT EXISTS (
117                                                 SELECT  1
118                                                   FROM  $cp_table cp,
119                                                         $cn_table cn
120                                                   WHERE cn.record = br.id
121                                                         AND cn.deleted = FALSE
122                                                         AND cp.deleted = FALSE
123                                                         AND cn.id = cp.call_number
124                                                   LIMIT 1
125                                         ))
126                                         OR EXISTS ((
127                                             SELECT      1
128                                               FROM      $src_table src
129                                               WHERE     src.id = br.source
130                                                         AND src.transcendant IS TRUE))
131                                 )
132                 SQL
133         }
134
135         if (@types) {
136                 $sql .= '                               AND rd.item_type IN ('.join(',',map{'?'}@types).')';
137         }
138
139         if (@forms) {
140                 $sql .= '                               AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
141         }
142
143
144
145         $sql .= <<"     SQL";
146                           OFFSET 0
147                         ) AS x
148           WHERE tag = '245'
149                 AND subfield = 'a'
150           GROUP BY record, item_type, item_form, quality
151           ORDER BY
152                 CASE
153                         WHEN item_type IS NULL -- default
154                                 THEN 0
155                         WHEN item_type = '' -- default
156                                 THEN 0
157                         WHEN item_type IN ('a','t') -- books
158                                 THEN 1
159                         WHEN item_type = 'g' -- movies
160                                 THEN 2
161                         WHEN item_type IN ('i','j') -- sound recordings
162                                 THEN 3
163                         WHEN item_type = 'm' -- software
164                                 THEN 4
165                         WHEN item_type = 'k' -- images
166                                 THEN 5
167                         WHEN item_type IN ('e','f') -- maps
168                                 THEN 6
169                         WHEN item_type IN ('o','p') -- mixed
170                                 THEN 7
171                         WHEN item_type IN ('c','d') -- music
172                                 THEN 8
173                         WHEN item_type = 'r' -- 3d
174                                 THEN 9
175                 END,
176                 title ASC,
177                 quality DESC
178         SQL
179
180         my $ids = metabib::metarecord_source_map->db_Main->selectcol_arrayref($sql, {}, "$mr", @types, @forms);
181         return $ids if ($self->api_name =~ /atomic$/o);
182
183         $client->respond( $_ ) for ( @$ids );
184         return undef;
185
186 }
187 __PACKAGE__->register_method(
188         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records',
189         method          => 'ordered_records_from_metarecord',
190         api_level       => 1,
191         cachable        => 1,
192 );
193 __PACKAGE__->register_method(
194         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.staff',
195         method          => 'ordered_records_from_metarecord',
196         api_level       => 1,
197         cachable        => 1,
198 );
199
200 __PACKAGE__->register_method(
201         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.atomic',
202         method          => 'ordered_records_from_metarecord',
203         api_level       => 1,
204         cachable        => 1,
205 );
206 __PACKAGE__->register_method(
207         api_name        => 'open-ils.storage.ordered.metabib.metarecord.records.staff.atomic',
208         method          => 'ordered_records_from_metarecord',
209         api_level       => 1,
210         cachable        => 1,
211 );
212
213 sub isxn_search {
214         my $self = shift;
215         my $client = shift;
216         my $isxn = lc(shift());
217
218         $isxn =~ s/^\s*//o;
219         $isxn =~ s/\s*$//o;
220         $isxn =~ s/-//o if ($self->api_name =~ /isbn/o);
221
222         my $tag = ($self->api_name =~ /isbn/o) ? "'020' OR f.tag = '024'" : "'022'";
223
224         my $fr_table = metabib::full_rec->table;
225         my $bib_table = biblio::record_entry->table;
226
227         my $sql = <<"   SQL";
228                 SELECT  DISTINCT f.record
229                   FROM  $fr_table f
230                         JOIN $bib_table b ON (b.id = f.record)
231                   WHERE (f.tag = $tag)
232                         AND f.value LIKE ?
233                         AND b.deleted IS FALSE
234         SQL
235
236         my $list = metabib::full_rec->db_Main->selectcol_arrayref($sql, {}, "$isxn%");
237         $client->respond($_) for (@$list);
238         return undef;
239 }
240 __PACKAGE__->register_method(
241         api_name        => 'open-ils.storage.id_list.biblio.record_entry.search.isbn',
242         method          => 'isxn_search',
243         api_level       => 1,
244         stream          => 1,
245 );
246 __PACKAGE__->register_method(
247         api_name        => 'open-ils.storage.id_list.biblio.record_entry.search.issn',
248         method          => 'isxn_search',
249         api_level       => 1,
250         stream          => 1,
251 );
252
253 sub metarecord_copy_count {
254         my $self = shift;
255         my $client = shift;
256
257         my %args = @_;
258
259         my $sm_table = metabib::metarecord_source_map->table;
260         my $rd_table = metabib::record_descriptor->table;
261         my $cn_table = asset::call_number->table;
262         my $cp_table = asset::copy->table;
263         my $br_table = biblio::record_entry->table;
264         my $src_table = config::bib_source->table;
265         my $cl_table = asset::copy_location->table;
266         my $cs_table = config::copy_status->table;
267         my $out_table = actor::org_unit_type->table;
268         my $descendants = "actor.org_unit_descendants(u.id)";
269         my $ancestors = "actor.org_unit_ancestors(?)";
270
271         my $copies_visible = 'AND a.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
272         $copies_visible = '' if ($self->api_name =~ /staff/o);
273
274         my (@types,@forms);
275         my ($t_filter, $f_filter) = ('','');
276
277         if ($args{format}) {
278                 my ($t, $f) = split '-', $args{format};
279                 @types = split '', $t;
280                 @forms = split '', $f;
281                 if (@types) {
282                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
283                 }
284
285                 if (@forms) {
286                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
287                 }
288         }
289
290         my $sql = <<"   SQL";
291                 SELECT  t.depth,
292                         u.id AS org_unit,
293                         sum(
294                                 (SELECT count(cp.id)
295                                   FROM  $sm_table r
296                                         JOIN $cn_table cn ON (cn.record = r.source)
297                                         JOIN $rd_table rd ON (cn.record = rd.record)
298                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
299                                         JOIN $cs_table cs ON (cp.status = cs.id)
300                                         JOIN $cl_table cl ON (cp.location = cl.id)
301                                         JOIN $descendants a ON (cp.circ_lib = a.id)
302                                   WHERE r.metarecord = ?
303                                         AND cn.deleted IS FALSE
304                                         AND cp.deleted IS FALSE
305                                         $copies_visible
306                                         $t_filter
307                                         $f_filter
308                                 )
309                         ) AS count,
310                         sum(
311                                 (SELECT count(cp.id)
312                                   FROM  $sm_table r
313                                         JOIN $cn_table cn ON (cn.record = r.source)
314                                         JOIN $rd_table rd ON (cn.record = rd.record)
315                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
316                                         JOIN $cs_table cs ON (cp.status = cs.id)
317                                         JOIN $cl_table cl ON (cp.location = cl.id)
318                                         JOIN $descendants a ON (cp.circ_lib = a.id)
319                                   WHERE r.metarecord = ?
320                                         AND cp.status IN (0,7)
321                                         AND cn.deleted IS FALSE
322                                         AND cp.deleted IS FALSE
323                                         $copies_visible
324                                         $t_filter
325                                         $f_filter
326                                 )
327                         ) AS available,
328                         sum(
329                                 (SELECT count(cp.id)
330                                   FROM  $sm_table r
331                                         JOIN $cn_table cn ON (cn.record = r.source)
332                                         JOIN $rd_table rd ON (cn.record = rd.record)
333                                         JOIN $cp_table cp ON (cn.id = cp.call_number)
334                                         JOIN $cs_table cs ON (cp.status = cs.id)
335                                         JOIN $cl_table cl ON (cp.location = cl.id)
336                                   WHERE r.metarecord = ?
337                                         AND cn.deleted IS FALSE
338                                         AND cp.deleted IS FALSE
339                                         AND cp.opac_visible IS TRUE
340                                         AND cs.holdable IS TRUE
341                                         AND cl.opac_visible IS TRUE
342                                         $t_filter
343                                         $f_filter
344                                 )
345                         ) AS unshadow,
346                         sum(    
347                                 (SELECT sum(1)
348                                   FROM  $sm_table r
349                                         JOIN $br_table br ON (br.id = r.source)
350                                         JOIN $src_table src ON (src.id = br.source)
351                                   WHERE r.metarecord = ?
352                                         AND src.transcendant IS TRUE
353                                 )
354                         ) AS transcendant
355
356                   FROM  $ancestors u
357                         JOIN $out_table t ON (u.ou_type = t.id)
358                   GROUP BY 1,2
359         SQL
360
361         my $sth = metabib::metarecord_source_map->db_Main->prepare_cached($sql);
362         $sth->execute(  ''.$args{metarecord},
363                         @types, 
364                         @forms,
365                         ''.$args{metarecord},
366                         @types, 
367                         @forms,
368                         ''.$args{metarecord},
369                         @types, 
370                         @forms,
371                         ''.$args{metarecord},
372                         ''.$args{org_unit}, 
373         ); 
374
375         while ( my $row = $sth->fetchrow_hashref ) {
376                 $client->respond( $row );
377         }
378         return undef;
379 }
380 __PACKAGE__->register_method(
381         api_name        => 'open-ils.storage.metabib.metarecord.copy_count',
382         method          => 'metarecord_copy_count',
383         api_level       => 1,
384         stream          => 1,
385         cachable        => 1,
386 );
387 __PACKAGE__->register_method(
388         api_name        => 'open-ils.storage.metabib.metarecord.copy_count.staff',
389         method          => 'metarecord_copy_count',
390         api_level       => 1,
391         stream          => 1,
392         cachable        => 1,
393 );
394
395 sub biblio_multi_search_full_rec {
396         my $self = shift;
397         my $client = shift;
398
399         my %args = @_;  
400         my $class_join = $args{class_join} || 'AND';
401         my $limit = $args{limit} || 100;
402         my $offset = $args{offset} || 0;
403         my $sort = $args{'sort'};
404         my $sort_dir = $args{sort_dir} || 'DESC';
405
406         my @binds;
407         my @selects;
408
409         for my $arg (@{ $args{searches} }) {
410                 my $term = $$arg{term};
411                 my $limiters = $$arg{restrict};
412
413                 my ($index_col) = metabib::full_rec->columns('FTS');
414                 $index_col ||= 'value';
415                 my $search_table = metabib::full_rec->table;
416
417                 my $fts = OpenILS::Application::Storage::FTS->compile('default' => $term, 'value',"$index_col");
418
419                 my $fts_where = $fts->sql_where_clause();
420                 my @fts_ranks = $fts->fts_rank;
421
422                 my $rank = join(' + ', @fts_ranks);
423
424                 my @wheres;
425                 for my $limit (@$limiters) {
426                         push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
427                         push @binds, $$limit{tag}, $$limit{subfield};
428                         $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
429                 }
430                 my $where = join(' OR ', @wheres);
431
432                 push @selects, "SELECT id, record, $rank as sum FROM $search_table WHERE $where";
433
434         }
435
436         my $descendants = defined($args{depth}) ?
437                                 "actor.org_unit_descendants($args{org_unit}, $args{depth})" :
438                                 "actor.org_unit_descendants($args{org_unit})" ;
439
440
441         my $metabib_record_descriptor = metabib::record_descriptor->table;
442         my $metabib_full_rec = metabib::full_rec->table;
443         my $asset_call_number_table = asset::call_number->table;
444         my $asset_copy_table = asset::copy->table;
445         my $cs_table = config::copy_status->table;
446         my $cl_table = asset::copy_location->table;
447         my $br_table = biblio::record_entry->table;
448
449         my $cj = 'HAVING COUNT(x.id) = ' . scalar(@selects) if ($class_join eq 'AND');
450         my $search_table =
451                 '(SELECT x.record, sum(x.sum) FROM (('.
452                         join(') UNION ALL (', @selects).
453                         ")) x GROUP BY 1 $cj ORDER BY 2 DESC )";
454
455         my $has_vols = 'AND cn.owning_lib = d.id';
456         my $has_copies = 'AND cp.call_number = cn.id';
457         my $copies_visible = 'AND d.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
458
459         if ($self->api_name =~ /staff/o) {
460                 $copies_visible = '';
461                 $has_copies = '' if ($ou_type == 0);
462                 $has_vols = '' if ($ou_type == 0);
463         }
464
465         my ($t_filter, $f_filter) = ('','');
466         my ($a_filter, $l_filter, $lf_filter) = ('','','');
467
468         if (my $a = $args{audience}) {
469                 $a = [$a] if (!ref($a));
470                 my @aud = @$a;
471                         
472                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
473                 push @binds, @aud;
474         }
475
476         if (my $l = $args{language}) {
477                 $l = [$l] if (!ref($l));
478                 my @lang = @$l;
479
480                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
481                 push @binds, @lang;
482         }
483
484         if (my $f = $args{lit_form}) {
485                 $f = [$f] if (!ref($f));
486                 my @lit_form = @$f;
487
488                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
489                 push @binds, @lit_form;
490         }
491
492         if (my $f = $args{item_form}) {
493                 $f = [$f] if (!ref($f));
494                 my @forms = @$f;
495
496                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
497                 push @binds, @forms;
498         }
499
500         if (my $t = $args{item_type}) {
501                 $t = [$t] if (!ref($t));
502                 my @types = @$t;
503
504                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
505                 push @binds, @types;
506         }
507
508
509         if ($args{format}) {
510                 my ($t, $f) = split '-', $args{format};
511                 my @types = split '', $t;
512                 my @forms = split '', $f;
513                 if (@types) {
514                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
515                 }
516
517                 if (@forms) {
518                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
519                 }
520                 push @binds, @types, @forms;
521         }
522
523         my $relevance = 'sum(f.sum)';
524         $relevance = 1 if (!$copies_visible);
525
526         my $rank = $relevance;
527         if (lc($sort) eq 'pubdate') {
528                 $rank = <<"             RANK";
529                         ( FIRST ((
530                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d+'),'9999')::INT
531                                   FROM  $metabib_full_rec frp
532                                   WHERE frp.record = f.record
533                                         AND frp.tag = '260'
534                                         AND frp.subfield = 'c'
535                                   LIMIT 1
536                         )) )
537                 RANK
538         } elsif (lc($sort) eq 'create_date') {
539                 $rank = <<"             RANK";
540                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = f.record)) )
541                 RANK
542         } elsif (lc($sort) eq 'edit_date') {
543                 $rank = <<"             RANK";
544                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = f.record)) )
545                 RANK
546         } elsif (lc($sort) eq 'title') {
547                 $rank = <<"             RANK";
548                         ( FIRST ((
549                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT + 1 )),'zzzzzzzz')
550                                   FROM  $metabib_full_rec frt
551                                   WHERE frt.record = f.record
552                                         AND frt.tag = '245'
553                                         AND frt.subfield = 'a'
554                                   LIMIT 1
555                         )) )
556                 RANK
557         } elsif (lc($sort) eq 'author') {
558                 $rank = <<"             RANK";
559                         ( FIRST((
560                                 SELECT  COALESCE(LTRIM(fra.value),'zzzzzzzz')
561                                   FROM  $metabib_full_rec fra
562                                   WHERE fra.record = f.record
563                                         AND fra.tag LIKE '1%'
564                                         AND fra.subfield = 'a'
565                                   ORDER BY fra.tag::text::int
566                                   LIMIT 1
567                         )) )
568                 RANK
569         } else {
570                 $sort = undef;
571         }
572
573
574         if ($copies_visible) {
575                 $select = <<"           SQL";
576                         SELECT  f.record, $relevance, count(DISTINCT cp.id), $rank
577                         FROM    $search_table f,
578                                 $asset_call_number_table cn,
579                                 $asset_copy_table cp,
580                                 $cs_table cs,
581                                 $cl_table cl,
582                                 $br_table br,
583                                 $metabib_record_descriptor rd,
584                                 $descendants d
585                         WHERE   br.id = f.record
586                                 AND cn.record = f.record
587                                 AND rd.record = f.record
588                                 AND cp.status = cs.id
589                                 AND cp.location = cl.id
590                                 AND br.deleted IS FALSE
591                                 AND cn.deleted IS FALSE
592                                 AND cp.deleted IS FALSE
593                                 $has_vols
594                                 $has_copies
595                                 $copies_visible
596                                 $t_filter
597                                 $f_filter
598                                 $a_filter
599                                 $l_filter
600                                 $lf_filter
601                         GROUP BY f.record HAVING count(DISTINCT cp.id) > 0
602                         ORDER BY 4 $sort_dir,3 DESC
603                 SQL
604         } else {
605                 $select = <<"           SQL";
606                         SELECT  f.record, 1, 1, $rank
607                         FROM    $search_table f,
608                                 $br_table br,
609                                 $metabib_record_descriptor rd
610                         WHERE   br.id = f.record
611                                 AND rd.record = f.record
612                                 AND br.deleted IS FALSE
613                                 $t_filter
614                                 $f_filter
615                                 $a_filter
616                                 $l_filter
617                                 $lf_filter
618                         GROUP BY 1,2,3 
619                         ORDER BY 4 $sort_dir
620                 SQL
621         }
622
623
624         $log->debug("Search SQL :: [$select]",DEBUG);
625
626         my $recs = metabib::full_rec->db_Main->selectall_arrayref("$select;", {}, @binds);
627         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
628
629         my $max = 0;
630         $max = 1 if (!@$recs);
631         for (@$recs) {
632                 $max = $$_[1] if ($$_[1] > $max);
633         }
634
635         my $count = @$recs;
636         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
637                 next unless ($$rec[0]);
638                 my ($rid,$rank,$junk,$skip) = @$rec;
639                 $client->respond( [$rid, sprintf('%0.3f',$rank/$max), $count] );
640         }
641         return undef;
642 }
643 __PACKAGE__->register_method(
644         api_name        => 'open-ils.storage.biblio.full_rec.multi_search',
645         method          => 'biblio_multi_search_full_rec',
646         api_level       => 1,
647         stream          => 1,
648         cachable        => 1,
649 );
650 __PACKAGE__->register_method(
651         api_name        => 'open-ils.storage.biblio.full_rec.multi_search.staff',
652         method          => 'biblio_multi_search_full_rec',
653         api_level       => 1,
654         stream          => 1,
655         cachable        => 1,
656 );
657
658 sub search_full_rec {
659         my $self = shift;
660         my $client = shift;
661
662         my %args = @_;
663         
664         my $term = $args{term};
665         my $limiters = $args{restrict};
666
667         my ($index_col) = metabib::full_rec->columns('FTS');
668         $index_col ||= 'value';
669         my $search_table = metabib::full_rec->table;
670
671         my $fts = OpenILS::Application::Storage::FTS->compile('default' => $term, 'value',"$index_col");
672
673         my $fts_where = $fts->sql_where_clause();
674         my @fts_ranks = $fts->fts_rank;
675
676         my $rank = join(' + ', @fts_ranks);
677
678         my @binds;
679         my @wheres;
680         for my $limit (@$limiters) {
681                 push @wheres, "( tag = ? AND subfield LIKE ? AND $fts_where )";
682                 push @binds, $$limit{tag}, $$limit{subfield};
683                 $log->debug("Limiting query using { tag => $$limit{tag}, subfield => $$limit{subfield} }", DEBUG);
684         }
685         my $where = join(' OR ', @wheres);
686
687         my $select = "SELECT record, sum($rank) FROM $search_table WHERE $where GROUP BY 1 ORDER BY 2 DESC;";
688
689         $log->debug("Search SQL :: [$select]",DEBUG);
690
691         my $recs = metabib::full_rec->db_Main->selectall_arrayref($select, {}, @binds);
692         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
693
694         $client->respond($_) for (@$recs);
695         return undef;
696 }
697 __PACKAGE__->register_method(
698         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.value',
699         method          => 'search_full_rec',
700         api_level       => 1,
701         stream          => 1,
702         cachable        => 1,
703 );
704 __PACKAGE__->register_method(
705         api_name        => 'open-ils.storage.direct.metabib.full_rec.search_fts.index_vector',
706         method          => 'search_full_rec',
707         api_level       => 1,
708         stream          => 1,
709         cachable        => 1,
710 );
711
712
713 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
714 sub search_class_fts {
715         my $self = shift;
716         my $client = shift;
717         my %args = @_;
718         
719         my $term = $args{term};
720         my $ou = $args{org_unit};
721         my $ou_type = $args{depth};
722         my $limit = $args{limit};
723         my $offset = $args{offset};
724
725         my $limit_clause = '';
726         my $offset_clause = '';
727
728         $limit_clause = "LIMIT $limit" if (defined $limit and int($limit) > 0);
729         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
730
731         my (@types,@forms);
732         my ($t_filter, $f_filter) = ('','');
733
734         if ($args{format}) {
735                 my ($t, $f) = split '-', $args{format};
736                 @types = split '', $t;
737                 @forms = split '', $f;
738                 if (@types) {
739                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
740                 }
741
742                 if (@forms) {
743                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
744                 }
745         }
746
747
748
749         my $descendants = defined($ou_type) ?
750                                 "actor.org_unit_descendants($ou, $ou_type)" :
751                                 "actor.org_unit_descendants($ou)";
752
753         my $class = $self->{cdbi};
754         my $search_table = $class->table;
755
756         my $metabib_record_descriptor = metabib::record_descriptor->table;
757         my $metabib_metarecord = metabib::metarecord->table;
758         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
759         my $asset_call_number_table = asset::call_number->table;
760         my $asset_copy_table = asset::copy->table;
761         my $cs_table = config::copy_status->table;
762         my $cl_table = asset::copy_location->table;
763
764         my ($index_col) = $class->columns('FTS');
765         $index_col ||= 'value';
766
767         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
768         my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $term, 'f.value', "f.$index_col");
769
770         my $fts_where = $fts->sql_where_clause;
771         my @fts_ranks = $fts->fts_rank;
772
773         my $rank = join(' + ', @fts_ranks);
774
775         my $has_vols = 'AND cn.owning_lib = d.id';
776         my $has_copies = 'AND cp.call_number = cn.id';
777         my $copies_visible = 'AND d.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
778
779         my $visible_count = ', count(DISTINCT cp.id)';
780         my $visible_count_test = 'HAVING count(DISTINCT cp.id) > 0';
781
782         if ($self->api_name =~ /staff/o) {
783                 $copies_visible = '';
784                 $visible_count_test = '';
785                 $has_copies = '' if ($ou_type == 0);
786                 $has_vols = '' if ($ou_type == 0);
787         }
788
789         my $rank_calc = <<"     RANK";
790                 , (SUM( $rank
791                         * CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END -- phrase order
792                         * CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END -- first word match
793                         * CASE WHEN f.value ~* ? THEN 2 ELSE 1 END -- only word match
794                 )/COUNT(m.source)), MIN(COALESCE(CHAR_LENGTH(f.value),1))
795         RANK
796
797         $rank_calc = ',1 , 1' if ($self->api_name =~ /unordered/o);
798
799         if ($copies_visible) {
800                 $select = <<"           SQL";
801                         SELECT  m.metarecord $rank_calc $visible_count, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
802                         FROM    $search_table f,
803                                 $metabib_metarecord_source_map_table m,
804                                 $asset_call_number_table cn,
805                                 $asset_copy_table cp,
806                                 $cs_table cs,
807                                 $cl_table cl,
808                                 $metabib_record_descriptor rd,
809                                 $descendants d
810                         WHERE   $fts_where
811                                 AND m.source = f.source
812                                 AND cn.record = m.source
813                                 AND rd.record = m.source
814                                 AND cp.status = cs.id
815                                 AND cp.location = cl.id
816                                 $has_vols
817                                 $has_copies
818                                 $copies_visible
819                                 $t_filter
820                                 $f_filter
821                         GROUP BY 1 $visible_count_test
822                         ORDER BY 2 DESC,3
823                         $limit_clause $offset_clause
824                 SQL
825         } else {
826                 $select = <<"           SQL";
827                         SELECT  m.metarecord $rank_calc, 0, CASE WHEN COUNT(DISTINCT m.source) = 1 THEN MAX(m.source) ELSE MAX(0) END
828                         FROM    $search_table f,
829                                 $metabib_metarecord_source_map_table m,
830                                 $metabib_record_descriptor rd
831                         WHERE   $fts_where
832                                 AND m.source = f.source
833                                 AND rd.record = m.source
834                                 $t_filter
835                                 $f_filter
836                         GROUP BY 1, 4
837                         ORDER BY 2 DESC,3
838                         $limit_clause $offset_clause
839                 SQL
840         }
841
842         $log->debug("Field Search SQL :: [$select]",DEBUG);
843
844         my $SQLstring = join('%',$fts->words);
845         my $REstring = join('\\s+',$fts->words);
846         my $first_word = ($fts->words)[0].'%';
847         my $recs = ($self->api_name =~ /unordered/o) ? 
848                         $class->db_Main->selectall_arrayref($select, {}, @types, @forms) :
849                         $class->db_Main->selectall_arrayref($select, {},
850                                 '%'.lc($SQLstring).'%',                 # phrase order match
851                                 lc($first_word),                        # first word match
852                                 '^\\s*'.lc($REstring).'\\s*/?\s*$',     # full exact match
853                                 @types, @forms
854                         );
855         
856         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
857
858         $client->respond($_) for (map { [@$_[0,1,3,4]] } @$recs);
859         return undef;
860 }
861
862 for my $class ( qw/title author subject keyword series/ ) {
863         __PACKAGE__->register_method(
864                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord",
865                 method          => 'search_class_fts',
866                 api_level       => 1,
867                 stream          => 1,
868                 cdbi            => "metabib::${class}_field_entry",
869                 cachable        => 1,
870         );
871         __PACKAGE__->register_method(
872                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.unordered",
873                 method          => 'search_class_fts',
874                 api_level       => 1,
875                 stream          => 1,
876                 cdbi            => "metabib::${class}_field_entry",
877                 cachable        => 1,
878         );
879         __PACKAGE__->register_method(
880                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff",
881                 method          => 'search_class_fts',
882                 api_level       => 1,
883                 stream          => 1,
884                 cdbi            => "metabib::${class}_field_entry",
885                 cachable        => 1,
886         );
887         __PACKAGE__->register_method(
888                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord.staff.unordered",
889                 method          => 'search_class_fts',
890                 api_level       => 1,
891                 stream          => 1,
892                 cdbi            => "metabib::${class}_field_entry",
893                 cachable        => 1,
894         );
895 }
896
897 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
898 sub search_class_fts_count {
899         my $self = shift;
900         my $client = shift;
901         my %args = @_;
902         
903         my $term = $args{term};
904         my $ou = $args{org_unit};
905         my $ou_type = $args{depth};
906         my $limit = $args{limit} || 100;
907         my $offset = $args{offset} || 0;
908
909         my $descendants = defined($ou_type) ?
910                                 "actor.org_unit_descendants($ou, $ou_type)" :
911                                 "actor.org_unit_descendants($ou)";
912                 
913         my (@types,@forms);
914         my ($t_filter, $f_filter) = ('','');
915
916         if ($args{format}) {
917                 my ($t, $f) = split '-', $args{format};
918                 @types = split '', $t;
919                 @forms = split '', $f;
920                 if (@types) {
921                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
922                 }
923
924                 if (@forms) {
925                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
926                 }
927         }
928
929
930         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).search_fts.*/$1/o;
931
932         my $class = $self->{cdbi};
933         my $search_table = $class->table;
934
935         my $metabib_record_descriptor = metabib::record_descriptor->table;
936         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
937         my $asset_call_number_table = asset::call_number->table;
938         my $asset_copy_table = asset::copy->table;
939         my $cs_table = config::copy_status->table;
940         my $cl_table = asset::copy_location->table;
941
942         my ($index_col) = $class->columns('FTS');
943         $index_col ||= 'value';
944
945         my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $term, 'value',"$index_col");
946
947         my $fts_where = $fts->sql_where_clause;
948
949         my $has_vols = 'AND cn.owning_lib = d.id';
950         my $has_copies = 'AND cp.call_number = cn.id';
951         my $copies_visible = 'AND d.opac_visible IS TRUE AND cp.opac_visible IS TRUE AND cs.holdable IS TRUE AND cl.opac_visible IS TRUE';
952         if ($self->api_name =~ /staff/o) {
953                 $copies_visible = '';
954                 $has_vols = '' if ($ou_type == 0);
955                 $has_copies = '' if ($ou_type == 0);
956         }
957
958         # XXX test an "EXISTS version of descendant checking...
959         my $select;
960         if ($copies_visible) {
961                 $select = <<"           SQL";
962                 SELECT  count(distinct  m.metarecord)
963                   FROM  $search_table f,
964                         $metabib_metarecord_source_map_table m,
965                         $metabib_metarecord_source_map_table mr,
966                         $asset_call_number_table cn,
967                         $asset_copy_table cp,
968                         $cs_table cs,
969                         $cl_table cl,
970                         $metabib_record_descriptor rd,
971                         $descendants d
972                   WHERE $fts_where
973                         AND mr.source = f.source
974                         AND mr.metarecord = m.metarecord
975                         AND cn.record = m.source
976                         AND rd.record = m.source
977                         AND cp.status = cs.id
978                         AND cp.location = cl.id
979                         $has_vols
980                         $has_copies
981                         $copies_visible
982                         $t_filter
983                         $f_filter
984                 SQL
985         } else {
986                 $select = <<"           SQL";
987                 SELECT  count(distinct  m.metarecord)
988                   FROM  $search_table f,
989                         $metabib_metarecord_source_map_table m,
990                         $metabib_metarecord_source_map_table mr,
991                         $metabib_record_descriptor rd
992                   WHERE $fts_where
993                         AND mr.source = f.source
994                         AND mr.metarecord = m.metarecord
995                         AND rd.record = m.source
996                         $t_filter
997                         $f_filter
998                 SQL
999         }
1000
1001         $log->debug("Field Search Count SQL :: [$select]",DEBUG);
1002
1003         my $recs = $class->db_Main->selectrow_arrayref($select, {}, @types, @forms)->[0];
1004         
1005         $log->debug("Count Search yielded $recs results.",DEBUG);
1006
1007         return $recs;
1008
1009 }
1010 for my $class ( qw/title author subject keyword series/ ) {
1011         __PACKAGE__->register_method(
1012                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count",
1013                 method          => 'search_class_fts_count',
1014                 api_level       => 1,
1015                 stream          => 1,
1016                 cdbi            => "metabib::${class}_field_entry",
1017                 cachable        => 1,
1018         );
1019         __PACKAGE__->register_method(
1020                 api_name        => "open-ils.storage.metabib.$class.search_fts.metarecord_count.staff",
1021                 method          => 'search_class_fts_count',
1022                 api_level       => 1,
1023                 stream          => 1,
1024                 cdbi            => "metabib::${class}_field_entry",
1025                 cachable        => 1,
1026         );
1027 }
1028
1029
1030 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1031 sub postfilter_search_class_fts {
1032         my $self = shift;
1033         my $client = shift;
1034         my %args = @_;
1035         
1036         my $term = $args{term};
1037         my $sort = $args{'sort'};
1038         my $sort_dir = $args{sort_dir} || 'DESC';
1039         my $ou = $args{org_unit};
1040         my $ou_type = $args{depth};
1041         my $limit = $args{limit} || 10;
1042         my $visibility_limit = $args{visibility_limit} || 5000;
1043         my $offset = $args{offset} || 0;
1044
1045         my $outer_limit = 1000;
1046
1047         my $limit_clause = '';
1048         my $offset_clause = '';
1049
1050         $limit_clause = "LIMIT $outer_limit";
1051         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1052
1053         my (@types,@forms,@lang,@aud,@lit_form);
1054         my ($t_filter, $f_filter) = ('','');
1055         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1056         my ($ot_filter, $of_filter) = ('','');
1057         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1058
1059         if (my $a = $args{audience}) {
1060                 $a = [$a] if (!ref($a));
1061                 @aud = @$a;
1062                         
1063                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1064                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1065         }
1066
1067         if (my $l = $args{language}) {
1068                 $l = [$l] if (!ref($l));
1069                 @lang = @$l;
1070
1071                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1072                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1073         }
1074
1075         if (my $f = $args{lit_form}) {
1076                 $f = [$f] if (!ref($f));
1077                 @lit_form = @$f;
1078
1079                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1080                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1081         }
1082
1083         if ($args{format}) {
1084                 my ($t, $f) = split '-', $args{format};
1085                 @types = split '', $t;
1086                 @forms = split '', $f;
1087                 if (@types) {
1088                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1089                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1090                 }
1091
1092                 if (@forms) {
1093                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1094                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1095                 }
1096         }
1097
1098
1099         my $descendants = defined($ou_type) ?
1100                                 "actor.org_unit_descendants($ou, $ou_type)" :
1101                                 "actor.org_unit_descendants($ou)";
1102
1103         my $class = $self->{cdbi};
1104         my $search_table = $class->table;
1105
1106         my $metabib_full_rec = metabib::full_rec->table;
1107         my $metabib_record_descriptor = metabib::record_descriptor->table;
1108         my $metabib_metarecord = metabib::metarecord->table;
1109         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1110         my $asset_call_number_table = asset::call_number->table;
1111         my $asset_copy_table = asset::copy->table;
1112         my $cs_table = config::copy_status->table;
1113         my $cl_table = asset::copy_location->table;
1114         my $br_table = biblio::record_entry->table;
1115
1116         my ($index_col) = $class->columns('FTS');
1117         $index_col ||= 'value';
1118
1119         (my $search_class = $self->api_name) =~ s/.*metabib.(\w+).post_filter.*/$1/o;
1120
1121         my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $term, 'f.value', "f.$index_col");
1122
1123         my $SQLstring = join('%',map { lc($_) } $fts->words);
1124         my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1125         my $first_word = lc(($fts->words)[0]).'%';
1126
1127         my $fts_where = $fts->sql_where_clause;
1128         my @fts_ranks = $fts->fts_rank;
1129
1130         my %bonus = ();
1131         $bonus{'metabib::keyword_field_entry'} = [ { 'CASE WHEN f.value ILIKE ? THEN 1.2 ELSE 1 END' => $SQLstring } ];
1132         $bonus{'metabib::title_field_entry'} =
1133                 $bonus{'metabib::series_field_entry'} = [
1134                         { 'CASE WHEN f.value ILIKE ? THEN 1.5 ELSE 1 END' => $first_word },
1135                         { 'CASE WHEN f.value ~* ? THEN 2 ELSE 1 END' => $REstring },
1136                         @{ $bonus{'metabib::keyword_field_entry'} }
1137                 ];
1138
1139         my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$class} };
1140         $bonus_list ||= '1';
1141
1142         my @bonus_values = map { values %$_ } @{ $bonus{$class} };
1143
1144         my $relevance = join(' + ', @fts_ranks);
1145         $relevance = <<"        RANK";
1146                         (SUM( ( $relevance )  * ( $bonus_list ) )/COUNT(m.source))
1147         RANK
1148
1149         my $string_default_sort = 'zzzz';
1150         $string_default_sort = 'AAAA' if ($sort_dir eq 'DESC');
1151
1152         my $number_default_sort = '9999';
1153         $number_default_sort = '0000' if ($sort_dir eq 'DESC');
1154
1155         my $rank = $relevance;
1156         if (lc($sort) eq 'pubdate') {
1157                 $rank = <<"             RANK";
1158                         ( FIRST ((
1159                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d+'),'$number_default_sort')::INT
1160                                   FROM  $metabib_full_rec frp
1161                                   WHERE frp.record = mr.master_record
1162                                         AND frp.tag = '260'
1163                                         AND frp.subfield = 'c'
1164                                   LIMIT 1
1165                         )) )
1166                 RANK
1167         } elsif (lc($sort) eq 'create_date') {
1168                 $rank = <<"             RANK";
1169                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1170                 RANK
1171         } elsif (lc($sort) eq 'edit_date') {
1172                 $rank = <<"             RANK";
1173                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1174                 RANK
1175         } elsif (lc($sort) eq 'title') {
1176                 $rank = <<"             RANK";
1177                         ( FIRST ((
1178                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT + 1 )),'$string_default_sort')
1179                                   FROM  $metabib_full_rec frt
1180                                   WHERE frt.record = mr.master_record
1181                                         AND frt.tag = '245'
1182                                         AND frt.subfield = 'a'
1183                                   LIMIT 1
1184                         )) )
1185                 RANK
1186         } elsif (lc($sort) eq 'author') {
1187                 $rank = <<"             RANK";
1188                         ( FIRST((
1189                                 SELECT  COALESCE(LTRIM(fra.value),'$string_default_sort')
1190                                   FROM  $metabib_full_rec fra
1191                                   WHERE fra.record = mr.master_record
1192                                         AND fra.tag LIKE '1%'
1193                                         AND fra.subfield = 'a'
1194                                   ORDER BY fra.tag::text::int
1195                                   LIMIT 1
1196                         )) )
1197                 RANK
1198         } else {
1199                 $sort = undef;
1200         }
1201
1202         my $select = <<"        SQL";
1203                 SELECT  m.metarecord,
1204                         $relevance,
1205                         CASE WHEN COUNT(DISTINCT smrs.source) = 1 THEN MIN(m.source) ELSE 0 END,
1206                         $rank
1207                 FROM    $search_table f,
1208                         $metabib_metarecord_source_map_table m,
1209                         $metabib_metarecord_source_map_table smrs,
1210                         $metabib_metarecord mr,
1211                         $metabib_record_descriptor rd
1212                 WHERE   $fts_where
1213                         AND smrs.metarecord = mr.id
1214                         AND m.source = f.source
1215                         AND m.metarecord = mr.id
1216                         AND rd.record = smrs.source
1217                         $t_filter
1218                         $f_filter
1219                         $a_filter
1220                         $l_filter
1221                         $lf_filter
1222                 GROUP BY m.metarecord
1223                 ORDER BY 4 $sort_dir, MIN(COALESCE(CHAR_LENGTH(f.value),1))
1224                 LIMIT $visibility_limit
1225         SQL
1226
1227         if (0) {
1228                 $select = <<"           SQL";
1229
1230                         SELECT  DISTINCT s.*
1231                           FROM  $asset_call_number_table cn,
1232                                 $metabib_metarecord_source_map_table mrs,
1233                                 $asset_copy_table cp,
1234                                 $cs_table cs,
1235                                 $cl_table cl,
1236                                 $br_table br,
1237                                 $descendants d,
1238                                 $metabib_record_descriptor ord,
1239                                 ($select) s
1240                           WHERE mrs.metarecord = s.metarecord
1241                                 AND br.id = mrs.source
1242                                 AND cn.record = mrs.source
1243                                 AND cp.status = cs.id
1244                                 AND cp.location = cl.id
1245                                 AND cn.owning_lib = d.id
1246                                 AND cp.call_number = cn.id
1247                                 AND cp.opac_visible IS TRUE
1248                                 AND cs.holdable IS TRUE
1249                                 AND cl.opac_visible IS TRUE
1250                                 AND d.opac_visible IS TRUE
1251                                 AND br.active IS TRUE
1252                                 AND br.deleted IS FALSE
1253                                 AND ord.record = mrs.source
1254                                 $ot_filter
1255                                 $of_filter
1256                                 $oa_filter
1257                                 $ol_filter
1258                                 $olf_filter
1259                           ORDER BY 4 $sort_dir
1260                 SQL
1261         } elsif ($self->api_name !~ /staff/o) {
1262                 $select = <<"           SQL";
1263
1264                         SELECT  DISTINCT s.*
1265                           FROM  ($select) s
1266                           WHERE EXISTS (
1267                                 SELECT  1
1268                                   FROM  $asset_call_number_table cn,
1269                                         $metabib_metarecord_source_map_table mrs,
1270                                         $asset_copy_table cp,
1271                                         $cs_table cs,
1272                                         $cl_table cl,
1273                                         $br_table br,
1274                                         $descendants d,
1275                                         $metabib_record_descriptor ord
1276                                 
1277                                   WHERE mrs.metarecord = s.metarecord
1278                                         AND br.id = mrs.source
1279                                         AND cn.record = mrs.source
1280                                         AND cp.status = cs.id
1281                                         AND cp.location = cl.id
1282                                         AND cp.circ_lib = d.id
1283                                         AND cp.call_number = cn.id
1284                                         AND cp.opac_visible IS TRUE
1285                                         AND cs.holdable IS TRUE
1286                                         AND cl.opac_visible IS TRUE
1287                                         AND d.opac_visible IS TRUE
1288                                         AND br.active IS TRUE
1289                                         AND br.deleted IS FALSE
1290                                         AND ord.record = mrs.source
1291                                         $ot_filter
1292                                         $of_filter
1293                                         $oa_filter
1294                                         $ol_filter
1295                                         $olf_filter
1296                                   LIMIT 1
1297                                 )
1298                           ORDER BY 4 $sort_dir
1299                 SQL
1300         } else {
1301                 $select = <<"           SQL";
1302
1303                         SELECT  DISTINCT s.*
1304                           FROM  ($select) s
1305                           WHERE EXISTS (
1306                                 SELECT  1
1307                                   FROM  $asset_call_number_table cn,
1308                                         $asset_copy_table cp,
1309                                         $metabib_metarecord_source_map_table mrs,
1310                                         $br_table br,
1311                                         $descendants d,
1312                                         $metabib_record_descriptor ord
1313                                 
1314                                   WHERE mrs.metarecord = s.metarecord
1315                                         AND br.id = mrs.source
1316                                         AND cn.record = mrs.source
1317                                         AND cn.id = cp.call_number
1318                                         AND br.deleted IS FALSE
1319                                         AND cn.deleted IS FALSE
1320                                         AND ord.record = mrs.source
1321                                         AND (   cn.owning_lib = d.id
1322                                                 OR (    cp.circ_lib = d.id
1323                                                         AND cp.deleted IS FALSE
1324                                                 )
1325                                         )
1326                                         $ot_filter
1327                                         $of_filter
1328                                         $oa_filter
1329                                         $ol_filter
1330                                         $olf_filter
1331                                   LIMIT 1
1332                                 )
1333                                 OR NOT EXISTS (
1334                                 SELECT  1
1335                                   FROM  $asset_call_number_table cn,
1336                                         $metabib_metarecord_source_map_table mrs,
1337                                         $metabib_record_descriptor ord
1338                                   WHERE mrs.metarecord = s.metarecord
1339                                         AND cn.record = mrs.source
1340                                         AND ord.record = mrs.source
1341                                         $ot_filter
1342                                         $of_filter
1343                                         $oa_filter
1344                                         $ol_filter
1345                                         $olf_filter
1346                                   LIMIT 1
1347                                 )
1348                           ORDER BY 4 $sort_dir
1349                 SQL
1350         }
1351
1352
1353         $log->debug("Field Search SQL :: [$select]",DEBUG);
1354
1355         my $recs = $class->db_Main->selectall_arrayref(
1356                         $select, {},
1357                         (@bonus_values > 0 ? @bonus_values : () ),
1358                         ( (!$sort && @bonus_values > 0) ? @bonus_values : () ),
1359                         @types, @forms, @aud, @lang, @lit_form,
1360                         @types, @forms, @aud, @lang, @lit_form,
1361                         ($self->api_name =~ /staff/o ? (@types, @forms, @aud, @lang, @lit_form) : () ) );
1362         
1363         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1364
1365         my $max = 0;
1366         $max = 1 if (!@$recs);
1367         for (@$recs) {
1368                 $max = $$_[1] if ($$_[1] > $max);
1369         }
1370
1371         my $count = scalar(@$recs);
1372         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1373                 my ($mrid,$rank,$skip) = @$rec;
1374                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $skip, $count] );
1375         }
1376         return undef;
1377 }
1378
1379 for my $class ( qw/title author subject keyword series/ ) {
1380         __PACKAGE__->register_method(
1381                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord",
1382                 method          => 'postfilter_search_class_fts',
1383                 api_level       => 1,
1384                 stream          => 1,
1385                 cdbi            => "metabib::${class}_field_entry",
1386                 cachable        => 1,
1387         );
1388         __PACKAGE__->register_method(
1389                 api_name        => "open-ils.storage.metabib.$class.post_filter.search_fts.metarecord.staff",
1390                 method          => 'postfilter_search_class_fts',
1391                 api_level       => 1,
1392                 stream          => 1,
1393                 cdbi            => "metabib::${class}_field_entry",
1394                 cachable        => 1,
1395         );
1396 }
1397
1398
1399
1400 my $_cdbi = {   title   => "metabib::title_field_entry",
1401                 author  => "metabib::author_field_entry",
1402                 subject => "metabib::subject_field_entry",
1403                 keyword => "metabib::keyword_field_entry",
1404                 series  => "metabib::series_field_entry",
1405 };
1406
1407 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1408 sub postfilter_search_multi_class_fts {
1409         my $self = shift;
1410         my $client = shift;
1411         my %args = @_;
1412         
1413         my $sort = $args{'sort'};
1414         my $sort_dir = $args{sort_dir} || 'DESC';
1415         my $ou = $args{org_unit};
1416         my $ou_type = $args{depth};
1417         my $limit = $args{limit} || 10;;
1418         my $visibility_limit = $args{visibility_limit} || 5000;;
1419         my $offset = $args{offset} || 0;
1420
1421         if (!$ou) {
1422                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
1423         }
1424
1425         if (!defined($args{org_unit})) {
1426                 die "No target organizational unit passed to ".$self->api_name;
1427         }
1428
1429         if (! scalar( keys %{$args{searches}} )) {
1430                 die "No search arguments were passed to ".$self->api_name;
1431         }
1432
1433         my $outer_limit = 1000;
1434
1435         my $limit_clause = '';
1436         my $offset_clause = '';
1437
1438         $limit_clause = "LIMIT $outer_limit";
1439         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1440
1441         my ($avail_filter,@types,@forms,@lang,@aud,@lit_form,@vformats) = ('');
1442         my ($t_filter, $f_filter, $v_filter) = ('','','');
1443         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1444         my ($ot_filter, $of_filter, $ov_filter) = ('','','');
1445         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1446
1447         if ($args{available}) {
1448                 $avail_filter = ' AND cp.status IN (0,7)';
1449         }
1450
1451         if (my $a = $args{audience}) {
1452                 $a = [$a] if (!ref($a));
1453                 @aud = @$a;
1454                         
1455                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1456                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1457         }
1458
1459         if (my $l = $args{language}) {
1460                 $l = [$l] if (!ref($l));
1461                 @lang = @$l;
1462
1463                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1464                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1465         }
1466
1467         if (my $f = $args{lit_form}) {
1468                 $f = [$f] if (!ref($f));
1469                 @lit_form = @$f;
1470
1471                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1472                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1473         }
1474
1475         if (my $f = $args{item_form}) {
1476                 $f = [$f] if (!ref($f));
1477                 @forms = @$f;
1478
1479                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1480                 $of_filter = ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1481         }
1482
1483         if (my $t = $args{item_type}) {
1484                 $t = [$t] if (!ref($t));
1485                 @types = @$t;
1486
1487                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1488                 $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1489         }
1490
1491         if (my $v = $args{vr_format}) {
1492                 $v = [$v] if (!ref($v));
1493                 @vformats = @$v;
1494
1495                 $v_filter = ' AND rd.vr_format IN ('.join(',',map{'?'}@vformats).')';
1496                 $ov_filter = ' AND ord.vr_format IN ('.join(',',map{'?'}@vformats).')';
1497         }
1498
1499
1500         # XXX legacy format and item type support
1501         if ($args{format}) {
1502                 my ($t, $f) = split '-', $args{format};
1503                 @types = split '', $t;
1504                 @forms = split '', $f;
1505                 if (@types) {
1506                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1507                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1508                 }
1509
1510                 if (@forms) {
1511                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1512                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1513                 }
1514         }
1515
1516
1517
1518         my $descendants = defined($ou_type) ?
1519                                 "actor.org_unit_descendants($ou, $ou_type)" :
1520                                 "actor.org_unit_descendants($ou)";
1521
1522         my $search_table_list = '';
1523         my $fts_list = '';
1524         my $join_table_list = '';
1525         my @rank_list;
1526
1527         my $field_table = config::metabib_field->table;
1528
1529         my @bonus_lists;
1530         my @bonus_values;
1531         my $prev_search_group;
1532         my $curr_search_group;
1533         my $search_class;
1534         my $search_field;
1535         my $metabib_field;
1536         for my $search_group (sort keys %{$args{searches}}) {
1537                 (my $search_group_name = $search_group) =~ s/\|/_/gso;
1538                 ($search_class,$search_field) = split /\|/, $search_group;
1539                 $log->debug("Searching class [$search_class] and field [$search_field]",DEBUG);
1540
1541                 if ($search_field) {
1542                         unless ( $metabib_field = config::metabib_field->search( field_class => $search_class, name => $search_field )->next ) {
1543                                 $log->warn("Requested class [$search_class] or field [$search_field] does not exist!");
1544                                 return undef;
1545                         }
1546                 }
1547
1548                 $prev_search_group = $curr_search_group if ($curr_search_group);
1549
1550                 $curr_search_group = $search_group_name;
1551
1552                 my $class = $_cdbi->{$search_class};
1553                 my $search_table = $class->table;
1554
1555                 my ($index_col) = $class->columns('FTS');
1556                 $index_col ||= 'value';
1557
1558                 
1559                 my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $args{searches}{$search_group}{term}, $search_group_name.'.value', "$search_group_name.$index_col");
1560
1561                 my $fts_where = $fts->sql_where_clause;
1562                 my @fts_ranks = $fts->fts_rank;
1563
1564                 my $SQLstring = join('%',map { lc($_) } $fts->words);
1565                 my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
1566                 my $first_word = lc(($fts->words)[0]).'%';
1567
1568                 $_.=" * (SELECT weight FROM $field_table WHERE $search_group_name.field = id)" for (@fts_ranks);
1569                 my $rank = join(' + ', @fts_ranks);
1570
1571                 my %bonus = ();
1572                 $bonus{'keyword'} = [ { "CASE WHEN $search_group_name.value LIKE ? THEN 10 ELSE 1 END" => $SQLstring } ];
1573                 $bonus{'author'} = [ { "CASE WHEN $search_group_name.value ILIKE ? THEN 10 ELSE 1 END" => $first_word } ];
1574
1575                 $bonus{'series'} = [
1576                         { "CASE WHEN $search_group_name.value LIKE ? THEN 1.5 ELSE 1 END" => $first_word },
1577                         { "CASE WHEN $search_group_name.value ~ ? THEN 20 ELSE 1 END" => $REstring },
1578                 ];
1579
1580                 $bonus{'title'} = [ @{ $bonus{'series'} }, @{ $bonus{'keyword'} } ];
1581
1582                 my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$search_class} };
1583                 $bonus_list ||= '1';
1584
1585                 push @bonus_lists, $bonus_list;
1586                 push @bonus_values, map { values %$_ } @{ $bonus{$search_class} };
1587
1588
1589                 #---------------------
1590
1591                 $search_table_list .= "$search_table $search_group_name, ";
1592                 push @rank_list,$rank;
1593                 $fts_list .= " AND $fts_where AND m.source = $search_group_name.source";
1594
1595                 if ($metabib_field) {
1596                         $join_table_list .= " AND $search_group_name.field = " . $metabib_field->id;
1597                         $metabib_field = undef;
1598                 }
1599
1600                 if ($prev_search_group) {
1601                         $join_table_list .= " AND $prev_search_group.source = $curr_search_group.source";
1602                 }
1603         }
1604
1605         my $metabib_record_descriptor = metabib::record_descriptor->table;
1606         my $metabib_full_rec = metabib::full_rec->table;
1607         my $metabib_metarecord = metabib::metarecord->table;
1608         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
1609         my $asset_call_number_table = asset::call_number->table;
1610         my $asset_copy_table = asset::copy->table;
1611         my $cs_table = config::copy_status->table;
1612         my $cl_table = asset::copy_location->table;
1613         my $br_table = biblio::record_entry->table;
1614         my $source_table = config::bib_source->table;
1615
1616         my $bonuses = join (' * ', @bonus_lists);
1617         my $relevance = join (' + ', @rank_list);
1618         $relevance = "SUM( ($relevance) * ($bonuses) )/COUNT(DISTINCT smrs.source)";
1619
1620         my $string_default_sort = 'zzzz';
1621         $string_default_sort = 'AAAA' if ($sort_dir eq 'DESC');
1622
1623         my $number_default_sort = '9999';
1624         $number_default_sort = '0000' if ($sort_dir eq 'DESC');
1625
1626
1627
1628         my $secondary_sort = <<"        SORT";
1629                 ( FIRST ((
1630                         SELECT  COALESCE(LTRIM(SUBSTR( sfrt.value, COALESCE(SUBSTRING(sfrt.ind2 FROM '\\\\d+'),'0')::INT + 1 )),'$string_default_sort')
1631                           FROM  $metabib_full_rec sfrt,
1632                                 $metabib_metarecord mr
1633                           WHERE sfrt.record = mr.master_record
1634                                 AND sfrt.tag = '245'
1635                                 AND sfrt.subfield = 'a'
1636                           LIMIT 1
1637                 )) )
1638         SORT
1639
1640         my $rank = $relevance;
1641         if (lc($sort) eq 'pubdate') {
1642                 $rank = <<"             RANK";
1643                         ( FIRST ((
1644                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d+'),'$number_default_sort')::INT
1645                                   FROM  $metabib_full_rec frp
1646                                   WHERE frp.record = mr.master_record
1647                                         AND frp.tag = '260'
1648                                         AND frp.subfield = 'c'
1649                                   LIMIT 1
1650                         )) )
1651                 RANK
1652         } elsif (lc($sort) eq 'create_date') {
1653                 $rank = <<"             RANK";
1654                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1655                 RANK
1656         } elsif (lc($sort) eq 'edit_date') {
1657                 $rank = <<"             RANK";
1658                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = mr.master_record)) )
1659                 RANK
1660         } elsif (lc($sort) eq 'title') {
1661                 $rank = <<"             RANK";
1662                         ( FIRST ((
1663                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT + 1 )),'$string_default_sort')
1664                                   FROM  $metabib_full_rec frt
1665                                   WHERE frt.record = mr.master_record
1666                                         AND frt.tag = '245'
1667                                         AND frt.subfield = 'a'
1668                                   LIMIT 1
1669                         )) )
1670                 RANK
1671                 $secondary_sort = <<"           SORT";
1672                         ( FIRST ((
1673                                 SELECT  COALESCE(SUBSTRING(sfrp.value FROM '\\\\d+'),'$number_default_sort')::INT
1674                                   FROM  $metabib_full_rec sfrp
1675                                   WHERE sfrp.record = mr.master_record
1676                                         AND sfrp.tag = '260'
1677                                         AND sfrp.subfield = 'c'
1678                                   LIMIT 1
1679                         )) )
1680                 SORT
1681         } elsif (lc($sort) eq 'author') {
1682                 $rank = <<"             RANK";
1683                         ( FIRST((
1684                                 SELECT  COALESCE(LTRIM(fra.value),'$string_default_sort')
1685                                   FROM  $metabib_full_rec fra
1686                                   WHERE fra.record = mr.master_record
1687                                         AND fra.tag LIKE '1%'
1688                                         AND fra.subfield = 'a'
1689                                   ORDER BY fra.tag::text::int
1690                                   LIMIT 1
1691                         )) )
1692                 RANK
1693         } else {
1694                 push @bonus_values, @bonus_values;
1695                 $sort = undef;
1696         }
1697
1698
1699         my $select = <<"        SQL";
1700                 SELECT  m.metarecord,
1701                         $relevance,
1702                         CASE WHEN COUNT(DISTINCT smrs.source) = 1 THEN FIRST(m.source) ELSE 0 END,
1703                         $rank,
1704                         $secondary_sort
1705                 FROM    $search_table_list
1706                         $metabib_metarecord mr,
1707                         $metabib_metarecord_source_map_table m,
1708                         $metabib_metarecord_source_map_table smrs
1709                 WHERE   m.metarecord = smrs.metarecord 
1710                         AND mr.id = m.metarecord
1711                         $fts_list
1712                         $join_table_list
1713                 GROUP BY m.metarecord
1714                 -- ORDER BY 4 $sort_dir
1715                 LIMIT $visibility_limit
1716         SQL
1717
1718         if ($self->api_name !~ /staff/o) {
1719                 $select = <<"           SQL";
1720
1721                         SELECT  s.*
1722                           FROM  ($select) s
1723                           WHERE EXISTS (
1724                                 SELECT  1
1725                                   FROM  $asset_call_number_table cn,
1726                                         $metabib_metarecord_source_map_table mrs,
1727                                         $asset_copy_table cp,
1728                                         $cs_table cs,
1729                                         $cl_table cl,
1730                                         $br_table br,
1731                                         $descendants d,
1732                                         $metabib_record_descriptor ord
1733                                   WHERE mrs.metarecord = s.metarecord
1734                                         AND br.id = mrs.source
1735                                         AND cn.record = mrs.source
1736                                         AND cp.status = cs.id
1737                                         AND cp.location = cl.id
1738                                         AND cp.circ_lib = d.id
1739                                         AND cp.call_number = cn.id
1740                                         AND cp.opac_visible IS TRUE
1741                                         AND cs.holdable IS TRUE
1742                                         AND cl.opac_visible IS TRUE
1743                                         AND d.opac_visible IS TRUE
1744                                         AND br.active IS TRUE
1745                                         AND br.deleted IS FALSE
1746                                         AND cp.deleted IS FALSE
1747                                         AND cn.deleted IS FALSE
1748                                         AND ord.record = mrs.source
1749                                         $ot_filter
1750                                         $of_filter
1751                                         $ov_filter
1752                                         $oa_filter
1753                                         $ol_filter
1754                                         $olf_filter
1755                                         $avail_filter
1756                                   LIMIT 1
1757                                 )
1758                                 OR EXISTS (
1759                                 SELECT  1
1760                                   FROM  $br_table br,
1761                                         $metabib_metarecord_source_map_table mrs,
1762                                         $metabib_record_descriptor ord,
1763                                         $source_table src
1764                                   WHERE mrs.metarecord = s.metarecord
1765                                         AND ord.record = mrs.source
1766                                         AND br.id = mrs.source
1767                                         AND br.source = src.id
1768                                         AND src.transcendant IS TRUE
1769                                         $ot_filter
1770                                         $of_filter
1771                                         $ov_filter
1772                                         $oa_filter
1773                                         $ol_filter
1774                                         $olf_filter
1775                                 )
1776                           ORDER BY 4 $sort_dir, 5
1777                 SQL
1778         } else {
1779                 $select = <<"           SQL";
1780
1781                         SELECT  DISTINCT s.*
1782                           FROM  ($select) s,
1783                                 $metabib_metarecord_source_map_table omrs,
1784                                 $metabib_record_descriptor ord
1785                           WHERE omrs.metarecord = s.metarecord
1786                                 AND ord.record = omrs.source
1787                                 AND (   EXISTS (
1788                                                 SELECT  1
1789                                                   FROM  $asset_call_number_table cn,
1790                                                         $asset_copy_table cp,
1791                                                         $descendants d,
1792                                                         $br_table br
1793                                                   WHERE br.id = omrs.source
1794                                                         AND cn.record = omrs.source
1795                                                         AND br.deleted IS FALSE
1796                                                         AND cn.deleted IS FALSE
1797                                                         AND cp.call_number = cn.id
1798                                                         AND (   cn.owning_lib = d.id
1799                                                                 OR (    cp.circ_lib = d.id
1800                                                                         AND cp.deleted IS FALSE
1801                                                                 )
1802                                                         )
1803                                                         $avail_filter
1804                                                   LIMIT 1
1805                                         )
1806                                         OR NOT EXISTS (
1807                                                 SELECT  1
1808                                                   FROM  $asset_call_number_table cn
1809                                                   WHERE cn.record = omrs.source
1810                                                         AND cn.deleted IS FALSE
1811                                                   LIMIT 1
1812                                         )
1813                                         OR EXISTS (
1814                                         SELECT  1
1815                                           FROM  $br_table br,
1816                                                 $metabib_metarecord_source_map_table mrs,
1817                                                 $metabib_record_descriptor ord,
1818                                                 $source_table src
1819                                           WHERE mrs.metarecord = s.metarecord
1820                                                 AND br.id = mrs.source
1821                                                 AND br.source = src.id
1822                                                 AND src.transcendant IS TRUE
1823                                                 $ot_filter
1824                                                 $of_filter
1825                                                 $ov_filter
1826                                                 $oa_filter
1827                                                 $ol_filter
1828                                                 $olf_filter
1829                                         )
1830                                 )
1831                                 $ot_filter
1832                                 $of_filter
1833                                 $ov_filter
1834                                 $oa_filter
1835                                 $ol_filter
1836                                 $olf_filter
1837
1838                           ORDER BY 4 $sort_dir, 5
1839                 SQL
1840         }
1841
1842
1843         $log->debug("Field Search SQL :: [$select]",DEBUG);
1844
1845         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
1846                         $select, {},
1847                         @bonus_values,
1848                         @types, @forms, @vformats, @aud, @lang, @lit_form,
1849                         @types, @forms, @vformats, @aud, @lang, @lit_form,
1850                         # ($self->api_name =~ /staff/o ? (@types, @forms, @aud, @lang, @lit_form) : () )
1851         );
1852         
1853         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
1854
1855         my $max = 0;
1856         $max = 1 if (!@$recs);
1857         for (@$recs) {
1858                 $max = $$_[1] if ($$_[1] > $max);
1859         }
1860
1861         my $count = scalar(@$recs);
1862         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
1863                 next unless ($$rec[0]);
1864                 my ($mrid,$rank,$skip) = @$rec;
1865                 $client->respond( [$mrid, sprintf('%0.3f',$rank/$max), $skip, $count] );
1866         }
1867         return undef;
1868 }
1869
1870 __PACKAGE__->register_method(
1871         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord",
1872         method          => 'postfilter_search_multi_class_fts',
1873         api_level       => 1,
1874         stream          => 1,
1875         cachable        => 1,
1876 );
1877 __PACKAGE__->register_method(
1878         api_name        => "open-ils.storage.metabib.post_filter.multiclass.search_fts.metarecord.staff",
1879         method          => 'postfilter_search_multi_class_fts',
1880         api_level       => 1,
1881         stream          => 1,
1882         cachable        => 1,
1883 );
1884
1885 __PACKAGE__->register_method(
1886         api_name        => "open-ils.storage.metabib.multiclass.search_fts",
1887         method          => 'postfilter_search_multi_class_fts',
1888         api_level       => 1,
1889         stream          => 1,
1890         cachable        => 1,
1891 );
1892 __PACKAGE__->register_method(
1893         api_name        => "open-ils.storage.metabib.multiclass.search_fts.staff",
1894         method          => 'postfilter_search_multi_class_fts',
1895         api_level       => 1,
1896         stream          => 1,
1897         cachable        => 1,
1898 );
1899
1900 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
1901 sub biblio_search_multi_class_fts {
1902         my $self = shift;
1903         my $client = shift;
1904         my %args = @_;
1905         
1906         my $sort = $args{'sort'};
1907         my $sort_dir = $args{sort_dir} || 'DESC';
1908         my $ou = $args{org_unit};
1909         my $ou_type = $args{depth};
1910         my $limit = $args{limit} || 10;
1911         my $pref_lang = $args{prefered_language} || 'eng';
1912         my $visibility_limit = $args{visibility_limit} || 5000;
1913         my $offset = $args{offset} || 0;
1914
1915         if (!$ou) {
1916                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
1917         }
1918
1919         if (! scalar( keys %{$args{searches}} )) {
1920                 die "No search arguments were passed to ".$self->api_name;
1921         }
1922
1923         my $outer_limit = 1000;
1924
1925         my $limit_clause = '';
1926         my $offset_clause = '';
1927
1928         $limit_clause = "LIMIT $outer_limit";
1929         $offset_clause = "OFFSET $offset" if (defined $offset and int($offset) > 0);
1930
1931         my ($avail_filter,@types,@forms,@lang,@aud,@lit_form,@vformats) = ('');
1932         my ($t_filter, $f_filter, $v_filter) = ('','','');
1933         my ($a_filter, $l_filter, $lf_filter) = ('','','');
1934         my ($ot_filter, $of_filter, $ov_filter) = ('','','');
1935         my ($oa_filter, $ol_filter, $olf_filter) = ('','','');
1936
1937         if ($args{available}) {
1938                 $avail_filter = ' AND cp.status IN (0,7)';
1939         }
1940
1941         if (my $a = $args{audience}) {
1942                 $a = [$a] if (!ref($a));
1943                 @aud = @$a;
1944                         
1945                 $a_filter = ' AND rd.audience IN ('.join(',',map{'?'}@aud).')';
1946                 $oa_filter = ' AND ord.audience IN ('.join(',',map{'?'}@aud).')';
1947         }
1948
1949         if (my $l = $args{language}) {
1950                 $l = [$l] if (!ref($l));
1951                 @lang = @$l;
1952
1953                 $l_filter = ' AND rd.item_lang IN ('.join(',',map{'?'}@lang).')';
1954                 $ol_filter = ' AND ord.item_lang IN ('.join(',',map{'?'}@lang).')';
1955         }
1956
1957         if (my $f = $args{lit_form}) {
1958                 $f = [$f] if (!ref($f));
1959                 @lit_form = @$f;
1960
1961                 $lf_filter = ' AND rd.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1962                 $olf_filter = ' AND ord.lit_form IN ('.join(',',map{'?'}@lit_form).')';
1963         }
1964
1965         if (my $f = $args{item_form}) {
1966                 $f = [$f] if (!ref($f));
1967                 @forms = @$f;
1968
1969                 $f_filter = ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
1970                 $of_filter = ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
1971         }
1972
1973         if (my $t = $args{item_type}) {
1974                 $t = [$t] if (!ref($t));
1975                 @types = @$t;
1976
1977                 $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1978                 $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1979         }
1980
1981         if (my $v = $args{vr_format}) {
1982                 $v = [$v] if (!ref($v));
1983                 @vformats = @$v;
1984
1985                 $v_filter = ' AND rd.vr_format IN ('.join(',',map{'?'}@vformats).')';
1986                 $ov_filter = ' AND ord.vr_format IN ('.join(',',map{'?'}@vformats).')';
1987         }
1988
1989         # XXX legacy format and item type support
1990         if ($args{format}) {
1991                 my ($t, $f) = split '-', $args{format};
1992                 @types = split '', $t;
1993                 @forms = split '', $f;
1994                 if (@types) {
1995                         $t_filter = ' AND rd.item_type IN ('.join(',',map{'?'}@types).')';
1996                         $ot_filter = ' AND ord.item_type IN ('.join(',',map{'?'}@types).')';
1997                 }
1998
1999                 if (@forms) {
2000                         $f_filter .= ' AND rd.item_form IN ('.join(',',map{'?'}@forms).')';
2001                         $of_filter .= ' AND ord.item_form IN ('.join(',',map{'?'}@forms).')';
2002                 }
2003         }
2004
2005
2006         my $descendants = defined($ou_type) ?
2007                                 "actor.org_unit_descendants($ou, $ou_type)" :
2008                                 "actor.org_unit_descendants($ou)";
2009
2010         my $search_table_list = '';
2011         my $fts_list = '';
2012         my $join_table_list = '';
2013         my @rank_list;
2014
2015         my $field_table = config::metabib_field->table;
2016
2017         my @bonus_lists;
2018         my @bonus_values;
2019         my $prev_search_group;
2020         my $curr_search_group;
2021         my $search_class;
2022         my $search_field;
2023         my $metabib_field;
2024         for my $search_group (sort keys %{$args{searches}}) {
2025                 (my $search_group_name = $search_group) =~ s/\|/_/gso;
2026                 ($search_class,$search_field) = split /\|/, $search_group;
2027                 $log->debug("Searching class [$search_class] and field [$search_field]",DEBUG);
2028
2029                 if ($search_field) {
2030                         unless ( $metabib_field = config::metabib_field->search( field_class => $search_class, name => $search_field )->next ) {
2031                                 $log->warn("Requested class [$search_class] or field [$search_field] does not exist!");
2032                                 return undef;
2033                         }
2034                 }
2035
2036                 $prev_search_group = $curr_search_group if ($curr_search_group);
2037
2038                 $curr_search_group = $search_group_name;
2039
2040                 my $class = $_cdbi->{$search_class};
2041                 my $search_table = $class->table;
2042
2043                 my ($index_col) = $class->columns('FTS');
2044                 $index_col ||= 'value';
2045
2046                 
2047                 my $fts = OpenILS::Application::Storage::FTS->compile($search_class => $args{searches}{$search_group}{term}, $search_group_name.'.value', "$search_group_name.$index_col");
2048
2049                 my $fts_where = $fts->sql_where_clause;
2050                 my @fts_ranks = $fts->fts_rank;
2051
2052                 my $SQLstring = join('%',map { lc($_) } $fts->words) .'%';
2053                 my $REstring = '^' . join('\s+',map { lc($_) } $fts->words) . '\W*$';
2054                 my $first_word = lc(($fts->words)[0]).'%';
2055
2056                 $_.=" * (SELECT weight FROM $field_table WHERE $search_group_name.field = id)" for (@fts_ranks);
2057                 my $rank = join('  + ', @fts_ranks);
2058
2059                 my %bonus = ();
2060                 $bonus{'subject'} = [];
2061                 $bonus{'author'} = [ { "CASE WHEN $search_group_name.value ILIKE ? THEN 1.5 ELSE 1 END" => $first_word } ];
2062
2063                 $bonus{'keyword'} = [ { "CASE WHEN $search_group_name.value ILIKE ? THEN 10 ELSE 1 END" => $SQLstring } ];
2064
2065                 $bonus{'series'} = [
2066                         { "CASE WHEN $search_group_name.value ILIKE ? THEN 1.5 ELSE 1 END" => $first_word },
2067                         { "CASE WHEN $search_group_name.value ~ ? THEN 20 ELSE 1 END" => $REstring },
2068                 ];
2069
2070                 $bonus{'title'} = [ @{ $bonus{'series'} }, @{ $bonus{'keyword'} } ];
2071
2072                 if ($pref_lang) {
2073                         push @{ $bonus{'title'} }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2074                         push @{ $bonus{'author'} }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2075                         push @{ $bonus{'subject'} }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2076                         push @{ $bonus{'keyword'} }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2077                         push @{ $bonus{'series'} }, { "CASE WHEN rd.item_lang = ? THEN 10 ELSE 1 END" => $pref_lang };
2078                 }
2079
2080                 my $bonus_list = join ' * ', map { keys %$_ } @{ $bonus{$search_class} };
2081                 $bonus_list ||= '1';
2082
2083                 push @bonus_lists, $bonus_list;
2084                 push @bonus_values, map { values %$_ } @{ $bonus{$search_class} };
2085
2086                 #---------------------
2087
2088                 $search_table_list .= "$search_table $search_group_name, ";
2089                 push @rank_list,$rank;
2090                 $fts_list .= " AND $fts_where AND b.id = $search_group_name.source";
2091
2092                 if ($metabib_field) {
2093                         $fts_list .= " AND $curr_search_group.field = " . $metabib_field->id;
2094                         $metabib_field = undef;
2095                 }
2096
2097                 if ($prev_search_group) {
2098                         $join_table_list .= " AND $prev_search_group.source = $curr_search_group.source";
2099                 }
2100         }
2101
2102         my $metabib_record_descriptor = metabib::record_descriptor->table;
2103         my $metabib_full_rec = metabib::full_rec->table;
2104         my $metabib_metarecord = metabib::metarecord->table;
2105         my $metabib_metarecord_source_map_table = metabib::metarecord_source_map->table;
2106         my $asset_call_number_table = asset::call_number->table;
2107         my $asset_copy_table = asset::copy->table;
2108         my $cs_table = config::copy_status->table;
2109         my $cl_table = asset::copy_location->table;
2110         my $br_table = biblio::record_entry->table;
2111         my $source_table = config::bib_source->table;
2112
2113
2114         my $bonuses = join (' * ', @bonus_lists);
2115         my $relevance = join (' + ', @rank_list);
2116         $relevance = "AVG( ($relevance) * ($bonuses) )";
2117
2118         my $string_default_sort = 'zzzz';
2119         $string_default_sort = 'AAAA' if ($sort_dir eq 'DESC');
2120
2121         my $number_default_sort = '9999';
2122         $number_default_sort = '0000' if ($sort_dir eq 'DESC');
2123
2124         my $rank = $relevance;
2125         if (lc($sort) eq 'pubdate') {
2126                 $rank = <<"             RANK";
2127                         ( FIRST ((
2128                                 SELECT  COALESCE(SUBSTRING(frp.value FROM '\\\\d{4}'),'$number_default_sort')::INT
2129                                   FROM  $metabib_full_rec frp
2130                                   WHERE frp.record = b.id
2131                                         AND frp.tag = '260'
2132                                         AND frp.subfield = 'c'
2133                                   LIMIT 1
2134                         )) )
2135                 RANK
2136         } elsif (lc($sort) eq 'create_date') {
2137                 $rank = <<"             RANK";
2138                         ( FIRST (( SELECT create_date FROM $br_table rbr WHERE rbr.id = b.id)) )
2139                 RANK
2140         } elsif (lc($sort) eq 'edit_date') {
2141                 $rank = <<"             RANK";
2142                         ( FIRST (( SELECT edit_date FROM $br_table rbr WHERE rbr.id = b.id)) )
2143                 RANK
2144         } elsif (lc($sort) eq 'title') {
2145                 $rank = <<"             RANK";
2146                         ( FIRST ((
2147                                 SELECT  COALESCE(LTRIM(SUBSTR( frt.value, COALESCE(SUBSTRING(frt.ind2 FROM '\\\\d+'),'0')::INT + 1 )),'$string_default_sort')
2148                                   FROM  $metabib_full_rec frt
2149                                   WHERE frt.record = b.id
2150                                         AND frt.tag = '245'
2151                                         AND frt.subfield = 'a'
2152                                   LIMIT 1
2153                         )) )
2154                 RANK
2155         } elsif (lc($sort) eq 'author') {
2156                 $rank = <<"             RANK";
2157                         ( FIRST((
2158                                 SELECT  COALESCE(LTRIM(fra.value),'$string_default_sort')
2159                                   FROM  $metabib_full_rec fra
2160                                   WHERE fra.record = b.id
2161                                         AND fra.tag LIKE '1%'
2162                                         AND fra.subfield = 'a'
2163                                   ORDER BY fra.tag::text::int
2164                                   LIMIT 1
2165                         )) )
2166                 RANK
2167         } else {
2168                 push @bonus_values, @bonus_values;
2169                 $sort = undef;
2170         }
2171
2172
2173         my $select = <<"        SQL";
2174                 SELECT  b.id,
2175                         $relevance AS rel,
2176                         $rank AS rank,
2177                         b.source
2178                 FROM    $search_table_list
2179                         $metabib_record_descriptor rd,
2180                         $source_table src,
2181                         $br_table b
2182                 WHERE   rd.record = b.id
2183                         AND b.active IS TRUE
2184                         AND b.deleted IS FALSE
2185                         $fts_list
2186                         $join_table_list
2187                         $t_filter
2188                         $f_filter
2189                         $v_filter
2190                         $a_filter
2191                         $l_filter
2192                         $lf_filter
2193                 GROUP BY b.id, b.source
2194                 ORDER BY 3 $sort_dir
2195                 LIMIT $visibility_limit
2196         SQL
2197
2198         if ($self->api_name !~ /staff/o) {
2199                 $select = <<"           SQL";
2200
2201                         SELECT  s.*
2202                           FROM  ($select) s
2203                                 LEFT OUTER JOIN $source_table src ON (s.source = src.id)
2204                           WHERE EXISTS (
2205                                 SELECT  1
2206                                   FROM  $asset_call_number_table cn,
2207                                         $asset_copy_table cp,
2208                                         $cs_table cs,
2209                                         $cl_table cl,
2210                                         $descendants d
2211                                   WHERE cn.record = s.id
2212                                         AND cp.status = cs.id
2213                                         AND cp.location = cl.id
2214                                         AND cp.call_number = cn.id
2215                                         AND cp.opac_visible IS TRUE
2216                                         AND cs.holdable IS TRUE
2217                                         AND cl.opac_visible IS TRUE
2218                                         AND d.opac_visible IS TRUE
2219                                         AND cp.deleted IS FALSE
2220                                         AND cn.deleted IS FALSE
2221                                         AND cp.circ_lib = d.id
2222                                         $avail_filter
2223                                   LIMIT 1
2224                                 )
2225                                 OR src.transcendant IS TRUE
2226                           ORDER BY 3 $sort_dir
2227                 SQL
2228         } else {
2229                 $select = <<"           SQL";
2230
2231                         SELECT  s.*
2232                           FROM  ($select) s
2233                                 LEFT OUTER JOIN $source_table src ON (s.source = src.id)
2234                           WHERE EXISTS (
2235                                 SELECT  1
2236                                   FROM  $asset_call_number_table cn,
2237                                         $asset_copy_table cp,
2238                                         $descendants d
2239                                   WHERE cn.record = s.id
2240                                         AND cp.call_number = cn.id
2241                                         AND cn.deleted IS FALSE
2242                                         AND cp.circ_lib = d.id
2243                                         AND cp.deleted IS FALSE
2244                                         $avail_filter
2245                                   LIMIT 1
2246                                 )
2247                                 OR NOT EXISTS (
2248                                 SELECT  1
2249                                   FROM  $asset_call_number_table cn
2250                                   WHERE cn.record = s.id
2251                                   LIMIT 1
2252                                 )
2253                                 OR src.transcendant IS TRUE
2254                           ORDER BY 3 $sort_dir
2255                 SQL
2256         }
2257
2258
2259         $log->debug("Field Search SQL :: [$select]",DEBUG);
2260
2261         my $recs = $_cdbi->{title}->db_Main->selectall_arrayref(
2262                         $select, {},
2263                         @bonus_values, @types, @forms, @vformats, @aud, @lang, @lit_form
2264         );
2265         
2266         $log->debug("Search yielded ".scalar(@$recs)." results.",DEBUG);
2267
2268         my $count = scalar(@$recs);
2269         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
2270                 next unless ($$rec[0]);
2271                 my ($mrid,$rank) = @$rec;
2272                 $client->respond( [$mrid, sprintf('%0.3f',$rank), $count] );
2273         }
2274         return undef;
2275 }
2276
2277 __PACKAGE__->register_method(
2278         api_name        => "open-ils.storage.biblio.multiclass.search_fts.record",
2279         method          => 'biblio_search_multi_class_fts',
2280         api_level       => 1,
2281         stream          => 1,
2282         cachable        => 1,
2283 );
2284 __PACKAGE__->register_method(
2285         api_name        => "open-ils.storage.biblio.multiclass.search_fts.record.staff",
2286         method          => 'biblio_search_multi_class_fts',
2287         api_level       => 1,
2288         stream          => 1,
2289         cachable        => 1,
2290 );
2291
2292
2293
2294 __PACKAGE__->register_method(
2295         api_name        => "open-ils.storage.biblio.multiclass.search_fts",
2296         method          => 'biblio_search_multi_class_fts',
2297         api_level       => 1,
2298         stream          => 1,
2299         cachable        => 1,
2300 );
2301 __PACKAGE__->register_method(
2302         api_name        => "open-ils.storage.biblio.multiclass.search_fts.staff",
2303         method          => 'biblio_search_multi_class_fts',
2304         api_level       => 1,
2305         stream          => 1,
2306         cachable        => 1,
2307 );
2308
2309 # XXX factored most of the PG dependant stuff out of here... need to find a way to do "dependants".
2310 sub staged_fts {
2311         my $self = shift;
2312         my $client = shift;
2313         my %args = @_;
2314         
2315         my $ou = $args{org_unit};
2316         my $limit = $args{limit} || 10;
2317         my $offset = $args{offset} || 0;
2318
2319         if (!$ou) {
2320                 $ou = actor::org_unit->search( { parent_ou => undef } )->next->id;
2321         }
2322
2323         if (! scalar( keys %{$args{searches}} )) {
2324                 die "No search arguments were passed to ".$self->api_name;
2325         }
2326
2327         my (@statuses,@types,@forms,@lang,@aud,@lit_form,@vformats);
2328
2329         if ($args{available}) {
2330                 @statuses = (0,7);
2331         }
2332
2333         if (my $s = $args{statuses}) {
2334                 $s = [$s] if (!ref($s));
2335                 @statuses = @$s;
2336         }
2337
2338         if (my $a = $args{audience}) {
2339                 $a = [$a] if (!ref($a));
2340                 @aud = @$a;
2341         }
2342
2343         if (my $l = $args{language}) {
2344                 $l = [$l] if (!ref($l));
2345                 @lang = @$l;
2346         }
2347
2348         if (my $f = $args{lit_form}) {
2349                 $f = [$f] if (!ref($f));
2350                 @lit_form = @$f;
2351         }
2352
2353         if (my $f = $args{item_form}) {
2354                 $f = [$f] if (!ref($f));
2355                 @forms = @$f;
2356         }
2357
2358         if (my $t = $args{item_type}) {
2359                 $t = [$t] if (!ref($t));
2360                 @types = @$t;
2361         }
2362
2363         if (my $v = $args{vr_format}) {
2364                 $v = [$v] if (!ref($v));
2365                 @vformats = @$v;
2366         }
2367
2368         # XXX legacy format and item type support
2369         if ($args{format}) {
2370                 my ($t, $f) = split '-', $args{format};
2371                 @types = split '', $t;
2372                 @forms = split '', $f;
2373         }
2374
2375     my %stored_proc_search_args;
2376         for my $search_group (sort keys %{$args{searches}}) {
2377                 (my $search_group_name = $search_group) =~ s/\|/_/gso;
2378                 my ($search_class,$search_field) = split /\|/, $search_group;
2379                 $log->debug("Searching class [$search_class] and field [$search_field]",DEBUG);
2380
2381                 if ($search_field) {
2382                         unless ( config::metabib_field->search( field_class => $search_class, name => $search_field )->next ) {
2383                                 $log->warn("Requested class [$search_class] or field [$search_field] does not exist!");
2384                                 return undef;
2385                         }
2386                 }
2387
2388                 my $class = $_cdbi->{$search_class};
2389                 my $search_table = $class->table;
2390
2391                 my ($index_col) = $class->columns('FTS');
2392                 $index_col ||= 'value';
2393
2394                 
2395                 my $fts = OpenILS::Application::Storage::FTS->compile(
2396             $search_class => $args{searches}{$search_group}{term},
2397             $search_group_name.'.value',
2398             "$search_group_name.$index_col"
2399         );
2400                 $fts->sql_where_clause; # this builds the ranks for us
2401
2402                 my @fts_ranks = $fts->fts_rank;
2403                 my @fts_queries = $fts->fts_query;
2404                 my @phrases = map { lc($_) } $fts->phrases;
2405                 my @words = map { lc($_) } $fts->words;
2406
2407         $stored_proc_search_args{$search_group} = {
2408             fts_rank    => \@fts_ranks,
2409             fts_query   => \@fts_queries,
2410             phrase      => \@phrases,
2411             word        => \@words,
2412         };
2413
2414         }
2415
2416         my $param_search_ou = $ou;
2417         my $param_depth = $args{depth}; $param_depth = 'NULL' unless (defined($param_depth) and length($param_depth) > 0 );
2418     my $param_searches = OpenSRF::Utils::JSON->perl2JSON( \%stored_proc_search_args ); $param_searches =~ s/\$//go; $param_searches = '$$'.$param_searches.'$$';
2419     my $param_statuses = '$${' . join(',', map { s/\$//go } @statuses) . '}$$';
2420     my $param_audience = '$${' . join(',', map { s/\$//go } @aud) . '}$$';
2421     my $param_language = '$${' . join(',', map { s/\$//go } @lang) . '}$$';
2422     my $param_lit_form = '$${' . join(',', map { s/\$//go } @lit_form) . '}$$';
2423     my $param_types = '$${' . join(',', map { s/\$//go } @types) . '}$$';
2424     my $param_forms = '$${' . join(',', map { s/\$//go } @forms) . '}$$';
2425     my $param_vformats = '$${' . join(',', map { s/\$//go } @vformats) . '}$$';
2426         my $param_pref_lang = $args{preferred_language}; $param_pref_lang =~ s/\$//go; $param_pref_lang = '$$'.$param_pref_lang.'$$';
2427         my $param_pref_lang_multiplier = $args{preferred_language_weight}; $param_pref_lang_multiplier ||= 'NULL';
2428         my $param_sort = $args{'sort'}; $param_sort =~ s/\$//go; $param_sort = '$$'.$param_sort.'$$';
2429         my $param_sort_desc = defined($args{sort_dir}) && $args{sort_dir} =~ /^d/io ? "'t'" : "'f'";
2430         my $metarecord = $self->api_name =~ /metabib/o ? "'t'" : "'f'";
2431         my $staff = $self->api_name =~ /staff/o ? "'t'" : "'f'";
2432     my $param_rel_limit = $args{core_limit}; $param_rel_limit ||= 'NULL';
2433     my $param_chk_limit = $args{check_limit}; $param_chk_limit ||= 'NULL';
2434     my $param_skip_chk = $args{skip_check}; $param_skip_chk ||= 'NULL';
2435
2436         my $sth = metabib::metarecord_source_map->db_Main->prepare(<<"    SQL");
2437         SELECT  *
2438           FROM  search.staged_fts(
2439                     $param_search_ou,
2440                     $param_depth,
2441                     $param_searches,
2442                     $param_statuses,
2443                     $param_audience,
2444                     $param_language,
2445                     $param_lit_form,
2446                     $param_types,
2447                     $param_forms,
2448                     $param_vformats,
2449                     $param_pref_lang,
2450                     $param_pref_lang_multiplier,
2451                     $param_sort,
2452                     $param_sort_desc,
2453                     $metarecord,
2454                     $staff,
2455                     $param_rel_limit,
2456                     $param_chk_limit,
2457                     $param_skip_chk
2458                 );
2459     SQL
2460
2461     $sth->execute;
2462
2463     my $recs = $sth->fetchall_arrayref({});
2464     my $summary_row = pop @$recs;
2465
2466     my $total = $$summary_row{total};
2467     my $checked = $$summary_row{checked};
2468     my $visible = $$summary_row{visible};
2469     my $deleted = $$summary_row{deleted};
2470     my $excluded = $$summary_row{excluded};
2471
2472     my $estimate = $visible;
2473     if ( $total > $checked && $checked ) {
2474         my $deleted_ratio = $deleted / $checked;
2475         my $exclution_ratio = $excluded / $checked;
2476         my $delete_adjusted_total = $total - ( $total * $deleted_ratio );
2477
2478         $estimate = $$summary_row{estimated_hit_count} = int($delete_adjusted_total - ( $delete_adjusted_total * $exclution_ratio ));
2479     }
2480
2481     delete $$summary_row{id};
2482     delete $$summary_row{rel};
2483     delete $$summary_row{record};
2484
2485     $client->respond( $summary_row );
2486
2487         $log->debug("Search yielded ".scalar(@$recs)." checked, visible results with an approximate visible total of $estimate.",DEBUG);
2488
2489         for my $rec (@$recs[$offset .. $offset + $limit - 1]) {
2490         delete $$rec{checked};
2491         delete $$rec{visible};
2492         delete $$rec{excluded};
2493         delete $$rec{deleted};
2494         delete $$rec{total};
2495         $$rec{rel} = sprintf('%0.3f',$$rec{rel});
2496
2497                 $client->respond( $rec );
2498         }
2499         return undef;
2500 }
2501 __PACKAGE__->register_method(
2502         api_name        => "open-ils.storage.biblio.multiclass.staged.search_fts",
2503         method          => 'staged_fts',
2504         api_level       => 1,
2505         stream          => 1,
2506         cachable        => 1,
2507 );
2508 __PACKAGE__->register_method(
2509         api_name        => "open-ils.storage.biblio.multiclass.staged.search_fts.staff",
2510         method          => 'staged_fts',
2511         api_level       => 1,
2512         stream          => 1,
2513         cachable        => 1,
2514 );
2515 __PACKAGE__->register_method(
2516         api_name        => "open-ils.storage.metabib.multiclass.staged.search_fts",
2517         method          => 'staged_fts',
2518         api_level       => 1,
2519         stream          => 1,
2520         cachable        => 1,
2521 );
2522 __PACKAGE__->register_method(
2523         api_name        => "open-ils.storage.metabib.multiclass.staged.search_fts.staff",
2524         method          => 'staged_fts',
2525         api_level       => 1,
2526         stream          => 1,
2527         cachable        => 1,
2528 );
2529
2530
2531 sub xref_count {
2532         my $self = shift;
2533         my $client = shift;
2534         my $args = shift;
2535
2536         my $term = $$args{term};
2537         my $limit = $$args{max} || 1;
2538         my $min = $$args{min} || 1;
2539         my @classes = @{$$args{class}};
2540
2541         $limit = $min if ($min > $limit);
2542
2543         if (!@classes) {
2544                 @classes = ( qw/ title author subject series keyword / );
2545         }
2546
2547         my %matches;
2548         my $bre_table = biblio::record_entry->table;
2549         my $cn_table = asset::call_number->table;
2550         my $cp_table = asset::copy->table;
2551
2552         for my $search_class ( @classes ) {
2553
2554                 my $class = $_cdbi->{$search_class};
2555                 my $search_table = $class->table;
2556
2557                 my ($index_col) = $class->columns('FTS');
2558                 $index_col ||= 'value';
2559
2560                 
2561                 my $where = OpenILS::Application::Storage::FTS
2562                         ->compile($search_class => $term, $search_class.'.value', "$search_class.$index_col")
2563                         ->sql_where_clause;
2564
2565                 my $SQL = <<"           SQL";
2566                         SELECT  COUNT(DISTINCT X.source)
2567                           FROM  (SELECT $search_class.source
2568                                   FROM  $search_table $search_class
2569                                         JOIN $bre_table b ON (b.id = $search_class.source)
2570                                   WHERE $where
2571                                         AND NOT b.deleted
2572                                         AND b.active
2573                                   LIMIT $limit) X
2574                           HAVING COUNT(DISTINCT X.source) >= $min;
2575                 SQL
2576
2577                 my $res = $class->db_Main->selectrow_arrayref( $SQL );
2578                 $matches{$search_class} = $res ? $res->[0] : 0;
2579         }
2580
2581         return \%matches;
2582 }
2583 __PACKAGE__->register_method(
2584         api_name        => "open-ils.storage.search.xref",
2585         method          => 'xref_count',
2586         api_level       => 1,
2587 );
2588
2589
2590
2591 1;
2592