X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=src%2Fsession.c;h=19ac45c843c7f5030850aba580d6745e50d8475e;hb=e7aa4584e25203b0da7839cf23011e89b6af6ced;hp=9875515e7cc508d12df0cc0adcf3de23fb947ca5;hpb=0572cad965179e30e4125702ff84b504346ee27a;p=pazpar2-moved-to-github.git

diff --git a/src/session.c b/src/session.c
index 9875515..19ac45c 100644
--- a/src/session.c
+++ b/src/session.c
@@ -111,15 +111,17 @@ static int session_use(int delta)
         no_session_total += delta;
     sessions = no_sessions;
     yaz_mutex_leave(g_session_mutex);
-    yaz_log(YLOG_DEBUG, "%s sesions=%d", delta == 0 ? "" : (delta > 0 ? "INC" : "DEC"), no_sessions);
+    yaz_log(YLOG_DEBUG, "%s sessions=%d", delta == 0 ? "" : (delta > 0 ? "INC" : "DEC"), no_sessions);
     return sessions;
 }
 
-int sessions_count(void) {
+int sessions_count(void)
+{
     return session_use(0);
 }
 
-int  session_count_total(void) {
+int session_count_total(void)
+{
     int total = 0;
     if (!g_session_mutex)
         return 0;
@@ -129,7 +131,6 @@ int  session_count_total(void) {
     return total;
 }
 
-
 static void log_xml_doc(xmlDoc *doc)
 {
     FILE *lf = yaz_log_file();
@@ -158,40 +159,14 @@ static void session_leave(struct session *s)
     yaz_mutex_leave(s->session_mutex);
 }
 
-// Recursively traverse query structure to extract terms.
-void pull_terms(NMEM nmem, struct ccl_rpn_node *n, char **termlist, int *num)
-{
-    char **words;
-    int numwords;
-    int i;
-
-    switch (n->kind)
-    {
-    case CCL_RPN_AND:
-    case CCL_RPN_OR:
-    case CCL_RPN_NOT:
-    case CCL_RPN_PROX:
-        pull_terms(nmem, n->u.p[0], termlist, num);
-        pull_terms(nmem, n->u.p[1], termlist, num);
-        break;
-    case CCL_RPN_TERM:
-        nmem_strsplit(nmem, " ", n->u.t.term, &words, &numwords);
-        for (i = 0; i < numwords; i++)
-            termlist[(*num)++] = words[i];
-        break;
-    default: // NOOP
-        break;
-    }
-}
-
-
-void add_facet(struct session *s, const char *type, const char *value, int count)
+static void session_normalize_facet(struct session *s, const char *type,
+                                    const char *value,
+                                    WRBUF display_wrbuf,
+                                    WRBUF facet_wrbuf)
 {
     struct conf_service *service = s->service;
     pp2_charset_token_t prt;
     const char *facet_component;
-    WRBUF facet_wrbuf = wrbuf_alloc();
-    WRBUF display_wrbuf = wrbuf_alloc();
     int i;
     const char *icu_chain_id = 0;
 
@@ -228,6 +203,14 @@ void add_facet(struct session *s, const char *type, const char *value, int count
         }
     }
     pp2_charset_token_destroy(prt);
+}
+
+void add_facet(struct session *s, const char *type, const char *value, int count)
+{
+    WRBUF facet_wrbuf = wrbuf_alloc();
+    WRBUF display_wrbuf = wrbuf_alloc();
+
+    session_normalize_facet(s, type, value, display_wrbuf, facet_wrbuf);
  
     if (wrbuf_len(facet_wrbuf))
     {
@@ -272,13 +255,13 @@ static xmlDoc *record_to_xml(struct session *se,
     if (!rdoc)
     {
         session_log(se, YLOG_FATAL, "Non-wellformed XML received from %s",
-                    db->url);
+                    db->id);
         return 0;
     }
 
     if (global_parameters.dump_records)
     {
-        session_log(se, YLOG_LOG, "Un-normalized record from %s", db->url);
+        session_log(se, YLOG_LOG, "Un-normalized record from %s", db->id);
         log_xml_doc(rdoc);
     }
 
@@ -366,7 +349,7 @@ static xmlDoc *normalize_record(struct session *se,
         if (normalize_record_transform(sdb->map, &rdoc, (const char **)parms))
         {
             session_log(se, YLOG_WARN, "Normalize failed from %s",
-                        sdb->database->url);
+                        sdb->database->id);
         }
         else
         {
@@ -375,7 +358,7 @@ static xmlDoc *normalize_record(struct session *se,
             if (global_parameters.dump_records)
             {
                 session_log(se, YLOG_LOG, "Normalized record from %s", 
-                            sdb->database->url);
+                            sdb->database->id);
                 log_xml_doc(rdoc);
             }
         }
@@ -425,12 +408,8 @@ static int prepare_map(struct session *se, struct session_database *sdb)
 {
     const char *s;
 
-    if (!sdb->settings)
-    {
-        session_log(se, YLOG_WARN, "No settings on %s", sdb->database->url);
-        return -1;
-    }
-    if ((s = session_setting_oneval(sdb, PZ_XSLT)))
+    if (sdb->settings && sdb->settings[PZ_XSLT] && !sdb->map &&
+        (s = session_setting_oneval(sdb, PZ_XSLT)))        
     {
         char auto_stylesheet[256];
 
@@ -458,32 +437,13 @@ static int prepare_map(struct session *se, struct session_database *sdb)
             }
         }
         sdb->map = normalize_cache_get(se->normalize_cache,
-                                       se->service->server->config, s);
+                                       se->service, s);
         if (!sdb->map)
             return -1;
     }
     return 0;
 }
 
-// This analyzes settings and recomputes any supporting data structures
-// if necessary.
-static int prepare_session_database(struct session *se, 
-                                    struct session_database *sdb)
-{
-    if (!sdb->settings)
-    {
-        session_log(se, YLOG_WARN, 
-                "No settings associated with %s", sdb->database->url);
-        return -1;
-    }
-    if (sdb->settings[PZ_XSLT] && !sdb->map)
-    {
-        if (prepare_map(se, sdb) < 0)
-            return -1;
-    }
-    return 0;
-}
-
 // called if watch should be removed because http_channel is to be destroyed
 static void session_watch_cancel(void *data, struct http_channel *c,
                                  void *data2)
@@ -547,28 +507,63 @@ void session_alert_watch(struct session *s, int what)
 }
 
 //callback for grep_databases
