X-Git-Url: http://jsfdemo.indexdata.com/?a=blobdiff_plain;f=src%2Fclient.c;h=30ef0407b4b25f0c4b7cdd0d4791209d3382d70b;hb=5b6b18f35bb161eafa6f8a8bd0413a35ce637eff;hp=0ae364138febd121880e99894dbb927197e700c8;hpb=7a464badf789151889130191602d5dea5ba1d243;p=pazpar2-moved-to-github.git

diff --git a/src/client.c b/src/client.c
index 0ae3641..30ef040 100644
--- a/src/client.c
+++ b/src/client.c
@@ -1,5 +1,5 @@
 /* This file is part of Pazpar2.
-   Copyright (C) 2006-2011 Index Data
+   Copyright (C) 2006-2012 Index Data
 
 Pazpar2 is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
@@ -18,7 +18,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 /** \file client.c
-    \brief Z39.50 client 
+    \brief Z39.50 client
 */
 
 #if HAVE_CONFIG_H
@@ -108,8 +108,10 @@ struct client {
     struct session *session;
     char *pquery; // Current search
     char *cqlquery; // used for SRU targets only
+    char *addinfo; // diagnostic info for most resent error
     Odr_int hits;
     int record_offset;
+    int filtered; // When using local:, this will count the number of filtered records.
     int maxrecs;
     int startrecs;
     int diagnostic;
@@ -121,6 +123,7 @@ struct client {
     YAZ_MUTEX mutex;
     int ref_count;
     char *id;
+    facet_limits_t facet_limits;
 };
 
 struct suggestions {
@@ -137,6 +140,7 @@ struct show_raw {
     int binary;
     char *syntax;
     char *esn;
+    char *nativesyntax;
     void (*error_handler)(void *data, const char *addinfo);
     void (*record_handler)(void *data, const char *buf, size_t sz);
     void *data;
@@ -184,6 +188,8 @@ void client_set_state(struct client *cl, enum client_state st)
                 client_get_id(cl), no_active);
         if (no_active == 0) {
             session_alert_watch(cl->session, SESSION_WATCH_SHOW);
+            session_alert_watch(cl->session, SESSION_WATCH_BYTARGET);
+            session_alert_watch(cl->session, SESSION_WATCH_TERMLIST);
             session_alert_watch(cl->session, SESSION_WATCH_SHOW_PREF);
         }
     }
@@ -212,15 +218,15 @@ const char *client_get_pquery(struct client *cl)
 }
 
 static void client_send_raw_present(struct client *cl);
