Rename some charset functions
[pazpar2-moved-to-github.git] / src / session.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2011 Index Data
3
4 Pazpar2 is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 /** \file session.c
21     \brief high-level logic; mostly user sessions and settings
22 */
23
24 #if HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <time.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <string.h>
32 #if HAVE_SYS_TIME_H
33 #include <sys/time.h>
34 #endif
35 #if HAVE_UNISTD_H
36 #include <unistd.h>
37 #endif
38 #ifdef WIN32
39 #include <windows.h>
40 #endif
41 #include <signal.h>
42 #include <ctype.h>
43 #include <assert.h>
44 #include <math.h>
45
46 #include <yaz/marcdisp.h>
47 #include <yaz/comstack.h>
48 #include <yaz/tcpip.h>
49 #include <yaz/proto.h>
50 #include <yaz/readconf.h>
51 #include <yaz/pquery.h>
52 #include <yaz/otherinfo.h>
53 #include <yaz/yaz-util.h>
54 #include <yaz/nmem.h>
55 #include <yaz/query-charset.h>
56 #include <yaz/querytowrbuf.h>
57 #include <yaz/oid_db.h>
58 #include <yaz/snprintf.h>
59 #include <yaz/gettimeofday.h>
60
61 #define USE_TIMING 0
62 #if USE_TIMING
63 #include <yaz/timing.h>
64 #endif
65
66 #include "ppmutex.h"
67 #include "parameters.h"
68 #include "session.h"
69 #include "eventl.h"
70 #include "http.h"
71 #include "termlists.h"
72 #include "reclists.h"
73 #include "relevance.h"
74 #include "database.h"
75 #include "client.h"
76 #include "settings.h"
77 #include "normalize7bit.h"
78
79 #define TERMLIST_HIGH_SCORE 25
80
81 #define MAX_CHUNK 15
82
83 #define MAX(a,b) ((a)>(b)?(a):(b))
84
85 // Note: Some things in this structure will eventually move to configuration
86 struct parameters global_parameters = 
87 {
88     0,   // dump_records
89     0,   // debug_mode
90     0,   // predictable sessions
91 };
92
93 struct client_list {
94     struct client *client;
95     struct client_list *next;
96 };
97
98 /* session counting (1) , disable client counting (0) */
99 static YAZ_MUTEX g_session_mutex = 0;
100 static int no_sessions = 0;
101 static int no_session_total = 0;
102
103 static int session_use(int delta)
104 {
105     int sessions;
106     if (!g_session_mutex)
107         yaz_mutex_create(&g_session_mutex);
108     yaz_mutex_enter(g_session_mutex);
109     no_sessions += delta;
110     if (delta > 0)
111         no_session_total += delta;
112     sessions = no_sessions;
113     yaz_mutex_leave(g_session_mutex);
114     yaz_log(YLOG_DEBUG, "%s sesions=%d", delta == 0 ? "" : (delta > 0 ? "INC" : "DEC"), no_sessions);
115     return sessions;
116 }
117
118 int sessions_count(void) {
119     return session_use(0);
120 }
121
122 int  session_count_total(void) {
123     int total = 0;
124     if (!g_session_mutex)
125         return 0;
126     yaz_mutex_enter(g_session_mutex);
127     total = no_session_total;
128     yaz_mutex_leave(g_session_mutex);
129     return total;
130 }
131
132
133 static void log_xml_doc(xmlDoc *doc)
134 {
135     FILE *lf = yaz_log_file();
136     xmlChar *result = 0;
137     int len = 0;
138 #if LIBXML_VERSION >= 20600
139     xmlDocDumpFormatMemory(doc, &result, &len, 1);
140 #else
141     xmlDocDumpMemory(doc, &result, &len);
142 #endif
143     if (lf && len)
144     {
145         (void) fwrite(result, 1, len, lf);
146         fprintf(lf, "\n");
147     }
148     xmlFree(result);
149 }
150
151 static void session_enter(struct session *s)
152 {
153     yaz_mutex_enter(s->session_mutex);
154 }
155
156 static void session_leave(struct session *s)
157 {
158     yaz_mutex_leave(s->session_mutex);
159 }
160
161 // Recursively traverse query structure to extract terms.
162 void pull_terms(NMEM nmem, struct ccl_rpn_node *n, char **termlist, int *num)
163 {
164     char **words;
165     int numwords;
166     int i;
167
168     switch (n->kind)
169     {
170     case CCL_RPN_AND:
171     case CCL_RPN_OR:
172     case CCL_RPN_NOT:
173     case CCL_RPN_PROX:
174         pull_terms(nmem, n->u.p[0], termlist, num);
175         pull_terms(nmem, n->u.p[1], termlist, num);
176         break;
177     case CCL_RPN_TERM:
178         nmem_strsplit(nmem, " ", n->u.t.term, &words, &numwords);
179         for (i = 0; i < numwords; i++)
180             termlist[(*num)++] = words[i];
181         break;
182     default: // NOOP
183         break;
184     }
185 }
186
187
188 void add_facet(struct session *s, const char *type, const char *value, int count)
189 {
190     struct conf_service *service = s->service;
191     pp2_charset_token_t prt;
192     const char *facet_component;
193     WRBUF facet_wrbuf = wrbuf_alloc();
194     WRBUF display_wrbuf = wrbuf_alloc();
195     int i;
196     const char *icu_chain_id = 0;
197
198     for (i = 0; i < service->num_metadata; i++)
199         if (!strcmp((service->metadata + i)->name, type))
200             icu_chain_id = (service->metadata + i)->icu_chain;
201     yaz_log(YLOG_LOG, "icu_chain id=%s", icu_chain_id ? icu_chain_id : "null");
202
203     if (!icu_chain_id)
204         icu_chain_id = "facet";
205     prt = pp2_charset_token_create(service->charsets, icu_chain_id);
206     if (!prt)
207     {
208         yaz_log(YLOG_FATAL, "Unknown ICU chain '%s' for facet of type '%s'",
209                 icu_chain_id, type);
210         wrbuf_destroy(facet_wrbuf);
211         wrbuf_destroy(display_wrbuf);
212         return;
213     }
214     pp2_charset_token_first(prt, value, 0);
215     while ((facet_component = pp2_charset_token_next(prt)))
216     {
217         const char *display_component;
218         if (*facet_component)
219         {
220             if (wrbuf_len(facet_wrbuf))
221                 wrbuf_puts(facet_wrbuf, " ");
222             wrbuf_puts(facet_wrbuf, facet_component);
223         }
224         display_component = pp2_get_display(prt);
225         if (display_component)
226         {
227             if (wrbuf_len(display_wrbuf))
228                 wrbuf_puts(display_wrbuf, " ");
229             wrbuf_puts(display_wrbuf, display_component);
230         }
231     }
232     pp2_charset_token_destroy(prt);
233  
234     yaz_log(YLOG_LOG, "facet norm=%s", wrbuf_cstr(facet_wrbuf));
235     yaz_log(YLOG_LOG, "facet display=%s", wrbuf_cstr(display_wrbuf));
236     if (wrbuf_len(facet_wrbuf))
237     {
238         int i;
239         for (i = 0; i < s->num_termlists; i++)
240             if (!strcmp(s->termlists[i].name, type))
241                 break;
242         if (i == s->num_termlists)
243         {
244             if (i == SESSION_MAX_TERMLISTS)
245             {
246                 session_log(s, YLOG_FATAL, "Too many termlists");
247                 wrbuf_destroy(facet_wrbuf);
248                 wrbuf_destroy(display_wrbuf);
249                 return;
250             }
251             
252             s->termlists[i].name = nmem_strdup(s->nmem, type);
253             s->termlists[i].termlist 
254                 = termlist_create(s->nmem, TERMLIST_HIGH_SCORE);
255             s->num_termlists = i + 1;
256         }
257         
258 #if 0
259         session_log(s, YLOG_DEBUG, "Facets for %s: %s norm:%s (%d)", type, value, wrbuf_cstr(facet_wrbuf), count);
260 #endif
261         termlist_insert(s->termlists[i].termlist, wrbuf_cstr(display_wrbuf),
262                         wrbuf_cstr(facet_wrbuf), count);
263     }
264     wrbuf_destroy(facet_wrbuf);
265     wrbuf_destroy(display_wrbuf);
266 }
267
268 static xmlDoc *record_to_xml(struct session *se,
269                              struct session_database *sdb, const char *rec)
270 {
271     struct database *db = sdb->database;
272     xmlDoc *rdoc = 0;
273
274     rdoc = xmlParseMemory(rec, strlen(rec));
275
276     if (!rdoc)
277     {
278         session_log(se, YLOG_FATAL, "Non-wellformed XML received from %s",
279                     db->url);
280         return 0;
281     }
282
283     if (global_parameters.dump_records)
284     {
285         session_log(se, YLOG_LOG, "Un-normalized record from %s", db->url);
286         log_xml_doc(rdoc);
287     }
288
289     return rdoc;
290 }
291
292 #define MAX_XSLT_ARGS 16
293
294 // Add static values from session database settings if applicable
295 static void insert_settings_parameters(struct session_database *sdb,
296                                        struct conf_service *service,
297                                        char **parms,
298                                        NMEM nmem)
299 {
300     int i;
301     int nparms = 0;
302     int offset = 0;
303
304     for (i = 0; i < service->num_metadata; i++)
305     {
306         struct conf_metadata *md = &service->metadata[i];
307         int setting;
308
309         if (md->setting == Metadata_setting_parameter &&
310             (setting = settings_lookup_offset(service, md->name)) >= 0)
311         {
312             const char *val = session_setting_oneval(sdb, setting);
313             if (val && nparms < MAX_XSLT_ARGS)
314             {
315                 char *buf;
316                 int len = strlen(val);
317                 buf = nmem_malloc(nmem, len + 3);
318                 buf[0] = '\'';
319                 strcpy(buf + 1, val);
320                 buf[len+1] = '\'';
321                 buf[len+2] = '\0';
322                 parms[offset++] = md->name;
323                 parms[offset++] = buf;
324                 nparms++;
325             }
326         }
327     }
328     parms[offset] = 0;
329 }
330
331 // Add static values from session database settings if applicable
332 static void insert_settings_values(struct session_database *sdb, xmlDoc *doc,
333     struct conf_service *service)
334 {
335     int i;
336
337     for (i = 0; i < service->num_metadata; i++)
338     {
339         struct conf_metadata *md = &service->metadata[i];
340         int offset;
341
342         if (md->setting == Metadata_setting_postproc &&
343             (offset = settings_lookup_offset(service, md->name)) >= 0)
344         {
345             const char *val = session_setting_oneval(sdb, offset);
346             if (val)
347             {
348                 xmlNode *r = xmlDocGetRootElement(doc);
349                 xmlNode *n = xmlNewTextChild(r, 0, (xmlChar *) "metadata",
350                                              (xmlChar *) val);
351                 xmlSetProp(n, (xmlChar *) "type", (xmlChar *) md->name);
352             }
353         }
354     }
355 }
356
357 static xmlDoc *normalize_record(struct session *se,
358                                 struct session_database *sdb,
359                                 struct conf_service *service,
360                                 const char *rec, NMEM nmem)
361 {
362     xmlDoc *rdoc = record_to_xml(se, sdb, rec);
363
364     if (rdoc)
365     {
366         char *parms[MAX_XSLT_ARGS*2+1];
367         
368         insert_settings_parameters(sdb, service, parms, nmem);
369         
370         if (normalize_record_transform(sdb->map, &rdoc, (const char **)parms))
371         {
372             session_log(se, YLOG_WARN, "Normalize failed from %s",
373                         sdb->database->url);
374         }
375         else
376         {
377             insert_settings_values(sdb, rdoc, service);
378             
379             if (global_parameters.dump_records)
380             {
381                 session_log(se, YLOG_LOG, "Normalized record from %s", 
382                             sdb->database->url);
383                 log_xml_doc(rdoc);
384             }
385         }
386     }
387     return rdoc;
388 }
389
390 void session_settings_dump(struct session *se,
391                            struct session_database *db,
392                            WRBUF w)
393 {
394     if (db->settings)
395     {
396         int i, num = db->num_settings;
397         for (i = 0; i < num; i++)
398         {
399             struct setting *s = db->settings[i];
400             for (;s ; s = s->next)
401             {
402                 wrbuf_puts(w, "<set name=\"");
403                 wrbuf_xmlputs(w, s->name);
404                 wrbuf_puts(w, "\" value=\"");
405                 wrbuf_xmlputs(w, s->value);
406                 wrbuf_puts(w, "\"/>");
407             }
408             if (db->settings[i])
409                 wrbuf_puts(w, "\n");
410         }
411     }
412 }
413
414 // Retrieve first defined value for 'name' for given database.
415 // Will be extended to take into account user associated with session
416 const char *session_setting_oneval(struct session_database *db, int offset)
417 {
418     if (offset >= db->num_settings || !db->settings[offset])
419         return "";
420     return db->settings[offset]->value;
421 }
422
423 // Prepare XSLT stylesheets for record normalization
424 // Structures are allocated on the session_wide nmem to avoid having
425 // to recompute this for every search. This would lead
426 // to leaking if a single session was to repeatedly change the PZ_XSLT
427 // setting. However, this is not a realistic use scenario.
428 static int prepare_map(struct session *se, struct session_database *sdb)
429 {
430     const char *s;
431
432     if (!sdb->settings)
433     {
434         session_log(se, YLOG_WARN, "No settings on %s", sdb->database->url);
435         return -1;
436     }
437     if ((s = session_setting_oneval(sdb, PZ_XSLT)))
438     {
439         char auto_stylesheet[256];
440
441         if (!strcmp(s, "auto"))
442         {
443             const char *request_syntax = session_setting_oneval(
444                 sdb, PZ_REQUESTSYNTAX);
445             if (request_syntax)
446             {
447                 char *cp;
448                 yaz_snprintf(auto_stylesheet, sizeof(auto_stylesheet),
449                              "%s.xsl", request_syntax);
450                 for (cp = auto_stylesheet; *cp; cp++)
451                 {
452                     /* deliberately only consider ASCII */
453                     if (*cp > 32 && *cp < 127)
454                         *cp = tolower(*cp);
455                 }
456                 s = auto_stylesheet;
457             }
458             else
459             {
460                 session_log(se, YLOG_WARN,
461                             "No pz:requestsyntax for auto stylesheet");
462             }
463         }
464         sdb->map = normalize_cache_get(se->normalize_cache,
465                                        se->service->server->config, s);
466         if (!sdb->map)
467             return -1;
468     }
469     return 0;
470 }
471
472 // This analyzes settings and recomputes any supporting data structures
473 // if necessary.
474 static int prepare_session_database(struct session *se, 
475                                     struct session_database *sdb)
476 {
477     if (!sdb->settings)
478     {
479         session_log(se, YLOG_WARN, 
480                 "No settings associated with %s", sdb->database->url);
481         return -1;
482     }
483     if (sdb->settings[PZ_XSLT] && !sdb->map)
484     {
485         if (prepare_map(se, sdb) < 0)
486             return -1;
487     }
488     return 0;
489 }
490
491 // called if watch should be removed because http_channel is to be destroyed
492 static void session_watch_cancel(void *data, struct http_channel *c,
493                                  void *data2)
494 {
495     struct session_watchentry *ent = data;
496
497     ent->fun = 0;
498     ent->data = 0;
499     ent->obs = 0;
500 }
501
502 // set watch. Returns 0=OK, -1 if watch is already set
503 int session_set_watch(struct session *s, int what, 
504                       session_watchfun fun, void *data,
505                       struct http_channel *chan)
506 {
507     int ret;
508     session_enter(s);
509     if (s->watchlist[what].fun)
510         ret = -1;
511     else
512     {
513         
514         s->watchlist[what].fun = fun;
515         s->watchlist[what].data = data;
516         s->watchlist[what].obs = http_add_observer(chan, &s->watchlist[what],
517                                                    session_watch_cancel);
518         ret = 0;
519     }
520     session_leave(s);
521     return ret;
522 }
523
524 void session_alert_watch(struct session *s, int what)
525 {
526     assert(s);
527     session_enter(s);
528     if (s->watchlist[what].fun)
529     {
530         /* our watch is no longer associated with http_channel */
531         void *data;
532         session_watchfun fun;
533
534         http_remove_observer(s->watchlist[what].obs);
535         fun  = s->watchlist[what].fun;
536         data = s->watchlist[what].data;
537
538         /* reset watch before fun is invoked - in case fun wants to set
539            it again */
540         s->watchlist[what].fun = 0;
541         s->watchlist[what].data = 0;
542         s->watchlist[what].obs = 0;
543
544         session_leave(s);
545         session_log(s, YLOG_DEBUG,
546                     "Alert Watch: %d calling function: %p", what, fun);
547         fun(data);
548     }
549     else
550         session_leave(s);
551 }
552
553 //callback for grep_databases
554 static void select_targets_callback(void *context, struct session_database *db)
555 {
556     struct session *se = (struct session*) context;
557     struct client *cl = client_create();
558     struct client_list *l;
559     client_set_database(cl, db);
560
561     client_set_session(cl, se);
562
563     l = xmalloc(sizeof(*l));
564     l->client = cl;
565     l->next = se->clients;
566     se->clients = l;
567 }
568
569 static void session_remove_clients(struct session *se)
570 {
571     struct client_list *l;
572
573     session_enter(se);
574     l = se->clients;
575     se->clients = 0;
576     session_leave(se);
577
578     while (l)
579     {
580         struct client_list *l_next = l->next;
581         client_lock(l->client);
582         client_set_session(l->client, 0);
583         client_set_database(l->client, 0);
584         client_unlock(l->client);
585         client_destroy(l->client);
586         xfree(l);
587         l = l_next;
588     }
589 }
590
591 // Associates a set of clients with a session;
592 // Note: Session-databases represent databases with per-session 
593 // setting overrides
594 static int select_targets(struct session *se, const char *filter)
595 {
596     return session_grep_databases(se, filter, select_targets_callback);
597 }
598
599 int session_active_clients(struct session *s)
600 {
601     struct client_list *l;
602     int res = 0;
603
604     for (l = s->clients; l; l = l->next)
605         if (client_is_active(l->client))
606             res++;
607
608     return res;
609 }
610
611 int session_is_preferred_clients_ready(struct session *s)
612 {
613     struct client_list *l;
614     int res = 0;
615
616     for (l = s->clients; l; l = l->next)
617         if (client_is_active_preferred(l->client))
618             res++;
619     session_log(s, YLOG_DEBUG, "Has %d active preferred clients.", res);
620     return res == 0;
621 }
622
623 enum pazpar2_error_code search(struct session *se,
624                                const char *query,
625                                const char *startrecs, const char *maxrecs,
626                                const char *filter,
627                                const char *limit,
628                                const char **addinfo)
629 {
630     int live_channels = 0;
631     int no_working = 0;
632     int no_failed = 0;
633     struct client_list *l;
634     struct timeval tval;
635     facet_limits_t facet_limits;
636
637     session_log(se, YLOG_DEBUG, "Search");
638
639     *addinfo = 0;
640
641     session_remove_clients(se);
642     
643     session_enter(se);
644     reclist_destroy(se->reclist);
645     se->reclist = 0;
646     relevance_destroy(&se->relevance);
647     nmem_reset(se->nmem);
648     se->total_records = se->total_hits = se->total_merged = 0;
649     se->num_termlists = 0;
650     live_channels = select_targets(se, filter);
651     if (!live_channels)
652     {
653         session_leave(se);
654         return PAZPAR2_NO_TARGETS;
655     }
656     se->reclist = reclist_create(se->nmem);
657
658     yaz_gettimeofday(&tval);
659     
660     tval.tv_sec += 5;
661
662     facet_limits = facet_limits_create(limit);
663     if (!facet_limits)
664     {
665         *addinfo = "limit";
666         session_leave(se);
667         return PAZPAR2_MALFORMED_PARAMETER_VALUE;
668     }
669     for (l = se->clients; l; l = l->next)
670     {
671         struct client *cl = l->client;
672
673         if (maxrecs)
674             client_set_maxrecs(cl, atoi(maxrecs));
675         if (startrecs)
676             client_set_startrecs(cl, atoi(startrecs));
677         if (prepare_session_database(se, client_get_database(cl)) < 0)
678             ;
679         else if (client_parse_query(cl, query, facet_limits) < 0)
680             no_failed++;
681         else
682         {
683             no_working++;
684             if (client_prep_connection(cl, se->service->z3950_operation_timeout,
685                                        se->service->z3950_session_timeout,
686                                        se->service->server->iochan_man,
687                                        &tval))
688                 client_start_search(cl);
689         }
690     }
691     facet_limits_destroy(facet_limits);
692     session_leave(se);
693     if (no_working == 0)
694     {
695         if (no_failed > 0)
696         {
697             *addinfo = "query";
698             return PAZPAR2_MALFORMED_PARAMETER_VALUE;
699         }
700         else
701             return PAZPAR2_NO_TARGETS;
702     }
703     return PAZPAR2_NO_ERROR;
704 }
705
706 // Creates a new session_database object for a database
707 static void session_init_databases_fun(void *context, struct database *db)
708 {
709     struct session *se = (struct session *) context;
710     struct session_database *new = nmem_malloc(se->session_nmem, sizeof(*new));
711     int i;
712
713     new->database = db;
714     
715     new->map = 0;
716     assert(db->settings);
717     new->settings = nmem_malloc(se->session_nmem,
718                                 sizeof(struct settings *) * db->num_settings);
719     new->num_settings = db->num_settings;
720     for (i = 0; i < db->num_settings; i++)
721     {
722         struct setting *setting = db->settings[i];
723         new->settings[i] = setting;
724     }
725     new->next = se->databases;
726     se->databases = new;
727 }
728
729 // Doesn't free memory associated with sdb -- nmem takes care of that
730 static void session_database_destroy(struct session_database *sdb)
731 {
732     sdb->map = 0;
733 }
734
735 // Initialize session_database list -- this represents this session's view
736 // of the database list -- subject to modification by the settings ws command
737 void session_init_databases(struct session *se)
738 {
739     se->databases = 0;
740     predef_grep_databases(se, se->service, session_init_databases_fun);
741 }
742
743 // Probably session_init_databases_fun should be refactored instead of
744 // called here.
745 static struct session_database *load_session_database(struct session *se, 
746                                                       char *id)
747 {
748     struct database *db = new_database(id, se->session_nmem);
749
750     resolve_database(se->service, db);
751
752     session_init_databases_fun((void*) se, db);
753
754     // New sdb is head of se->databases list
755     return se->databases;
756 }
757
758 // Find an existing session database. If not found, load it
759 static struct session_database *find_session_database(struct session *se, 
760                                                       char *id)
761 {
762     struct session_database *sdb;
763
764     for (sdb = se->databases; sdb; sdb = sdb->next)
765         if (!strcmp(sdb->database->url, id))
766             return sdb;
767     return load_session_database(se, id);
768 }
769
770 // Apply a session override to a database
771 void session_apply_setting(struct session *se, char *dbname, char *setting,
772                            char *value)
773 {
774     struct session_database *sdb = find_session_database(se, dbname);
775     struct conf_service *service = se->service;
776     struct setting *new = nmem_malloc(se->session_nmem, sizeof(*new));
777     int offset = settings_create_offset(service, setting);
778
779     expand_settings_array(&sdb->settings, &sdb->num_settings, offset,
780                           se->session_nmem);
781     new->precedence = 0;
782     new->target = dbname;
783     new->name = setting;
784     new->value = value;
785     new->next = sdb->settings[offset];
786     sdb->settings[offset] = new;
787
788     // Force later recompute of settings-driven data structures
789     // (happens when a search starts and client connections are prepared)
790     switch (offset)
791     {
792     case PZ_XSLT:
793         if (sdb->map)
794         {
795             sdb->map = 0;
796         }
797         break;
798     }
799 }
800
801 void session_destroy(struct session *se) {
802     struct session_database *sdb;
803     session_log(se, YLOG_DEBUG, "Destroying");
804     session_use(-1);
805     session_remove_clients(se);
806
807     for (sdb = se->databases; sdb; sdb = sdb->next)
808         session_database_destroy(sdb);
809     normalize_cache_destroy(se->normalize_cache);
810     relevance_destroy(&se->relevance);
811     reclist_destroy(se->reclist);
812     nmem_destroy(se->nmem);
813     service_destroy(se->service);
814     yaz_mutex_destroy(&se->session_mutex);
815 }
816
817 /* Depreciated: use session_destroy */
818 void destroy_session(struct session *se)
819 {
820     session_destroy(se);
821 }
822
823 size_t session_get_memory_status(struct session *session) {
824     size_t session_nmem;
825     if (session == 0)
826         return 0;
827     session_enter(session);
828     session_nmem = nmem_total(session->nmem);
829     session_leave(session);
830     return session_nmem;
831 }
832
833
834 struct session *new_session(NMEM nmem, struct conf_service *service,
835                             unsigned session_id)
836 {
837     int i;
838     struct session *session = nmem_malloc(nmem, sizeof(*session));
839
840     char tmp_str[50];
841
842     sprintf(tmp_str, "session#%u", session_id);
843
844     session->session_id = session_id;
845     session_log(session, YLOG_DEBUG, "New");
846     session->service = service;
847     session->relevance = 0;
848     session->total_hits = 0;
849     session->total_records = 0;
850     session->number_of_warnings_unknown_elements = 0;
851     session->number_of_warnings_unknown_metadata = 0;
852     session->num_termlists = 0;
853     session->reclist = 0;
854     session->clients = 0;
855     session->session_nmem = nmem;
856     session->nmem = nmem_create();
857     session->databases = 0;
858     for (i = 0; i <= SESSION_WATCH_MAX; i++)
859     {
860         session->watchlist[i].data = 0;
861         session->watchlist[i].fun = 0;
862     }
863     session->normalize_cache = normalize_cache_create();
864     session->session_mutex = 0;
865     pazpar2_mutex_create(&session->session_mutex, tmp_str);
866     session_use(1);
867     return session;
868 }
869
870 struct hitsbytarget *hitsbytarget(struct session *se, int *count, NMEM nmem)
871 {
872     struct hitsbytarget *res = 0;
873     struct client_list *l;
874     size_t sz = 0;
875
876     session_enter(se);
877     for (l = se->clients; l; l = l->next)
878         sz++;
879
880     res = nmem_malloc(nmem, sizeof(*res) * sz);
881     *count = 0;
882     for (l = se->clients; l; l = l->next)
883     {
884         struct client *cl = l->client;
885         WRBUF w = wrbuf_alloc();
886         const char *name = session_setting_oneval(client_get_database(cl),
887                                                   PZ_NAME);
888
889         res[*count].id = client_get_database(cl)->database->url;
890         res[*count].name = *name ? name : "Unknown";
891         res[*count].hits = client_get_hits(cl);
892         res[*count].records = client_get_num_records(cl);
893         res[*count].diagnostic = client_get_diagnostic(cl);
894         res[*count].state = client_get_state_str(cl);
895         res[*count].connected  = client_get_connection(cl) ? 1 : 0;
896         session_settings_dump(se, client_get_database(cl), w);
897         res[*count].settings_xml = nmem_strdup(nmem, wrbuf_cstr(w));
898         wrbuf_destroy(w);
899         (*count)++;
900     }
901     session_leave(se);
902     return res;
903 }
904
905 struct termlist_score **get_termlist_score(struct session *se,
906                                            const char *name, int *num)
907 {
908     int i;
909     struct termlist_score **tl = 0;
910
911     session_enter(se);
912     for (i = 0; i < se->num_termlists; i++)
913         if (!strcmp((const char *) se->termlists[i].name, name))
914         {
915             tl = termlist_highscore(se->termlists[i].termlist, num);
916             break;
917         }
918     session_leave(se);
919     return tl;
920 }
921
922 #ifdef MISSING_HEADERS
923 void report_nmem_stats(void)
924 {
925     size_t in_use, is_free;
926
927     nmem_get_memory_in_use(&in_use);
928     nmem_get_memory_free(&is_free);
929
930     yaz_log(YLOG_LOG, "nmem stat: use=%ld free=%ld", 
931             (long) in_use, (long) is_free);
932 }
933 #endif
934
935 struct record_cluster *show_single_start(struct session *se, const char *id,
936                                          struct record_cluster **prev_r,
937                                          struct record_cluster **next_r)
938 {
939     struct record_cluster *r = 0;
940
941     session_enter(se);
942     *prev_r = 0;
943     *next_r = 0;
944     if (se->reclist)
945     {
946         reclist_enter(se->reclist);
947         while ((r = reclist_read_record(se->reclist)))
948         {
949             if (!strcmp(r->recid, id))
950             {
951                 *next_r = reclist_read_record(se->reclist);
952                 break;
953             }
954             *prev_r = r;
955         }
956         reclist_leave(se->reclist);
957     }
958     if (!r)
959         session_leave(se);
960     return r;
961 }
962
963 void show_single_stop(struct session *se, struct record_cluster *rec)
964 {
965     session_leave(se);
966 }
967
968 struct record_cluster **show_range_start(struct session *se,
969                                          struct reclist_sortparms *sp, 
970                                          int start, int *num, int *total, Odr_int *sumhits)
971 {
972     struct record_cluster **recs;
973     struct reclist_sortparms *spp;
974     int i;
975 #if USE_TIMING    
976     yaz_timing_t t = yaz_timing_create();
977 #endif
978     session_enter(se);
979     recs = nmem_malloc(se->nmem, *num * sizeof(struct record_cluster *));
980     if (!se->relevance)
981     {
982         *num = 0;
983         *total = 0;
984         *sumhits = 0;
985         recs = 0;
986     }
987     else
988     {
989         for (spp = sp; spp; spp = spp->next)
990             if (spp->type == Metadata_sortkey_relevance)
991             {
992                 relevance_prepare_read(se->relevance, se->reclist);
993                 break;
994             }
995         reclist_sort(se->reclist, sp);
996         
997         reclist_enter(se->reclist);
998         *total = reclist_get_num_records(se->reclist);
999         *sumhits = se->total_hits;
1000         
1001         for (i = 0; i < start; i++)
1002             if (!reclist_read_record(se->reclist))
1003             {
1004                 *num = 0;
1005                 recs = 0;
1006                 break;
1007             }
1008         
1009         for (i = 0; i < *num; i++)
1010         {
1011             struct record_cluster *r = reclist_read_record(se->reclist);
1012             if (!r)
1013             {
1014                 *num = i;
1015                 break;
1016             }
1017             recs[i] = r;
1018         }
1019         reclist_leave(se->reclist);
1020     }
1021 #if USE_TIMING
1022     yaz_timing_stop(t);
1023     yaz_log(YLOG_LOG, "show %6.5f %3.2f %3.2f", 
1024             yaz_timing_get_real(t), yaz_timing_get_user(t),
1025             yaz_timing_get_sys(t));
1026     yaz_timing_destroy(&t);
1027 #endif
1028     return recs;
1029 }
1030
1031 void show_range_stop(struct session *se, struct record_cluster **recs)
1032 {
1033     session_leave(se);
1034 }
1035
1036 void statistics(struct session *se, struct statistics *stat)
1037 {
1038     struct client_list *l;
1039     int count = 0;
1040
1041     memset(stat, 0, sizeof(*stat));
1042     for (l = se->clients; l; l = l->next)
1043     {
1044         struct client *cl = l->client;
1045         if (!client_get_connection(cl))
1046             stat->num_no_connection++;
1047         switch (client_get_state(cl))
1048         {
1049         case Client_Connecting: stat->num_connecting++; break;
1050         case Client_Working: stat->num_working++; break;
1051         case Client_Idle: stat->num_idle++; break;
1052         case Client_Failed: stat->num_failed++; break;
1053         case Client_Error: stat->num_error++; break;
1054         default: break;
1055         }
1056         count++;
1057     }
1058     stat->num_hits = se->total_hits;
1059     stat->num_records = se->total_records;
1060
1061     stat->num_clients = count;
1062 }
1063
1064 static struct record_metadata *record_metadata_init(
1065     NMEM nmem, const char *value, enum conf_metadata_type type,
1066     struct _xmlAttr *attr)
1067 {
1068     struct record_metadata *rec_md = record_metadata_create(nmem);
1069     struct record_metadata_attr **attrp = &rec_md->attributes;
1070     
1071     for (; attr; attr = attr->next)
1072     {
1073         if (attr->children && attr->children->content)
1074         {
1075             if (strcmp((const char *) attr->name, "type"))
1076             {  /* skip the "type" attribute.. Its value is already part of
1077                   the element in output (md-%s) and so repeating it here
1078                   is redundant */
1079                 *attrp = nmem_malloc(nmem, sizeof(**attrp));
1080                 (*attrp)->name =
1081                     nmem_strdup(nmem, (const char *) attr->name);
1082                 (*attrp)->value =
1083                     nmem_strdup(nmem, (const char *) attr->children->content);
1084                 attrp = &(*attrp)->next;
1085             }
1086         }
1087     }
1088     *attrp = 0;
1089
1090     if (type == Metadata_type_generic)
1091     {
1092         char *p = nmem_strdup(nmem, value);
1093
1094         p = normalize7bit_generic(p, " ,/.:([");
1095         
1096         rec_md->data.text.disp = p;
1097         rec_md->data.text.sort = 0;
1098     }
1099     else if (type == Metadata_type_year || type == Metadata_type_date)
1100     {
1101         int first, last;
1102         int longdate = 0;
1103
1104         if (type == Metadata_type_date)
1105             longdate = 1;
1106         if (extract7bit_dates((char *) value, &first, &last, longdate) < 0)
1107             return 0;
1108
1109         rec_md->data.number.min = first;
1110         rec_md->data.number.max = last;
1111     }
1112     else
1113         return 0;
1114     return rec_md;
1115 }
1116
1117 static int get_mergekey_from_doc(xmlDoc *doc, xmlNode *root, const char *name,
1118                                  struct conf_service *service, WRBUF norm_wr)
1119 {
1120     xmlNode *n;
1121     int no_found = 0;
1122     for (n = root->children; n; n = n->next)
1123     {
1124         if (n->type != XML_ELEMENT_NODE)
1125             continue;
1126         if (!strcmp((const char *) n->name, "metadata"))
1127         {
1128             xmlChar *type = xmlGetProp(n, (xmlChar *) "type");
1129             if (type == NULL) {
1130                 yaz_log(YLOG_FATAL, "Missing type attribute on metadata element. Skipping!");
1131             }
1132             else if (!strcmp(name, (const char *) type))
1133             {
1134                 xmlChar *value = xmlNodeListGetString(doc, n->children, 1);
1135                 if (value)
1136                 {
1137                     const char *norm_str;
1138                     pp2_charset_token_t prt =
1139                         pp2_charset_token_create(service->charsets, "mergekey");
1140                     
1141                     pp2_charset_token_first(prt, (const char *) value, 0);
1142                     if (wrbuf_len(norm_wr) > 0)
1143                         wrbuf_puts(norm_wr, " ");
1144                     wrbuf_puts(norm_wr, name);
1145                     while ((norm_str =
1146                             pp2_charset_token_next(prt)))
1147                     {
1148                         if (*norm_str)
1149                         {
1150                             wrbuf_puts(norm_wr, " ");
1151                             wrbuf_puts(norm_wr, norm_str);
1152                         }
1153                     }
1154                     xmlFree(value);
1155                     pp2_charset_token_destroy(prt);
1156                     no_found++;
1157                 }
1158             }
1159             xmlFree(type);
1160         }
1161     }
1162     return no_found;
1163 }
1164
1165 static const char *get_mergekey(xmlDoc *doc, struct client *cl, int record_no,
1166                                 struct conf_service *service, NMEM nmem)
1167 {
1168     char *mergekey_norm = 0;
1169     xmlNode *root = xmlDocGetRootElement(doc);
1170     WRBUF norm_wr = wrbuf_alloc();
1171
1172     /* consider mergekey from XSL first */
1173     xmlChar *mergekey = xmlGetProp(root, (xmlChar *) "mergekey");
1174     if (mergekey)
1175     {
1176         const char *norm_str;
1177         pp2_charset_token_t prt =
1178             pp2_charset_token_create(service->charsets, "mergekey");
1179
1180         pp2_charset_token_first(prt, (const char *) mergekey, 0);
1181         while ((norm_str = pp2_charset_token_next(prt)))
1182         {
1183             if (*norm_str)
1184             {
1185                 if (wrbuf_len(norm_wr))
1186                     wrbuf_puts(norm_wr, " ");
1187                 wrbuf_puts(norm_wr, norm_str);
1188             }
1189         }
1190         pp2_charset_token_destroy(prt);
1191         xmlFree(mergekey);
1192     }
1193     else
1194     {
1195         /* no mergekey defined in XSL. Look for mergekey metadata instead */
1196         int field_id;
1197         for (field_id = 0; field_id < service->num_metadata; field_id++)
1198         {
1199             struct conf_metadata *ser_md = &service->metadata[field_id];
1200             if (ser_md->mergekey != Metadata_mergekey_no)
1201             {
1202                 int r = get_mergekey_from_doc(doc, root, ser_md->name,
1203                                               service, norm_wr);
1204                 if (r == 0 && ser_md->mergekey == Metadata_mergekey_required)
1205                 {
1206                     /* no mergekey on this one and it is required.. 
1207                        Generate unique key instead */
1208                     wrbuf_rewind(norm_wr);
1209                     break;
1210                 }
1211             }
1212         }
1213     }
1214
1215     /* generate unique key if none is not generated already or is empty */
1216     if (wrbuf_len(norm_wr) == 0)
1217     {
1218         wrbuf_printf(norm_wr, "%s-%d",
1219                      client_get_database(cl)->database->url, record_no);
1220     }
1221     if (wrbuf_len(norm_wr) > 0)
1222         mergekey_norm = nmem_strdup(nmem, wrbuf_cstr(norm_wr));
1223     wrbuf_destroy(norm_wr);
1224     return mergekey_norm;
1225 }
1226
1227 /** \brief see if metadata for pz:recordfilter exists 
1228     \param root xml root element of normalized record
1229     \param sdb session database for client
1230     \retval 0 if there is no metadata for pz:recordfilter
1231     \retval 1 if there is metadata for pz:recordfilter
1232
1233     If there is no pz:recordfilter defined, this function returns 1
1234     as well.
1235 */
1236     
1237 static int check_record_filter(xmlNode *root, struct session_database *sdb)
1238 {
1239     int match = 0;
1240     xmlNode *n;
1241     const char *s;
1242     s = session_setting_oneval(sdb, PZ_RECORDFILTER);
1243
1244     if (!s || !*s)
1245         return 1;
1246
1247     for (n = root->children; n; n = n->next)
1248     {
1249         if (n->type != XML_ELEMENT_NODE)
1250             continue;
1251         if (!strcmp((const char *) n->name, "metadata"))
1252         {
1253             xmlChar *type = xmlGetProp(n, (xmlChar *) "type");
1254             if (type)
1255             {
1256                 size_t len;
1257                 int substring;
1258                 const char *eq;
1259
1260                 if ((eq = strchr(s, '=')))
1261                     substring = 0;
1262                 else if ((eq = strchr(s, '~')))
1263                     substring = 1;
1264                 if (eq)
1265                     len = eq - s;
1266                 else
1267                     len = strlen(s);
1268                 if (len == strlen((const char *)type) &&
1269                     !memcmp((const char *) type, s, len))
1270                 {
1271                     xmlChar *value = xmlNodeGetContent(n);
1272                     if (value && *value)
1273                     {
1274                         if (!eq ||
1275                             (substring && strstr((const char *) value, eq+1)) ||
1276                             (!substring && !strcmp((const char *) value, eq + 1)))
1277                             match = 1;
1278                     }
1279                     xmlFree(value);
1280                 }
1281                 xmlFree(type);
1282             }
1283         }
1284     }
1285     return match;
1286 }
1287
1288
1289 static int ingest_to_cluster(struct client *cl,
1290                              xmlDoc *xdoc,
1291                              xmlNode *root,
1292                              int record_no,
1293                              const char *mergekey_norm);
1294
1295 /** \brief ingest XML record
1296     \param cl client holds the result set for record
1297     \param rec record buffer (0 terminated)
1298     \param record_no record position (1, 2, ..)
1299     \param nmem working NMEM
1300     \retval 0 OK
1301     \retval -1 failure
1302     \retval -2 Filtered
1303 */
1304 int ingest_record(struct client *cl, const char *rec,
1305                   int record_no, NMEM nmem)
1306 {
1307     struct session *se = client_get_session(cl);
1308     int ret = 0;
1309     struct session_database *sdb = client_get_database(cl);
1310     struct conf_service *service = se->service;
1311     xmlDoc *xdoc = normalize_record(se, sdb, service, rec, nmem);
1312     xmlNode *root;
1313     const char *mergekey_norm;
1314     
1315     if (!xdoc)
1316         return -1;
1317     
1318     root = xmlDocGetRootElement(xdoc);
1319     
1320     if (!check_record_filter(root, sdb))
1321     {
1322         session_log(se, YLOG_LOG, "Filtered out record no %d from %s",
1323                     record_no, sdb->database->url);
1324         xmlFreeDoc(xdoc);
1325         return -2;
1326     }
1327     
1328     mergekey_norm = get_mergekey(xdoc, cl, record_no, service, nmem);
1329     if (!mergekey_norm)
1330     {
1331         session_log(se, YLOG_WARN, "Got no mergekey");
1332         xmlFreeDoc(xdoc);
1333         return -1;
1334     }
1335     session_enter(se);
1336     if (client_get_session(cl) == se)
1337         ret = ingest_to_cluster(cl, xdoc, root, record_no, mergekey_norm);
1338     session_leave(se);
1339     
1340     xmlFreeDoc(xdoc);
1341     return ret;
1342 }
1343
1344 static int ingest_to_cluster(struct client *cl,
1345                              xmlDoc *xdoc,
1346                              xmlNode *root,
1347                              int record_no,
1348                              const char *mergekey_norm)
1349 {
1350     xmlNode *n;
1351     xmlChar *type = 0;
1352     xmlChar *value = 0;
1353     struct session_database *sdb = client_get_database(cl);
1354     struct session *se = client_get_session(cl);
1355     struct conf_service *service = se->service;
1356     struct record *record = record_create(se->nmem, 
1357                                           service->num_metadata,
1358                                           service->num_sortkeys, cl,
1359                                           record_no);
1360     struct record_cluster *cluster = reclist_insert(se->reclist,
1361                                                     service, 
1362                                                     record,
1363                                                     mergekey_norm,
1364                                                     &se->total_merged);
1365
1366     const char *use_term_factor_str = session_setting_oneval(sdb, PZ_TERMLIST_TERM_FACTOR);
1367     int use_term_factor = 0;
1368     int term_factor = 1; 
1369     if (use_term_factor_str && use_term_factor_str[0] != 0)
1370        use_term_factor =  atoi(use_term_factor_str);
1371     if (use_term_factor) {
1372         int maxrecs = client_get_maxrecs(cl);
1373         int hits = (int) client_get_hits(cl);
1374         term_factor = MAX(hits, maxrecs) /  MAX(1, maxrecs);
1375         assert(term_factor >= 1);
1376         yaz_log(YLOG_DEBUG, "Using term factor: %d (%d / %d)", term_factor, MAX(hits, maxrecs), MAX(1, maxrecs));
1377     }
1378
1379     if (!cluster)
1380         return -1;
1381     if (global_parameters.dump_records)
1382         session_log(se, YLOG_LOG, "Cluster id %s from %s (#%d)", cluster->recid,
1383                     sdb->database->url, record_no);
1384     relevance_newrec(se->relevance, cluster);
1385     
1386     // now parsing XML record and adding data to cluster or record metadata
1387     for (n = root->children; n; n = n->next)
1388     {
1389         pp2_charset_token_t prt;
1390         if (type)
1391             xmlFree(type);
1392         if (value)
1393             xmlFree(value);
1394         type = value = 0;
1395         
1396         if (n->type != XML_ELEMENT_NODE)
1397             continue;
1398         if (!strcmp((const char *) n->name, "metadata"))
1399         {
1400             struct conf_metadata *ser_md = 0;
1401             struct conf_sortkey *ser_sk = 0;
1402             struct record_metadata **wheretoput = 0;
1403             struct record_metadata *rec_md = 0;
1404             int md_field_id = -1;
1405             int sk_field_id = -1;
1406             
1407             type = xmlGetProp(n, (xmlChar *) "type");
1408             value = xmlNodeListGetString(xdoc, n->children, 1);
1409             
1410             if (!type || !value || !*value)
1411                 continue;
1412             
1413             md_field_id 
1414                 = conf_service_metadata_field_id(service, (const char *) type);
1415             if (md_field_id < 0)
1416             {
1417                 if (se->number_of_warnings_unknown_metadata == 0)
1418                 {
1419                     session_log(se, YLOG_WARN, 
1420                             "Ignoring unknown metadata element: %s", type);
1421                 }
1422                 se->number_of_warnings_unknown_metadata++;
1423                 continue;
1424             }
1425             
1426             ser_md = &service->metadata[md_field_id];
1427             
1428             if (ser_md->sortkey_offset >= 0){
1429                 sk_field_id = ser_md->sortkey_offset;
1430                 ser_sk = &service->sortkeys[sk_field_id];
1431             }
1432
1433             // non-merged metadata
1434             rec_md = record_metadata_init(se->nmem, (const char *) value,
1435                                           ser_md->type, n->properties);
1436             if (!rec_md)
1437             {
1438                 session_log(se, YLOG_WARN, "bad metadata data '%s' "
1439                             "for element '%s'", value, type);
1440                 continue;
1441             }
1442             wheretoput = &record->metadata[md_field_id];
1443             while (*wheretoput)
1444                 wheretoput = &(*wheretoput)->next;
1445             *wheretoput = rec_md;
1446
1447             // merged metadata
1448             rec_md = record_metadata_init(se->nmem, (const char *) value,
1449                                           ser_md->type, 0);
1450             wheretoput = &cluster->metadata[md_field_id];
1451
1452             // and polulate with data:
1453             // assign cluster or record based on merge action
1454             if (ser_md->merge == Metadata_merge_unique)
1455             {
1456                 while (*wheretoput)
1457                 {
1458                     if (!strcmp((const char *) (*wheretoput)->data.text.disp, 
1459                                 rec_md->data.text.disp))
1460                         break;
1461                     wheretoput = &(*wheretoput)->next;
1462                 }
1463                 if (!*wheretoput)
1464                     *wheretoput = rec_md;
1465             }
1466             else if (ser_md->merge == Metadata_merge_longest)
1467             {
1468                 if (!*wheretoput 
1469                     || strlen(rec_md->data.text.disp) 
1470                     > strlen((*wheretoput)->data.text.disp))
1471                 {
1472                     *wheretoput = rec_md;
1473                     if (ser_sk)
1474                     {
1475                         const char *sort_str = 0;
1476                         int skip_article = 
1477                             ser_sk->type == Metadata_sortkey_skiparticle;
1478
1479                         if (!cluster->sortkeys[sk_field_id])
1480                             cluster->sortkeys[sk_field_id] = 
1481                                 nmem_malloc(se->nmem, 
1482                                             sizeof(union data_types));
1483                          
1484                         prt =
1485                             pp2_charset_token_create(service->charsets, "sort");
1486
1487                         pp2_charset_token_first(prt, rec_md->data.text.disp,
1488                                                 skip_article);
1489
1490                         pp2_charset_token_next(prt);
1491                          
1492                         sort_str = pp2_get_sort(prt);
1493                          
1494                         cluster->sortkeys[sk_field_id]->text.disp = 
1495                             rec_md->data.text.disp;
1496                         if (!sort_str)
1497                         {
1498                             sort_str = rec_md->data.text.disp;
1499                             session_log(se, YLOG_WARN, 
1500                                     "Could not make sortkey. Bug #1858");
1501                         }
1502                         cluster->sortkeys[sk_field_id]->text.sort = 
1503                             nmem_strdup(se->nmem, sort_str);
1504                         pp2_charset_token_destroy(prt);
1505                     }
1506                 }
1507             }
1508             else if (ser_md->merge == Metadata_merge_all)
1509             {
1510                 while (*wheretoput)
1511                     wheretoput = &(*wheretoput)->next;
1512                 *wheretoput = rec_md;
1513             }
1514             else if (ser_md->merge == Metadata_merge_range)
1515             {
1516                 if (!*wheretoput)
1517                 {
1518                     *wheretoput = rec_md;
1519                     if (ser_sk)
1520                         cluster->sortkeys[sk_field_id] 
1521                             = &rec_md->data;
1522                 }
1523                 else
1524                 {
1525                     int this_min = rec_md->data.number.min;
1526                     int this_max = rec_md->data.number.max;
1527                     if (this_min < (*wheretoput)->data.number.min)
1528                         (*wheretoput)->data.number.min = this_min;
1529                     if (this_max > (*wheretoput)->data.number.max)
1530                         (*wheretoput)->data.number.max = this_max;
1531                 }
1532             }
1533
1534
1535             // ranking of _all_ fields enabled ... 
1536             if (ser_md->rank)
1537                 relevance_countwords(se->relevance, cluster, 
1538                                      (char *) value, ser_md->rank,
1539                                      ser_md->name);
1540
1541             // construct facets ... unless the client already has reported them
1542             if (ser_md->termlist && !client_has_facet(cl, (char *) type))
1543             {
1544                 if (ser_md->type == Metadata_type_year)
1545                 {
1546                     char year[64];
1547                     sprintf(year, "%d", rec_md->data.number.max);
1548
1549                     add_facet(se, (char *) type, year, term_factor);
1550                     if (rec_md->data.number.max != rec_md->data.number.min)
1551                     {
1552                         sprintf(year, "%d", rec_md->data.number.min);
1553                         add_facet(se, (char *) type, year, term_factor);
1554                     }
1555                 }
1556                 else
1557                     add_facet(se, (char *) type, (char *) value, term_factor);
1558             }
1559
1560             // cleaning up
1561             xmlFree(type);
1562             xmlFree(value);
1563             type = value = 0;
1564         }
1565         else
1566         {
1567             if (se->number_of_warnings_unknown_elements == 0)
1568                 session_log(se, YLOG_WARN,
1569                         "Unexpected element in internal record: %s", n->name);
1570             se->number_of_warnings_unknown_elements++;
1571         }
1572     }
1573     if (type)
1574         xmlFree(type);
1575     if (value)
1576         xmlFree(value);
1577
1578     relevance_donerecord(se->relevance, cluster);
1579     se->total_records++;
1580
1581     return 0;
1582 }
1583
1584 void session_log(struct session *s, int level, const char *fmt, ...)
1585 {
1586     char buf[1024];
1587     va_list ap;
1588     va_start(ap, fmt);
1589
1590     yaz_vsnprintf(buf, sizeof(buf)-30, fmt, ap);
1591     yaz_log(level, "Session (%u): %s", s->session_id, buf);
1592
1593     va_end(ap);
1594 }
1595
1596 /*
1597  * Local variables:
1598  * c-basic-offset: 4
1599  * c-file-style: "Stroustrup"
1600  * indent-tabs-mode: nil
1601  * End:
1602  * vim: shiftwidth=4 tabstop=8 expandtab
1603  */
1604