-static void select_targets_callback(void *context, struct session_database *db)
+static void select_targets_callback(struct session *se,
+                                    struct session_database *db)
 {
-    struct session *se = (struct session*) context;
-    struct client *cl = client_create();
+    struct client *cl;
     struct client_list *l;
-    client_set_database(cl, db);
 
-    client_set_session(cl, se);
+    for (l = se->clients_cached; l; l = l->next)
+        if (client_get_database(l->client) == db)
+            break;
+
+    if (l)
+        cl = l->client;
+    else
+    {
+        cl = client_create(db->database->id);
+        client_set_database(cl, db);
+        client_set_session(cl, se);
+
+        l = xmalloc(sizeof(*l));
+        l->client = cl;
+        l->next = se->clients_cached;
+        se->clients_cached = l;
+    }
 
     l = xmalloc(sizeof(*l));
     l->client = cl;
-    l->next = se->clients;
-    se->clients = l;
+    l->next = se->clients_active;
+    se->clients_active = l;
 }
 
-static void session_remove_clients(struct session *se)
+static void session_reset_active_clients(struct session *se,
+                                         struct client_list *new_list)
 {
     struct client_list *l;
 
     session_enter(se);
-    l = se->clients;
-    se->clients = 0;
+    l = se->clients_active;
+    se->clients_active = new_list;
+    session_leave(se);
+
+    while (l)
+    {
+        struct client_list *l_next = l->next;
+        xfree(l);
+        l = l_next;
+    }
+}
+
+static void session_remove_cached_clients(struct session *se)
+{
+    struct client_list *l;
+
+    session_reset_active_clients(se, 0);
+
+    session_enter(se);
+    l = se->clients_cached;
+    se->clients_cached = 0;
     session_leave(se);
 
     while (l)
@@ -597,7 +592,7 @@ int session_active_clients(struct session *s)
     struct client_list *l;
     int res = 0;
 
-    for (l = s->clients; l; l = l->next)
+    for (l = s->clients_active; l; l = l->next)
         if (client_is_active(l->client))
             res++;
 
@@ -609,24 +604,68 @@ int session_is_preferred_clients_ready(struct session *s)
     struct client_list *l;
     int res = 0;
 
-    for (l = s->clients; l; l = l->next)
+    for (l = s->clients_active; l; l = l->next)
         if (client_is_active_preferred(l->client))
             res++;
     session_log(s, YLOG_DEBUG, "Has %d active preferred clients.", res);
     return res == 0;
 }
 