-static int nativesyntax_to_type(struct session_database *sdb, char *type,
-                                ZOOM_record rec);
+static int nativesyntax_to_type(const char *s, char *type, ZOOM_record rec);
 
 static void client_show_immediate(
     ZOOM_resultset resultset, struct session_database *sdb, int position,
     void *data,
     void (*error_handler)(void *data, const char *addinfo),
     void (*record_handler)(void *data, const char *buf, size_t sz),
-    int binary)
+    int binary,
+    const char *nativesyntax)
 {
     ZOOM_record rec = 0;
     char type[80];
@@ -232,16 +238,13 @@ static void client_show_immediate(
         error_handler(data, "no resultset");
         return;
     }
-    rec = ZOOM_resultset_record(resultset, position-1);
+    rec = ZOOM_resultset_record_immediate(resultset, position-1);
     if (!rec)
     {
         error_handler(data, "no record");
         return;
     }
-    if (binary)
-        strcpy(type, "raw");
-    else
-        nativesyntax_to_type(sdb, type, rec);
+    nativesyntax_to_type(nativesyntax, type, rec);
     buf = ZOOM_record_get(rec, type, &len);
     if (!buf)
     {
@@ -258,20 +261,32 @@ int client_show_raw_begin(struct client *cl, int position,
                           void (*error_handler)(void *data, const char *addinfo),
                           void (*record_handler)(void *data, const char *buf,
                                                  size_t sz),
-                          int binary)
+                          int binary,
+                          const char *nativesyntax)
 {
+    if (!nativesyntax)
+    {
+        if (binary)
+            nativesyntax = "raw";
+        else
+        {
+            struct session_database *sdb = client_get_database(cl);
+            nativesyntax = session_setting_oneval(sdb, PZ_NATIVESYNTAX);
+        }
+    }
+
     if (syntax == 0 && esn == 0)
         client_show_immediate(cl->resultset, client_get_database(cl),
                               position, data,
                               error_handler, record_handler,
-                              binary);
+                              binary, nativesyntax);
     else
     {
         struct show_raw *rr, **rrp;
 
         if (!cl->connection)
             return -1;
-    
+
 
         rr = xmalloc(sizeof(*rr));
         rr->position = position;
@@ -288,12 +303,16 @@ int client_show_raw_begin(struct client *cl, int position,
             rr->esn = xstrdup(esn);
         else
             rr->esn = 0;
+
+        assert(nativesyntax);
+        rr->nativesyntax = xstrdup(nativesyntax);
+
         rr->next = 0;
-        
+
         for (rrp = &cl->show_raw; *rrp; rrp = &(*rrp)->next)
             ;
         *rrp = rr;
-        
+
         if (cl->state == Client_Failed)
         {
             client_show_raw_error(cl, "client failed");
@@ -314,6 +333,7 @@ static void client_show_raw_delete(struct show_raw *r)
 {
     xfree(r->syntax);
     xfree(r->esn);
+    xfree(r->nativesyntax);
     xfree(r);
 }
 
@@ -382,11 +402,9 @@ static void client_send_raw_present(struct client *cl)
     connection_continue(co);
 }
 
-static int nativesyntax_to_type(struct session_database *sdb, char *type,
+static int nativesyntax_to_type(const char *s, char *type,
                                 ZOOM_record rec)
 {
-    const char *s = session_setting_oneval(sdb, PZ_NATIVESYNTAX);
-
     if (s && *s)
     {
         if (!strncmp(s, "iso2709", 7))
@@ -394,17 +412,13 @@ static int nativesyntax_to_type(struct session_database *sdb, char *type,
             const char *cp = strchr(s, ';');
             yaz_snprintf(type, 80, "xml; charset=%s", cp ? cp+1 : "marc-8s");
         }
-        else if (!strncmp(s, "xml", 3))
-        {
-            strcpy(type, "xml");
-        }
         else if (!strncmp(s, "txml", 4))
         {
             const char *cp = strchr(s, ';');
             yaz_snprintf(type, 80, "txml; charset=%s", cp ? cp+1 : "marc-8s");
         }
-        else
-            return -1;
+        else /* pass verbatim to ZOOM - including "xml" */
+            strcpy(type, s);
         return 0;
     }
     else  /* attempt to deduce structure */
@@ -482,14 +496,7 @@ static void ingest_raw_record(struct client *cl, ZOOM_record rec)
     int len;
     char type[80];
 
-    if (cl->show_raw->binary)
-        strcpy(type, "raw");
-    else
-    {
-        struct session_database *sdb = client_get_database(cl);
-        nativesyntax_to_type(sdb, type, rec);
-    }
-
+    nativesyntax_to_type(cl->show_raw->nativesyntax, type, rec);
     buf = ZOOM_record_get(rec, type, &len);
     cl->show_raw->record_handler(cl->show_raw->data,  buf, len);
     client_show_raw_dequeue(cl);
@@ -526,7 +533,7 @@ void client_search_response(struct client *cl)
     ZOOM_resultset resultset = cl->resultset;
 
     const char *error, *addinfo = 0;
-    
+
     if (ZOOM_connection_error(link, &error, &addinfo))
     {
         cl->hits = 0;
@@ -536,11 +543,10 @@ void client_search_response(struct client *cl)
     }
     else
     {
-        yaz_log(YLOG_DEBUG, "client_search_response: hits "
-                ODR_INT_PRINTF, cl->hits);
         client_report_facets(cl, resultset);
         cl->record_offset = cl->startrecs;
         cl->hits = ZOOM_resultset_size(resultset);
+        yaz_log(YLOG_DEBUG, "client_search_response: hits " ODR_INT_PRINTF, cl->hits);
         if (cl->suggestions)
             client_suggestions_destroy(cl);
         cl->suggestions = client_suggestions_create(ZOOM_resultset_option_get(resultset, "suggestions"));
@@ -552,10 +558,15 @@ void client_got_records(struct client *cl)
     struct session *se = cl->session;
     if (se)
     {
-        client_unlock(cl);
-        session_alert_watch(se, SESSION_WATCH_SHOW);
-        session_alert_watch(se, SESSION_WATCH_RECORD);
-        client_lock(cl);
+        if (reclist_get_num_records(se->reclist) > 0)
+        {
+            client_unlock(cl);
+            session_alert_watch(se, SESSION_WATCH_SHOW);
+            session_alert_watch(se, SESSION_WATCH_BYTARGET);
+            session_alert_watch(se, SESSION_WATCH_TERMLIST);
+            session_alert_watch(se, SESSION_WATCH_RECORD);
+            client_lock(cl);
+        }
     }
 }
 
@@ -565,16 +576,16 @@ static void client_record_ingest(struct client *cl)
     ZOOM_record rec = 0;
     ZOOM_resultset resultset = cl->resultset;
     int offset = cl->record_offset;
-    if ((rec = ZOOM_resultset_record(resultset, offset)))
+    if ((rec = ZOOM_resultset_record_immediate(resultset, offset)))
     {
         cl->record_offset++;
-        if (cl->session == 0)
-            ;
+        if (cl->session == 0) {
+            /* no operation */
+        }
         else if (ZOOM_record_error(rec, &msg, &addinfo, 0))
         {
             yaz_log(YLOG_WARN, "Record error %s (%s): %s (rec #%d)",
-                    msg, addinfo, client_get_id(cl),
-                    cl->record_offset);
+                    msg, addinfo, client_get_id(cl), cl->record_offset);
         }
         else
         {
@@ -582,8 +593,9 @@ static void client_record_ingest(struct client *cl)
             NMEM nmem = nmem_create();
             const char *xmlrec;
             char type[80];
-            
-            if (nativesyntax_to_type(sdb, type, rec))
+
+            const char *s = session_setting_oneval(sdb, PZ_NATIVESYNTAX);
+            if (nativesyntax_to_type(s, type, rec))
                 yaz_log(YLOG_WARN, "Failed to determine record type");
             xmlrec = ZOOM_record_get(rec, type, NULL);
             if (!xmlrec)
@@ -592,16 +604,18 @@ static void client_record_ingest(struct client *cl)
             else
             {
                 /* OK = 0, -1 = failure, -2 = Filtered */
-                if (ingest_record(cl, xmlrec, cl->record_offset, nmem) == -1)
+                int rc = ingest_record(cl, xmlrec, cl->record_offset, nmem);
+                if (rc == -1)
                     yaz_log(YLOG_WARN, "Failed to ingest from %s", client_get_id(cl));
+                if (rc == -2)
+                    cl->filtered += 1;
             }
             nmem_destroy(nmem);
         }
     }
     else
     {
-        yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
-                offset);
+        yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d", offset);
     }
 }
 
@@ -623,8 +637,8 @@ void client_record_response(struct client *cl)
         if (cl->show_raw && cl->show_raw->active)
         {
             ZOOM_record rec = 0;
-            if ((rec = ZOOM_resultset_record(resultset,
-                                             cl->show_raw->position-1)))
+            if ((rec = ZOOM_resultset_record_immediate(
+                     resultset, cl->show_raw->position-1)))
             {
                 cl->show_raw->active = 0;
                 ingest_raw_record(cl, rec);
@@ -646,6 +660,7 @@ void client_reingest(struct client *cl)
 {
     int i = cl->startrecs;
     int to = cl->record_offset;
+    cl->filtered = 0;
 
     cl->record_offset = i;
     for (; i < to; i++)
@@ -657,7 +672,7 @@ static void client_set_facets_request(struct client *cl, ZOOM_connection link)
     struct session_database *sdb = client_get_database(cl);
 
     WRBUF w = wrbuf_alloc();
-    
+
     struct setting *s;
 
     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
@@ -675,7 +690,7 @@ static void client_set_facets_request(struct client *cl, ZOOM_connection link)
                 wrbuf_puts(w, ",");
         }
     }
-    yaz_log(YLOG_LOG, "using facets str: %s", wrbuf_cstr(w));
+    yaz_log(YLOG_DEBUG, "using facets str: %s", wrbuf_cstr(w));
     ZOOM_connection_option_set(link, "facets",
                                wrbuf_len(w) ? wrbuf_cstr(w) : 0);
     wrbuf_destroy(w);
@@ -695,12 +710,37 @@ int client_has_facet(struct client *cl, const char *name)
     return 0;
 }
 
-void client_start_search(struct client *cl, const char *sort_strategy_and_spec,
-                         int increasing)
+static const char *get_strategy_plus_sort(struct client *l, const char *field)
+{
+    struct session_database *sdb = client_get_database(l);
+    struct setting *s;
+
+    const char *strategy_plus_sort = 0;
+
+    for (s = sdb->settings[PZ_SORTMAP]; s; s = s->next)
+    {
+        char *p = strchr(s->name + 3, ':');
+        if (!p)
+        {
+            yaz_log(YLOG_WARN, "Malformed sortmap name: %s", s->name);
+            continue;
+        }
+        p++;
+        if (!strcmp(p, field))
+        {
+            strategy_plus_sort = s->value;
+            break;
+        }
+    }
+    return strategy_plus_sort;
+}
+
+void client_start_search(struct client *cl)
 {
     struct session_database *sdb = client_get_database(cl);
     struct connection *co = client_get_connection(cl);
     ZOOM_connection link = connection_get_link(co);
+    struct session *se = client_get_session(cl);
     ZOOM_resultset rs;
     const char *opt_piggyback   = session_setting_oneval(sdb, PZ_PIGGYBACK);
     const char *opt_queryenc    = session_setting_oneval(sdb, PZ_QUERYENCODING);
@@ -711,14 +751,18 @@ void client_start_search(struct client *cl, const char *sort_strategy_and_spec,
     const char *opt_sort        = session_setting_oneval(sdb, PZ_SORT);
     const char *opt_preferred   = session_setting_oneval(sdb, PZ_PREFERRED);
     const char *extra_args      = session_setting_oneval(sdb, PZ_EXTRA_ARGS);
-    char maxrecs_str[24], startrecs_str[24];
-    ZOOM_query q;
-
+    const char *opt_present_chunk = session_setting_oneval(sdb, PZ_PRESENT_CHUNK);
+    ZOOM_query query;
+    char maxrecs_str[24], startrecs_str[24], present_chunk_str[24];
+    int present_chunk = 20; // Default chunk size
+    if (opt_present_chunk && strcmp(opt_present_chunk,"")) {
+        present_chunk = atoi(opt_present_chunk);
+        yaz_log(YLOG_DEBUG, "Present chunk set to %d", present_chunk);
+    }
     assert(link);
 
-    cl->hits = 0;
-    cl->record_offset = 0;
     cl->diagnostic = 0;
+    cl->filtered = 0;
 
     if (extra_args && *extra_args)
         ZOOM_connection_option_set(link, "extraArgs", extra_args);
@@ -729,7 +773,6 @@ void client_start_search(struct client *cl, const char *sort_strategy_and_spec,
             yaz_log(YLOG_LOG, "Target %s has preferred status: %d",
                     client_get_id(cl), cl->preferred);
     }
-    client_set_state(cl, Client_Working);
 
     if (*opt_piggyback)
         ZOOM_connection_option_set(link, "piggyback", opt_piggyback);
@@ -753,11 +796,16 @@ void client_start_search(struct client *cl, const char *sort_strategy_and_spec,
     sprintf(maxrecs_str, "%d", cl->maxrecs);
     ZOOM_connection_option_set(link, "count", maxrecs_str);
 
-    if (cl->maxrecs > 20)
-        ZOOM_connection_option_set(link, "presentChunk", "20");
-    else
+    /* A present_chunk less than 1 will disable chunking. */
+    if (present_chunk > 0 && cl->maxrecs > present_chunk) {
+        sprintf(present_chunk_str, "%d", present_chunk);
+        ZOOM_connection_option_set(link, "presentChunk", present_chunk_str);
+        yaz_log(YLOG_DEBUG, "Present chunk set to %s", present_chunk_str);
+    }
+    else {
         ZOOM_connection_option_set(link, "presentChunk", maxrecs_str);
-
+        yaz_log(YLOG_DEBUG, "Present chunk set to %s (maxrecs)", maxrecs_str);
+    }
     sprintf(startrecs_str, "%d", cl->startrecs);
     ZOOM_connection_option_set(link, "start", startrecs_str);
 
@@ -765,42 +813,62 @@ void client_start_search(struct client *cl, const char *sort_strategy_and_spec,
     /* facets definition is in PQF */
     client_set_facets_request(cl, link);
 
-    q = ZOOM_query_create();
+    query = ZOOM_query_create();
     if (cl->cqlquery)
     {
-        yaz_log(YLOG_LOG, "Search %s CQL: %s", client_get_id(cl),
-                cl->cqlquery);
-        ZOOM_query_cql(q, cl->cqlquery);
+        yaz_log(YLOG_LOG, "Client %s: Search CQL: %s", client_get_id(cl), cl->cqlquery);
+        ZOOM_query_cql(query, cl->cqlquery);
         if (*opt_sort)
-            ZOOM_query_sortby(q, opt_sort);
+            ZOOM_query_sortby(query, opt_sort);
     }
     else
     {
-        yaz_log(YLOG_LOG, "Search %s PQF: %s", client_get_id(cl), cl->pquery);
-        
-        ZOOM_query_prefix(q, cl->pquery);
+        yaz_log(YLOG_LOG, "Client %s: Search PQF: %s", client_get_id(cl), cl->pquery);
+
+        ZOOM_query_prefix(query, cl->pquery);
     }
-    if (sort_strategy_and_spec &&
-        strlen(sort_strategy_and_spec) < 40 /* spec below */)
-    {
-        char spec[50], *p;
-        strcpy(spec, sort_strategy_and_spec);
-        p = strchr(spec, ':');
-        if (p)
+    if (se->sorted_results)
+    {   /* first entry is current sorting ! */
+        const char *sort_strategy_and_spec =
+            get_strategy_plus_sort(cl, se->sorted_results->name);
+        int increasing = se->sorted_results->increasing;
+        // int position = se->sorted_results->type;
+        if (sort_strategy_and_spec && strlen(sort_strategy_and_spec) < 40)
         {
-            *p++ = '\0'; /* cut the string in two */
-            while (*p == ' ')
-                p++;
-            if (increasing)
-                strcat(p, " <");
-            else
-                strcat(p, " >");
-            yaz_log(YLOG_LOG, "applying %s %s", spec, p);
-            ZOOM_query_sortby2(q, spec, p);
+            char spec[50], *p;
+            strcpy(spec, sort_strategy_and_spec);
+            p = strchr(spec, ':');
+            if (p)
+            {
+                *p++ = '\0'; /* cut the string in two */
+                while (*p == ' ')
+                    p++;
+                if (increasing)
+                    strcat(p, " <");
+                else
+                    strcat(p, " >");
+                yaz_log(YLOG_LOG, "Client %s: applying sorting %s %s", client_get_id(cl), spec, p);
+                ZOOM_query_sortby2(query, spec, p);
+            }
+        }
+        else
+        {
+            /* no native sorting.. If this is not the first search, then skip it entirely */
+            if (se->sorted_results->next)
+            {
+                // TODO this seems wrong. Need to re-ingest instead?
+                yaz_log(YLOG_DEBUG,"Client %s: Do not (re)search anyway", client_get_id(cl));
+                ZOOM_query_destroy(query);
+                return;
+            }
         }
     }
-    rs = ZOOM_connection_search(link, q);
-    ZOOM_query_destroy(q);
+    yaz_log(YLOG_DEBUG,"Client %s: Starting search", client_get_id(cl));
+    client_set_state(cl, Client_Working);
+    cl->hits = 0;
+    cl->record_offset = 0;
+    rs = ZOOM_connection_search(link, query);
+    ZOOM_query_destroy(query);
     ZOOM_resultset_destroy(cl->resultset);
     cl->resultset = rs;
     connection_continue(co);
@@ -813,11 +881,13 @@ struct client *client_create(const char *id)
     cl->startrecs = 0;
     cl->pquery = 0;
     cl->cqlquery = 0;
+    cl->addinfo = 0;
     cl->database = 0;
     cl->connection = 0;
     cl->session = 0;
     cl->hits = 0;
     cl->record_offset = 0;
+    cl->filtered = 0;
     cl->diagnostic = 0;
     cl->state = Client_Disconnected;
     cl->show_raw = 0;
@@ -827,10 +897,11 @@ struct client *client_create(const char *id)
     pazpar2_mutex_create(&cl->mutex, "client");
     cl->preferred = 0;
     cl->ref_count = 1;
+    cl->facet_limits = 0;
     assert(id);
     cl->id = xstrdup(id);
     client_use(1);
-    
+
     return cl;
 }
 
@@ -863,8 +934,11 @@ int client_destroy(struct client *c)
             c->pquery = 0;
             xfree(c->cqlquery);
             c->cqlquery = 0;
+            xfree(c->addinfo);
+            c->addinfo = 0;
             xfree(c->id);
             assert(!c->connection);
+            facet_limits_destroy(c->facet_limits);
 
             if (c->resultset)
             {
@@ -905,7 +979,7 @@ void client_disconnect(struct client *cl)
 
 
 // Initialize CCL map for a target
-static CCL_bibset prepare_cclmap(struct client *cl)
+static CCL_bibset prepare_cclmap(struct client *cl, CCL_bibset base_bibset)
 {
     struct session_database *sdb = client_get_database(cl);
     struct setting *s;
@@ -913,94 +987,131 @@ static CCL_bibset prepare_cclmap(struct client *cl)
 
     if (!sdb->settings)
         return 0;
-    res = ccl_qual_mk();
+    if (base_bibset)
+        res = ccl_qual_dup(base_bibset);
+    else
+        res = ccl_qual_mk();
     for (s = sdb->settings[PZ_CCLMAP]; s; s = s->next)
     {
+        const char *addinfo = 0;
         char *p = strchr(s->name + 3, ':');
         if (!p)
         {
-            yaz_log(YLOG_WARN, "Malformed cclmap name: %s", s->name);
+            WRBUF w = wrbuf_alloc();
+            wrbuf_printf(w, "Malformed cclmap. name=%s", s->name);
+            yaz_log(YLOG_WARN, "%s: %s", client_get_id(cl), wrbuf_cstr(w));
+            client_set_diagnostic(cl, ZOOM_ERROR_CCL_CONFIG, wrbuf_cstr(w));
+            client_set_state_nb(cl, Client_Error);
             ccl_qual_rm(&res);
+            wrbuf_destroy(w);
             return 0;
         }
         p++;
-        ccl_qual_fitem(res, s->value, p);
+        if (ccl_qual_fitem2(res, s->value, p, &addinfo))
+        {
+            WRBUF w = wrbuf_alloc();
+
+            wrbuf_printf(w, "Malformed cclmap. name=%s: value=%s (%s)",
+                         s->name, p, addinfo);
+            yaz_log(YLOG_WARN, "%s: %s", client_get_id(cl), wrbuf_cstr(w));
+            client_set_diagnostic(cl, ZOOM_ERROR_CCL_CONFIG, wrbuf_cstr(w));
+            client_set_state_nb(cl, Client_Error);
+            ccl_qual_rm(&res);
+            wrbuf_destroy(w);
+            return 0;
+        }
     }
     return res;
 }
 
 // returns a xmalloced CQL query corresponding to the pquery in client
-static char *make_cqlquery(struct client *cl)
+static char *make_cqlquery(struct client *cl, Z_RPNQuery *zquery)
 {
     cql_transform_t cqlt = cql_transform_create();
-    Z_RPNQuery *zquery;
-    char *r;
+    char *r = 0;
     WRBUF wrb = wrbuf_alloc();
     int status;
-    ODR odr_out = odr_createmem(ODR_ENCODE);
 
-    zquery = p_query_rpn(odr_out, cl->pquery);
-    yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
     if ((status = cql_transform_rpn2cql_wrbuf(cqlt, wrb, zquery)))
     {
         yaz_log(YLOG_WARN, "Failed to generate CQL query, code=%d", status);
-        r = 0;
     }
     else
     {
         r = xstrdup(wrbuf_cstr(wrb));
-    }     
+    }
     wrbuf_destroy(wrb);
-    odr_destroy(odr_out);
     cql_transform_close(cqlt);
     return r;
 }
 
 // returns a xmalloced SOLR query corresponding to the pquery in client
 // TODO Could prob. be merge with the similar make_cqlquery
-static char *make_solrquery(struct client *cl)
+static char *make_solrquery(struct client *cl, Z_RPNQuery *zquery)
 {
     solr_transform_t sqlt = solr_transform_create();
-    Z_RPNQuery *zquery;
-    char *r;
+    char *r = 0;
     WRBUF wrb = wrbuf_alloc();
     int status;
-    ODR odr_out = odr_createmem(ODR_ENCODE);
 
-    zquery = p_query_rpn(odr_out, cl->pquery);
-    if (zquery == 0) {
-        yaz_log(YLOG_WARN, "Failed to generate RPN from PQF: %s", cl->pquery);
-        return 0;
-    }
-    yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
     if ((status = solr_transform_rpn2solr_wrbuf(sqlt, wrb, zquery)))
     {
-        yaz_log(YLOG_WARN, "Failed to generate SOLR query from PQF %s, code=%d", cl->pquery, status);
-        r = 0;
+        yaz_log(YLOG_WARN, "Failed to generate SOLR query, code=%d", status);
     }
     else
     {
         r = xstrdup(wrbuf_cstr(wrb));
     }
     wrbuf_destroy(wrb);
-    odr_destroy(odr_out);
     solr_transform_close(sqlt);
     return r;
 }
 
+const char *client_get_facet_limit_local(struct client *cl,
+                                         struct session_database *sdb,
+                                         int *l,
+                                         NMEM nmem, int *num, char ***values)
+{
+    const char *name = 0;
+    const char *value = 0;
+    for (; (name = facet_limits_get(cl->facet_limits, *l, &value)); (*l)++)
+    {
+        struct setting *s = 0;
+
+        for (s = sdb->settings[PZ_LIMITMAP]; s; s = s->next)
+        {
+            const char *p = strchr(s->name + 3, ':');
+            if (p && !strcmp(p + 1, name) && s->value &&
+                !strncmp(s->value, "local:", 6))
+            {
+                const char *cp = s->value + 6;
+                while (*cp == ' ')
+                    cp++;
+
+                nmem_strsplit_escape2(nmem, "|", value, values,
+                                      num, 1, '\\', 1);
+                (*l)++;
+                return *cp ? cp : name;
+            }
+        }
+    }
+    return 0;
+}
+
 static int apply_limit(struct session_database *sdb,
                        facet_limits_t facet_limits,
-                       WRBUF w_pqf, WRBUF w_ccl)
+                       WRBUF w_pqf, CCL_bibset ccl_map)
 {
     int ret = 0;
     int i = 0;
     const char *name;
     const char *value;
+
     NMEM nmem_tmp = nmem_create();
     for (i = 0; (name = facet_limits_get(facet_limits, i, &value)); i++)
     {
         struct setting *s = 0;
-        
+        nmem_reset(nmem_tmp);
         for (s = sdb->settings[PZ_LIMITMAP]; s; s = s->next)
         {
             const char *p = strchr(s->name + 3, ':');
@@ -1029,23 +1140,38 @@ static int apply_limit(struct session_database *sdb,
                 else if (!strncmp(s->value, "ccl:", 4))
                 {
                     const char *ccl = s->value + 4;
-
-                    wrbuf_puts(w_ccl, " and (");
-
+                    WRBUF ccl_w = wrbuf_alloc();
                     for (i = 0; i < num; i++)
                     {
-                        if (i)
-                            wrbuf_puts(w_ccl, " or ");
-                        wrbuf_puts(w_ccl, ccl);
-                        wrbuf_puts(w_ccl, "=\"");
-                        wrbuf_puts(w_ccl, values[i]);
-                        wrbuf_puts(w_ccl, "\"");
+                        int cerror, cpos;
+                        struct ccl_rpn_node *cn;
+
+                        wrbuf_rewind(ccl_w);
+                        wrbuf_puts(ccl_w, ccl);
+                        wrbuf_puts(ccl_w, "=\"");
+                        wrbuf_puts(ccl_w, values[i]);
+                        wrbuf_puts(ccl_w, "\"");
+
+                        cn = ccl_find_str(ccl_map, wrbuf_cstr(ccl_w),
+                                          &cerror, &cpos);
+                        if (cn)
+                        {
+                            if (i == 0)
+                                wrbuf_printf(w_pqf, "@and ");
+
+                            /* or multiple values.. could be bad if last CCL
+                               parse fails, but this is unlikely to happen */
+                            if (i < num - 1)
+                                wrbuf_printf(w_pqf, "@or ");
+                            ccl_pquery(w_pqf, cn);
+                            ccl_rpn_delete(cn);
+                        }
                     }
-                    wrbuf_puts(w_ccl, ")");
-
+                    wrbuf_destroy(ccl_w);
+                }
+                else if (!strncmp(s->value, "local:", 6)) {
+                    /* no operation */
                 }
-                else if (!strncmp(s->value, "local:", 6))
-                    ;
                 else
                 {
                     yaz_log(YLOG_WARN, "Target %s: Bad limitmap '%s'",
@@ -1055,7 +1181,6 @@ static int apply_limit(struct session_database *sdb,
                 break;
             }
         }
-        nmem_reset(nmem_tmp);
         if (!s)
         {
             yaz_log(YLOG_WARN, "Target %s: limit %s used, but no limitmap defined",
@@ -1065,27 +1190,33 @@ static int apply_limit(struct session_database *sdb,
     nmem_destroy(nmem_tmp);
     return ret;
 }
-                        
+
 // Parse the query given the settings specific to this client
+// return 0 if query is OK but different from before
+// return 1 if query is OK but same as before
+// return -1 on query error
+// return -2 on limit error
 int client_parse_query(struct client *cl, const char *query,
                        facet_limits_t facet_limits,
-                       const char *startrecs, const char *maxrecs)
+                       const char *startrecs, const char *maxrecs,
+                       CCL_bibset bibset)
 {
     struct session *se = client_get_session(cl);
     struct session_database *sdb = client_get_database(cl);
     struct ccl_rpn_node *cn;
     int cerror, cpos;
-    CCL_bibset ccl_map = prepare_cclmap(cl);
+    ODR odr_out;
+    CCL_bibset ccl_map = prepare_cclmap(cl, bibset);
     const char *sru = session_setting_oneval(sdb, PZ_SRU);
     const char *pqf_prefix = session_setting_oneval(sdb, PZ_PQF_PREFIX);
     const char *pqf_strftime = session_setting_oneval(sdb, PZ_PQF_STRFTIME);
     const char *query_syntax = session_setting_oneval(sdb, PZ_QUERY_SYNTAX);
     WRBUF w_ccl, w_pqf;
     int ret_value = 1;
+    Z_RPNQuery *zquery;
 
     if (!ccl_map)
-        return -1;
-
+        return -3;
 
     if (maxrecs && atoi(maxrecs) != cl->maxrecs)
     {
@@ -1109,18 +1240,24 @@ int client_parse_query(struct client *cl, const char *query,
         wrbuf_puts(w_pqf, " ");
     }
 
-    if (apply_limit(sdb, facet_limits, w_pqf, w_ccl))
+    if (apply_limit(sdb, facet_limits, w_pqf, ccl_map))
+    {
+        ccl_qual_rm(&ccl_map);
         return -2;
+    }
 
-    yaz_log(YLOG_LOG, "CCL query: %s", wrbuf_cstr(w_ccl));
+    facet_limits_destroy(cl->facet_limits);
+    cl->facet_limits = facet_limits_dup(facet_limits);
+
+    yaz_log(YLOG_LOG, "Client %s: CCL query: %s", client_get_id(cl), wrbuf_cstr(w_ccl));
     cn = ccl_find_str(ccl_map, wrbuf_cstr(w_ccl), &cerror, &cpos);
     ccl_qual_rm(&ccl_map);
     if (!cn)
     {
         client_set_state(cl, Client_Error);
-        session_log(se, YLOG_WARN, "Failed to parse CCL query '%s' for %s",
-                    wrbuf_cstr(w_ccl),
-                    client_get_id(cl));
+        session_log(se, YLOG_WARN, "Client %s: Failed to parse CCL query '%s'",
+                    client_get_id(cl),
+                    wrbuf_cstr(w_ccl));
         wrbuf_destroy(w_ccl);
         wrbuf_destroy(w_pqf);
         return -1;
@@ -1147,6 +1284,7 @@ int client_parse_query(struct client *cl, const char *query,
                 wrbuf_putc(w_pqf, cp[0]);
         }
     }
+
     if (!cl->pquery || strcmp(cl->pquery, wrbuf_cstr(w_pqf)))
     {
         xfree(cl->pquery);
@@ -1155,35 +1293,46 @@ int client_parse_query(struct client *cl, const char *query,
     }
     wrbuf_destroy(w_pqf);
 
-    yaz_log(YLOG_LOG, "PQF query: %s", cl->pquery);
-
     xfree(cl->cqlquery);
+    cl->cqlquery = 0;
 
-    /* Support for PQF on SRU targets. */
-    /* TODO Refactor */
-    yaz_log(YLOG_DEBUG, "Query syntax: %s", query_syntax);
-    if (strcmp(query_syntax, "pqf") != 0 && *sru)
+    odr_out = odr_createmem(ODR_ENCODE);
+    zquery = p_query_rpn(odr_out, cl->pquery);
+    if (!zquery)
     {
-        if (!strcmp(sru, "solr")) {
-            if (!(cl->cqlquery = make_solrquery(cl)))
-                return -1;
-        }
-        else {
-            if (!(cl->cqlquery = make_cqlquery(cl)))
-                return -1;
-        }
+
+        session_log(se, YLOG_WARN, "Invalid PQF query for Client %s: %s",
+                    client_get_id(cl), cl->pquery);
+        ret_value = -1;
     }
     else
-        cl->cqlquery = 0;
+    {
+        session_log(se, YLOG_LOG, "PQF for Client %s: %s",
+                    client_get_id(cl), cl->pquery);
+
+        /* Support for PQF on SRU targets. */
+        if (strcmp(query_syntax, "pqf") != 0 && *sru)
+        {
+            if (!strcmp(sru, "solr"))
+                cl->cqlquery = make_solrquery(cl, zquery);
+            else
+                cl->cqlquery = make_cqlquery(cl, zquery);
+            if (!cl->cqlquery)
+                ret_value = -1;
+        }
+    }
+    odr_destroy(odr_out);
 
     /* TODO FIX Not thread safe */
     if (!se->relevance)
     {
         // Initialize relevance structure with query terms
-        se->relevance = relevance_create_ccl(
-            se->service->charsets, se->nmem, cn);
+        se->relevance = relevance_create_ccl(se->service->charsets, cn,
+                                             se->service->rank_cluster,
+                                             se->service->rank_follow,
+                                             se->service->rank_lead,
+                                             se->service->rank_length);
     }
-
     ccl_rpn_delete(cn);
     return ret_value;
 }
@@ -1218,18 +1367,40 @@ Odr_int client_get_hits(struct client *cl)
     return cl->hits;
 }
 
+Odr_int client_get_approximation(struct client *cl)
+{
+    if (cl->record_offset > 0) {
+        Odr_int approx = ((10 * cl->hits * (cl->record_offset - cl->filtered)) / cl->record_offset + 5) /10;
+        yaz_log(YLOG_DEBUG, "%s: Approx: %lld * %d / %d = %lld ", client_get_id(cl), cl->hits, cl->record_offset - cl->filtered, cl->record_offset, approx);
+        return approx;
+    }
+    return cl->hits;
+}
+
 int client_get_num_records(struct client *cl)
 {
     return cl->record_offset;
 }
 
-void client_set_diagnostic(struct client *cl, int diagnostic)
+int client_get_num_records_filtered(struct client *cl)
+{
+    return cl->filtered;
+}
+
+void client_set_diagnostic(struct client *cl, int diagnostic,
+                           const char *addinfo)
 {
     cl->diagnostic = diagnostic;
+    xfree(cl->addinfo);
+    cl->addinfo = 0;
+    if (addinfo)
+        cl->addinfo = xstrdup(addinfo);
 }
 
-int client_get_diagnostic(struct client *cl)
+int client_get_diagnostic(struct client *cl, const char **addinfo)
 {
+    if (addinfo)
+        *addinfo = cl->addinfo;
     return cl->diagnostic;
 }
 
@@ -1239,7 +1410,7 @@ const char * client_get_suggestions_xml(struct client *cl, WRBUF wrbuf)
     struct suggestions *suggestions = cl->suggestions;
 
     if (!suggestions) {
-        yaz_log(YLOG_DEBUG, "No suggestions found");
+        //yaz_log(YLOG_DEBUG, "No suggestions found");
         return "";
     }
     if (suggestions->passthrough) {
@@ -1290,11 +1461,11 @@ struct suggestions* client_suggestions_create(const char* suggestions_string)
     int i;
     NMEM nmem;
     struct suggestions *suggestions;
-    if (suggestions_string == 0)
+    if (suggestions_string == 0 || suggestions_string[0] == 0 )
         return 0;
     nmem = nmem_create();
     suggestions = nmem_malloc(nmem, sizeof(*suggestions));
-    yaz_log(YLOG_DEBUG, "client target suggestions: %s", suggestions_string);
+    yaz_log(YLOG_DEBUG, "client target suggestions: %s.", suggestions_string);
 
     suggestions->nmem = nmem;
     suggestions->num = 0;
@@ -1326,6 +1497,11 @@ static void client_suggestions_destroy(struct client *cl)
     nmem_destroy(nmem);
 }
 
+int client_test_sort_order(struct client *cl, struct reclist_sortparms *sp)
+{
+    //TODO implement correctly.
+    return 1;
+}
 /*
  * Local variables:
  * c-basic-offset: 4