-enum pazpar2_error_code search(struct session *se,
-                               const char *query,
-                               const char *startrecs, const char *maxrecs,
-                               const char *filter,
-                               const char *limit,
-                               const char **addinfo)
+void session_sort(struct session *se, const char *field, int increasing)
+{
+    struct session_sorted_results *sr;
+    struct client_list *l;
+
+    session_enter(se);
+
+    /* see if we already have sorted for this critieria */
+    for (sr = se->sorted_results; sr; sr = sr->next)
+    {
+        if (!strcmp(field, sr->field) && increasing == sr->increasing)
+            break;
+    }
+    if (sr)
+    {
+        yaz_log(YLOG_LOG, "search_sort: field=%s increasing=%d already fetched",
+                field, increasing);
+        session_leave(se);
+        return;
+    }
+    yaz_log(YLOG_LOG, "search_sort: field=%s increasing=%d must fetch",
+            field, increasing);
+    sr = nmem_malloc(se->nmem, sizeof(*sr));
+    sr->field = nmem_strdup(se->nmem, field);
+    sr->increasing = increasing;
+    sr->next = se->sorted_results;
+    se->sorted_results = sr;
+    
+    for (l = se->clients_active; l; l = l->next)
+    {
+        struct client *cl = l->client;
+        struct timeval tval;
+        if (client_prep_connection(cl, se->service->z3950_operation_timeout,
+                                   se->service->z3950_session_timeout,
+                                   se->service->server->iochan_man,
+                                   &tval))
+            client_start_search(cl);
+    }
+    session_leave(se);
+}
+
+enum pazpar2_error_code session_search(struct session *se,
+                                       const char *query,
+                                       const char *startrecs,
+                                       const char *maxrecs,
+                                       const char *filter,
+                                       const char *limit,
+                                       const char **addinfo,
+                                       const char *sort_field, int increasing)
 {
     int live_channels = 0;
     int no_working = 0;
-    int no_failed = 0;
-    struct client_list *l;
+    int no_failed_query = 0;
+    int no_failed_limit = 0;
+    struct client_list *l, *l0;
     struct timeval tval;
     facet_limits_t facet_limits;
 
@@ -634,15 +673,26 @@ enum pazpar2_error_code search(struct session *se,
 
     *addinfo = 0;
 
-    session_remove_clients(se);
+    if (se->settings_modified)
+        session_remove_cached_clients(se);
+    else
+        session_reset_active_clients(se, 0);
     
     session_enter(se);
     reclist_destroy(se->reclist);
     se->reclist = 0;
+    se->settings_modified = 0;
     relevance_destroy(&se->relevance);
     nmem_reset(se->nmem);
-    se->total_records = se->total_hits = se->total_merged = 0;
+    se->total_records = se->total_merged = 0;
     se->num_termlists = 0;
+
+    /* reset list of sorted results and clear to relevance search */
+    se->sorted_results = nmem_malloc(se->nmem, sizeof(*se->sorted_results));
+    se->sorted_results->field = nmem_strdup(se->nmem, sort_field);
+    se->sorted_results->increasing = increasing;
+    se->sorted_results->next = 0;
+    
     live_channels = select_targets(se, filter);
     if (!live_channels)
     {
@@ -662,20 +712,28 @@ enum pazpar2_error_code search(struct session *se,
         session_leave(se);
         return PAZPAR2_MALFORMED_PARAMETER_VALUE;
     }
-    for (l = se->clients; l; l = l->next)
+
+    l0 = se->clients_active;
+    se->clients_active = 0;
+    session_leave(se);
+
+    for (l = l0; l; l = l->next)
     {
+        int parse_ret;
         struct client *cl = l->client;
 
-        if (maxrecs)
-            client_set_maxrecs(cl, atoi(maxrecs));
-        if (startrecs)
-            client_set_startrecs(cl, atoi(startrecs));
-        if (prepare_session_database(se, client_get_database(cl)) < 0)
-            ;
-        else if (client_parse_query(cl, query, facet_limits) < 0)
-            no_failed++;
-        else
+        if (prepare_map(se, client_get_database(cl)) < 0)
+            continue;
+
+        parse_ret = client_parse_query(cl, query, facet_limits, startrecs,
+            maxrecs);
+        if (parse_ret == -1)
+            no_failed_query++;
+        else if (parse_ret == -2)
+            no_failed_limit++;
+        else if (parse_ret == 0)
         {
+            session_log(se, YLOG_LOG, "client NEW %s", client_get_id(cl));
             no_working++;
             if (client_prep_connection(cl, se->service->z3950_operation_timeout,
                                        se->service->z3950_session_timeout,
@@ -683,19 +741,38 @@ enum pazpar2_error_code search(struct session *se,
                                        &tval))
                 client_start_search(cl);
         }
+        else
+        {
+            session_log(se, YLOG_LOG, "client REUSE %s", client_get_id(cl));
+            no_working++;
+            if (client_prep_connection(cl, se->service->z3950_operation_timeout,
+                                       se->service->z3950_session_timeout,
+                                       se->service->server->iochan_man,
+                                       &tval))
+            {
+                client_reingest(cl);
+            }
+        }
     }
     facet_limits_destroy(facet_limits);
-    session_leave(se);
+    session_reset_active_clients(se, l0);
+
     if (no_working == 0)
     {
-        if (no_failed > 0)
+        if (no_failed_query > 0)
         {
             *addinfo = "query";
             return PAZPAR2_MALFORMED_PARAMETER_VALUE;
         }
+        else if (no_failed_limit > 0)
+        {
+            *addinfo = "limit";
+            return PAZPAR2_MALFORMED_PARAMETER_VALUE;
+        }
         else
             return PAZPAR2_NO_TARGETS;
     }
+    yaz_log(YLOG_LOG, "session_start_search done");
     return PAZPAR2_NO_ERROR;
 }
 
@@ -743,8 +820,6 @@ static struct session_database *load_session_database(struct session *se,
 {
     struct database *db = new_database(id, se->session_nmem);
 
-    resolve_database(se->service, db);
-
     session_init_databases_fun((void*) se, db);
 
     // New sdb is head of se->databases list
@@ -758,7 +833,7 @@ static struct session_database *find_session_database(struct session *se,
     struct session_database *sdb;
 
     for (sdb = se->databases; sdb; sdb = sdb->next)
-        if (!strcmp(sdb->database->url, id))
+        if (!strcmp(sdb->database->id, id))
             return sdb;
     return load_session_database(se, id);
 }
@@ -781,6 +856,8 @@ void session_apply_setting(struct session *se, char *dbname, char *setting,
     new->next = sdb->settings[offset];
     sdb->settings[offset] = new;
 
+    se->settings_modified = 1;
+
     // Force later recompute of settings-driven data structures
     // (happens when a search starts and client connections are prepared)
     switch (offset)
@@ -794,11 +871,12 @@ void session_apply_setting(struct session *se, char *dbname, char *setting,
     }
 }
 
-void session_destroy(struct session *se) {
+void session_destroy(struct session *se)
+{
     struct session_database *sdb;
     session_log(se, YLOG_DEBUG, "Destroying");
     session_use(-1);
-    session_remove_clients(se);
+    session_remove_cached_clients(se);
 
     for (sdb = se->databases; sdb; sdb = sdb->next)
         session_database_destroy(sdb);
@@ -810,12 +888,6 @@ void session_destroy(struct session *se) {
     yaz_mutex_destroy(&se->session_mutex);
 }
 
-/* Depreciated: use session_destroy */
-void destroy_session(struct session *se)
-{
-    session_destroy(se);
-}
-
 size_t session_get_memory_status(struct session *session) {
     size_t session_nmem;
     if (session == 0)
@@ -841,13 +913,14 @@ struct session *new_session(NMEM nmem, struct conf_service *service,
     session_log(session, YLOG_DEBUG, "New");
     session->service = service;
     session->relevance = 0;
-    session->total_hits = 0;
     session->total_records = 0;
     session->number_of_warnings_unknown_elements = 0;
     session->number_of_warnings_unknown_metadata = 0;
     session->num_termlists = 0;
     session->reclist = 0;
-    session->clients = 0;
+    session->clients_active = 0;
+    session->clients_cached = 0;
+    session->settings_modified = 0;
     session->session_nmem = nmem;
     session->nmem = nmem_create();
     session->databases = 0;
@@ -863,41 +936,55 @@ struct session *new_session(NMEM nmem, struct conf_service *service,
     return session;
 }
 
-struct hitsbytarget *hitsbytarget(struct session *se, int *count, NMEM nmem)
+const char * client_get_suggestions_xml(struct client *cl, WRBUF wrbuf);
+
+static struct hitsbytarget *hitsbytarget_nb(struct session *se,
+                                            int *count, NMEM nmem)
 {
     struct hitsbytarget *res = 0;
     struct client_list *l;
     size_t sz = 0;
 
-    session_enter(se);
-    for (l = se->clients; l; l = l->next)
+    for (l = se->clients_active; l; l = l->next)
         sz++;
 
     res = nmem_malloc(nmem, sizeof(*res) * sz);
     *count = 0;
-    for (l = se->clients; l; l = l->next)
+    for (l = se->clients_active; l; l = l->next)
     {
         struct client *cl = l->client;
         WRBUF w = wrbuf_alloc();
         const char *name = session_setting_oneval(client_get_database(cl),
                                                   PZ_NAME);
 
-        res[*count].id = client_get_database(cl)->database->url;
+        res[*count].id = client_get_id(cl);
         res[*count].name = *name ? name : "Unknown";
         res[*count].hits = client_get_hits(cl);
         res[*count].records = client_get_num_records(cl);
-        res[*count].diagnostic = client_get_diagnostic(cl);
+        res[*count].diagnostic =
+            client_get_diagnostic(cl, &res[*count].addinfo);
         res[*count].state = client_get_state_str(cl);
         res[*count].connected  = client_get_connection(cl) ? 1 : 0;
         session_settings_dump(se, client_get_database(cl), w);
         res[*count].settings_xml = nmem_strdup(nmem, wrbuf_cstr(w));
+        wrbuf_rewind(w);
+        wrbuf_puts(w, "");
+        res[*count].suggestions_xml = nmem_strdup(nmem, client_get_suggestions_xml(cl, w));
         wrbuf_destroy(w);
         (*count)++;
     }
-    session_leave(se);
     return res;
 }
 
+struct hitsbytarget *get_hitsbytarget(struct session *se, int *count, NMEM nmem)
+{
+    struct hitsbytarget *p;
+    session_enter(se);
+    p = hitsbytarget_nb(se, count, nmem);
+    session_leave(se);
+    return p;
+}
+    
 struct termlist_score **get_termlist_score(struct session *se,
                                            const char *name, int *num)
 {
@@ -915,6 +1002,124 @@ struct termlist_score **get_termlist_score(struct session *se,
     return tl;
 }
 
+// Compares two hitsbytarget nodes by hitcount
+static int cmp_ht(const void *p1, const void *p2)
+{
+    const struct hitsbytarget *h1 = p1;
+    const struct hitsbytarget *h2 = p2;
+    return h2->hits - h1->hits;
+}
+
+static int targets_termlist_nb(WRBUF wrbuf, struct session *se, int num,
+                               NMEM nmem)
+{
+    struct hitsbytarget *ht;
+    int count, i;
+
+    ht = hitsbytarget_nb(se, &count, nmem);
+    qsort(ht, count, sizeof(struct hitsbytarget), cmp_ht);
+    for (i = 0; i < count && i < num && ht[i].hits > 0; i++)
+    {
+
+        // do only print terms which have display names
+    
+        wrbuf_puts(wrbuf, "<term>\n");
+
+        wrbuf_puts(wrbuf, "<id>");
+        wrbuf_xmlputs(wrbuf, ht[i].id);
+        wrbuf_puts(wrbuf, "</id>\n");
+        
+        wrbuf_puts(wrbuf, "<name>");
+        if (!ht[i].name || !ht[i].name[0])
+            wrbuf_xmlputs(wrbuf, "NO TARGET NAME");
+        else
+            wrbuf_xmlputs(wrbuf, ht[i].name);
+        wrbuf_puts(wrbuf, "</name>\n");
+        
+        wrbuf_printf(wrbuf, "<frequency>" ODR_INT_PRINTF "</frequency>\n",
+                     ht[i].hits);
+        
+        wrbuf_puts(wrbuf, "<state>");
+        wrbuf_xmlputs(wrbuf, ht[i].state);
+        wrbuf_puts(wrbuf, "</state>\n");
+        
+        wrbuf_printf(wrbuf, "<diagnostic>%d</diagnostic>\n", 
+                     ht[i].diagnostic);
+        wrbuf_puts(wrbuf, "</term>\n");
+    }
+    return count;
+}
+
+void perform_termlist(struct http_channel *c, struct session *se,
+                      const char *name, int num)
+{
+    int i, j;
+    NMEM nmem_tmp = nmem_create();
+    char **names;
+    int num_names = 0;
+
+    if (!name)
+        name = "*";
+
+    nmem_strsplit(nmem_tmp, ",", name, &names, &num_names);
+
+    session_enter(se);
+
+    for (j = 0; j < num_names; j++)
+    {
+        const char *tname;
+        
+        for (i = 0; i < se->num_termlists; i++)
+        {
+            tname = se->termlists[i].name;
+            if (!strcmp(names[j], tname) || !strcmp(names[j], "*"))
+            {
+                struct termlist_score **p = 0;
+                int len;
+
+                wrbuf_puts(c->wrbuf, "<list name=\"");
+                wrbuf_xmlputs(c->wrbuf, tname);
+                wrbuf_puts(c->wrbuf, "\">\n");
+
+                p = termlist_highscore(se->termlists[i].termlist, &len);
+                if (p)
+                {
+                    int i;
+                    for (i = 0; i < len && i < num; i++)
+                    {
+                        // prevent sending empty term elements
+                        if (!p[i]->display_term || !p[i]->display_term[0])
+                            continue;
+                        
+                        wrbuf_puts(c->wrbuf, "<term>");
+                        wrbuf_puts(c->wrbuf, "<name>");
+                        wrbuf_xmlputs(c->wrbuf, p[i]->display_term);
+                        wrbuf_puts(c->wrbuf, "</name>");
+                        
+                        wrbuf_printf(c->wrbuf, 
+                                     "<frequency>%d</frequency>", 
+                                     p[i]->frequency);
+                        wrbuf_puts(c->wrbuf, "</term>\n");
+                    }
+                }
+                wrbuf_puts(c->wrbuf, "</list>\n");
+            }
+        }
+        tname = "xtargets";
+        if (!strcmp(names[j], tname) || !strcmp(names[j], "*"))
+        {
+            wrbuf_puts(c->wrbuf, "<list name=\"");
+            wrbuf_xmlputs(c->wrbuf, tname);
+            wrbuf_puts(c->wrbuf, "\">\n");
+
+            targets_termlist_nb(c->wrbuf, se, num, c->nmem);
+            wrbuf_puts(c->wrbuf, "</list>\n");
+        }
+    }
+    session_leave(se);
+    nmem_destroy(nmem_tmp);
+}
+
 #ifdef MISSING_HEADERS
 void report_nmem_stats(void)
 {
@@ -982,6 +1187,8 @@ struct record_cluster **show_range_start(struct session *se,
     }
     else
     {
+        struct client_list *l;
+        
         for (spp = sp; spp; spp = spp->next)
             if (spp->type == Metadata_sortkey_relevance)
             {
@@ -992,7 +1199,10 @@ struct record_cluster **show_range_start(struct session *se,
         
         reclist_enter(se->reclist);
         *total = reclist_get_num_records(se->reclist);
-        *sumhits = se->total_hits;
+
+        *sumhits = 0;
+        for (l = se->clients_active; l; l = l->next)
+            *sumhits += client_get_hits(l->client);
         
         for (i = 0; i < start; i++)
             if (!reclist_read_record(se->reclist))
@@ -1035,11 +1245,13 @@ void statistics(struct session *se, struct statistics *stat)
     int count = 0;
 
     memset(stat, 0, sizeof(*stat));
-    for (l = se->clients; l; l = l->next)
+    stat->num_hits = 0;
+    for (l = se->clients_active; l; l = l->next)
     {
         struct client *cl = l->client;
         if (!client_get_connection(cl))
             stat->num_no_connection++;
+        stat->num_hits += client_get_hits(cl);
         switch (client_get_state(cl))
         {
         case Client_Connecting: stat->num_connecting++; break;
@@ -1051,7 +1263,6 @@ void statistics(struct session *se, struct statistics *stat)
         }
         count++;
     }
-    stat->num_hits = se->total_hits;
     stat->num_records = se->total_records;
 
     stat->num_clients = count;
@@ -1211,8 +1422,13 @@ static const char *get_mergekey(xmlDoc *doc, struct client *cl, int record_no,
     /* generate unique key if none is not generated already or is empty */
     if (wrbuf_len(norm_wr) == 0)
     {
-        wrbuf_printf(norm_wr, "%s-%d",
-                     client_get_database(cl)->database->url, record_no);
+        wrbuf_printf(norm_wr, "position: %s-%d",
+                     client_get_id(cl), record_no);
+    }
+    else
+    {
+        const char *lead = "content: ";
+        wrbuf_insert(norm_wr, 0, lead, strlen(lead));
     }
     if (wrbuf_len(norm_wr) > 0)
         mergekey_norm = nmem_strdup(nmem, wrbuf_cstr(norm_wr));
@@ -1316,7 +1532,7 @@ int ingest_record(struct client *cl, const char *rec,
     if (!check_record_filter(root, sdb))
     {
         session_log(se, YLOG_LOG, "Filtered out record no %d from %s",
-                    record_no, sdb->database->url);
+                    record_no, sdb->database->id);
         xmlFreeDoc(xdoc);
         return -2;
     }
@@ -1337,6 +1553,78 @@ int ingest_record(struct client *cl, const char *rec,
     return ret;
 }
 
+static int check_limit_local(struct client *cl,
+                             struct record *record,
+                             int record_no)
+{
+    int skip_record = 0;
+    struct session *se = client_get_session(cl);
+    struct conf_service *service = se->service;
+    NMEM nmem_tmp = nmem_create();
+    struct session_database *sdb = client_get_database(cl);
+    int l = 0;
+    while (!skip_record)
+    {
+        struct conf_metadata *ser_md = 0;
+        struct record_metadata *rec_md = 0;
+        int md_field_id;
+        char **values = 0;
+        int i, num_v = 0;
+        
+        const char *name =
+            client_get_facet_limit_local(cl, sdb, &l, nmem_tmp, &num_v,
+                                         &values);
+        if (!name)
+            break;
+        
+        md_field_id = conf_service_metadata_field_id(service, name);
+        if (md_field_id < 0)
+        {
+            skip_record = 1;
+            break;
+        }
+        ser_md = &service->metadata[md_field_id];
+        rec_md = record->metadata[md_field_id];
+        yaz_log(YLOG_LOG, "check limit local %s", name);
+        for (i = 0; i < num_v; )
+        {
+            if (rec_md)
+            {
+                if (ser_md->type == Metadata_type_year 
+                    || ser_md->type == Metadata_type_date)
+                {
+                    int y = atoi(values[i]);
+                    if (y >= rec_md->data.number.min 
+                        && y <= rec_md->data.number.max)
+                        break;
+                }
+                else
+                {
+                    yaz_log(YLOG_LOG, "cmp: '%s' '%s'",
+                            rec_md->data.text.disp, values[i]);
+                    if (!strcmp(rec_md->data.text.disp, values[i]))
+                    {
+                        break;
+                    }
+                }
+                rec_md = rec_md->next;
+            }
+            else
+            {
+                rec_md = record->metadata[md_field_id];
+                i++;
+            }
+        }
+        if (i == num_v)
+        {
+            skip_record = 1;
+            break;
+        }
+    }
+    nmem_destroy(nmem_tmp);
+    return skip_record;
+}
+                             
 static int ingest_to_cluster(struct client *cl,
                              xmlDoc *xdoc,
                              xmlNode *root,
@@ -1346,43 +1634,18 @@ static int ingest_to_cluster(struct client *cl,
     xmlNode *n;
     xmlChar *type = 0;
     xmlChar *value = 0;
-    struct session_database *sdb = client_get_database(cl);
     struct session *se = client_get_session(cl);
     struct conf_service *service = se->service;
+    int term_factor = 1;
+    struct record_cluster *cluster;
+    struct session_database *sdb = client_get_database(cl);
     struct record *record = record_create(se->nmem, 
                                           service->num_metadata,
                                           service->num_sortkeys, cl,
                                           record_no);
-    struct record_cluster *cluster = reclist_insert(se->reclist,
-                                                    service, 
-                                                    record,
-                                                    mergekey_norm,
-                                                    &se->total_merged);
-
-    const char *use_term_factor_str = session_setting_oneval(sdb, PZ_TERMLIST_TERM_FACTOR);
-    int use_term_factor = 0;
-    int term_factor = 1; 
-    if (use_term_factor_str && use_term_factor_str[0] != 0)
-       use_term_factor =  atoi(use_term_factor_str);
-    if (use_term_factor) {
-        int maxrecs = client_get_maxrecs(cl);
-        int hits = (int) client_get_hits(cl);
-        term_factor = MAX(hits, maxrecs) /  MAX(1, maxrecs);
-        assert(term_factor >= 1);
-        yaz_log(YLOG_DEBUG, "Using term factor: %d (%d / %d)", term_factor, MAX(hits, maxrecs), MAX(1, maxrecs));
-    }
 
-    if (!cluster)
-        return -1;
-    if (global_parameters.dump_records)
-        session_log(se, YLOG_LOG, "Cluster id %s from %s (#%d)", cluster->recid,
-                    sdb->database->url, record_no);
-    relevance_newrec(se->relevance, cluster);
-    
-    // now parsing XML record and adding data to cluster or record metadata
     for (n = root->children; n; n = n->next)
     {
-        pp2_charset_token_t prt;
         if (type)
             xmlFree(type);
         if (value)
@@ -1394,11 +1657,9 @@ static int ingest_to_cluster(struct client *cl,
         if (!strcmp((const char *) n->name, "metadata"))
         {
             struct conf_metadata *ser_md = 0;
-            struct conf_sortkey *ser_sk = 0;
             struct record_metadata **wheretoput = 0;
             struct record_metadata *rec_md = 0;
             int md_field_id = -1;
-            int sk_field_id = -1;
             
             type = xmlGetProp(n, (xmlChar *) "type");
             value = xmlNodeListGetString(xdoc, n->children, 1);
@@ -1418,13 +1679,8 @@ static int ingest_to_cluster(struct client *cl,
                 se->number_of_warnings_unknown_metadata++;
                 continue;
             }
-            
+           
             ser_md = &service->metadata[md_field_id];
-            
-            if (ser_md->sortkey_offset >= 0){
-                sk_field_id = ser_md->sortkey_offset;
-                ser_sk = &service->sortkeys[sk_field_id];
-            }
 
             // non-merged metadata
             rec_md = record_metadata_init(se->nmem, (const char *) value,
@@ -1439,10 +1695,90 @@ static int ingest_to_cluster(struct client *cl,
             while (*wheretoput)
                 wheretoput = &(*wheretoput)->next;
             *wheretoput = rec_md;
+        }
+    }
+
+    if (check_limit_local(cl, record, record_no))
+    {
+        session_log(se, YLOG_LOG, "Facet filtered out record no %d from %s",
+                    record_no, sdb->database->id);
+        if (type)
+            xmlFree(type);
+        if (value)
+            xmlFree(value);
+        return -2;
+    }
+    cluster = reclist_insert(se->reclist, service, record,
+                             mergekey_norm, &se->total_merged);
+    if (!cluster)
+        return -1;
+
+    {
+        const char *use_term_factor_str =
+            session_setting_oneval(sdb, PZ_TERMLIST_TERM_FACTOR);
+        if (use_term_factor_str && use_term_factor_str[0] == '1')
+        {
+            int maxrecs = client_get_maxrecs(cl);
+            int hits = (int) client_get_hits(cl);
+            term_factor = MAX(hits, maxrecs) /  MAX(1, maxrecs);
+            assert(term_factor >= 1);
+            yaz_log(YLOG_DEBUG, "Using term factor: %d (%d / %d)", term_factor, MAX(hits, maxrecs), MAX(1, maxrecs));
+        }
+    }
+
+    if (global_parameters.dump_records)
+        session_log(se, YLOG_LOG, "Cluster id %s from %s (#%d)", cluster->recid,
+                    sdb->database->id, record_no);
+
+
+    relevance_newrec(se->relevance, cluster);
+    
+    // now parsing XML record and adding data to cluster or record metadata
+    for (n = root->children; n; n = n->next)
+    {
+        pp2_charset_token_t prt;
+        if (type)
+            xmlFree(type);
+        if (value)
+            xmlFree(value);
+        type = value = 0;
+        
+        if (n->type != XML_ELEMENT_NODE)
+            continue;
+        if (!strcmp((const char *) n->name, "metadata"))
+        {
+            struct conf_metadata *ser_md = 0;
+            struct conf_sortkey *ser_sk = 0;
+            struct record_metadata **wheretoput = 0;
+            struct record_metadata *rec_md = 0;
+            int md_field_id = -1;
+            int sk_field_id = -1;
+            
+            type = xmlGetProp(n, (xmlChar *) "type");
+            value = xmlNodeListGetString(xdoc, n->children, 1);
+            
+            if (!type || !value || !*value)
+                continue;
+            
+            md_field_id 
+                = conf_service_metadata_field_id(service, (const char *) type);
+            if (md_field_id < 0)
+                continue;
+            
+            ser_md = &service->metadata[md_field_id];
+            
+            if (ser_md->sortkey_offset >= 0)
+            {
+                sk_field_id = ser_md->sortkey_offset;
+                ser_sk = &service->sortkeys[sk_field_id];
+            }
 
             // merged metadata
             rec_md = record_metadata_init(se->nmem, (const char *) value,
                                           ser_md->type, 0);
+            if (!rec_md)
+                continue;
+
             wheretoput = &cluster->metadata[md_field_id];
 
             // and polulate with data:
@@ -1584,7 +1920,7 @@ void session_log(struct session *s, int level, const char *fmt, ...)
     va_start(ap, fmt);
 
     yaz_vsnprintf(buf, sizeof(buf)-30, fmt, ap);
-    yaz_log(level, "Session (%u): %s", s->session_id, buf);
+    yaz_log(level, "Session %u: %s", s->session_id, buf);
 
     va_end(ap);
 }