X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;ds=sidebyside;f=src%2Fsession.c;h=00af02f9e1b9194c390caca8d339db5b6816078b;hb=3e762d9cf53e8ed8049d43879a32c0e72ad68dc5;hp=fbcd94e8b5241a5a92a8e5350105175e1083fd3a;hpb=20bc8b17d60373c2c93ab6bb777d19dd92ed2960;p=pazpar2-moved-to-github.git

diff --git a/src/session.c b/src/session.c
index fbcd94e..00af02f 100644
--- a/src/session.c
+++ b/src/session.c
@@ -624,7 +624,6 @@ int session_is_preferred_clients_ready(struct session *s)
 static void session_clear_set(struct session *se, struct reclist_sortparms *sp)
 {
     reclist_destroy(se->reclist);
-    se->reclist = 0;
     if (nmem_total(se->nmem))
         session_log(se, YLOG_DEBUG, "NMEN operation usage %zd",
                     nmem_total(se->nmem));
@@ -632,6 +631,8 @@ static void session_clear_set(struct session *se, struct reclist_sortparms *sp)
     se->total_records = se->total_merged = 0;
     se->num_termlists = 0;
 
+    relevance_clear(se->relevance);
+
     /* reset list of sorted results and clear to relevance search */
     se->sorted_results = nmem_malloc(se->nmem, sizeof(*se->sorted_results));
     se->sorted_results->name = nmem_strdup(se->nmem, sp->name);
@@ -645,9 +646,11 @@ static void session_clear_set(struct session *se, struct reclist_sortparms *sp)
     se->reclist = reclist_create(se->nmem);
 }
 
-static void session_sort_unlocked(struct session *se, struct reclist_sortparms *sp)
+static void session_sort_unlocked(struct session *se,
+                                  struct reclist_sortparms *sp,
+                                  const char *mergekey,
+                                  const char *rank)
 {
-    struct reclist_sortparms *sr;
     struct client_list *l;
     const char *field = sp->name;
     int increasing = sp->increasing;
@@ -656,20 +659,42 @@ static void session_sort_unlocked(struct session *se, struct reclist_sortparms *
 
     session_log(se, YLOG_DEBUG, "session_sort field=%s increasing=%d type=%d",
                 field, increasing, type);
-    /* see if we already have sorted for this criteria */
-    for (sr = se->sorted_results; sr; sr = sr->next)
+
+    if (rank && (!se->rank || strcmp(se->rank, rank)))
     {
-        if (!reclist_sortparms_cmp(sr, sp))
-            break;
+        /* new rank must research/reingest anyway */
+        assert(rank);
+        xfree(se->rank);
+        se->rank = *rank ? xstrdup(rank) : 0;
+        clients_research = 1;
+        session_log(se, YLOG_DEBUG, "session_sort: new rank = %s",
+                    rank);
     }
-    if (sr)
+    if (mergekey && (!se->mergekey || strcmp(se->mergekey, mergekey)))
     {
-        session_log(se, YLOG_DEBUG, "search_sort: field=%s increasing=%d type=%d already fetched",
-                    field, increasing, type);
-        return;
+        /* new mergekey must research/reingest anyway */
+        assert(mergekey);
+        xfree(se->mergekey);
+        se->mergekey = *mergekey ? xstrdup(mergekey) : 0;
+        clients_research = 1;
+        session_log(se, YLOG_DEBUG, "session_sort: new mergekey = %s",
+                    mergekey);
+    }
+    if (clients_research == 0)
+    {
+        struct reclist_sortparms *sr;
+        for (sr = se->sorted_results; sr; sr = sr->next)
+            if (!reclist_sortparms_cmp(sr, sp))
+                break;
+        if (sr)
+        {
+            session_log(se, YLOG_DEBUG, "session_sort: field=%s increasing=%d type=%d already fetched",
+                        field, increasing, type);
+            return;
+        }
     }
-    session_log(se, YLOG_DEBUG, "search_sort: field=%s increasing=%d type=%d must fetch",
-                    field, increasing, type);
+    session_log(se, YLOG_DEBUG, "session_sort: field=%s increasing=%d type=%d must fetch",
+                field, increasing, type);
 
     // We need to reset reclist on every sort that changes the records, not just for position
     // So if just one client requires new searching, we need to clear set.
@@ -682,21 +707,23 @@ static void session_sort_unlocked(struct session *se, struct reclist_sortparms *
         client_parse_init(cl, 1);
         clients_research += client_parse_sort(cl, sp);
     }
-    if (clients_research) {
+    if (clients_research)
+    {
         session_log(se, YLOG_DEBUG,
-                    "Reset results due to %d clients researching",
+                    "session_sort: reset results due to %d clients researching",
                     clients_research);
         session_clear_set(se, sp);
     }
-    else {
+    else
+    {
         // A new sorting based on same record set
-        sr = nmem_malloc(se->nmem, sizeof(*sr));
+        struct reclist_sortparms *sr = nmem_malloc(se->nmem, sizeof(*sr));
         sr->name = nmem_strdup(se->nmem, field);
         sr->increasing = increasing;
         sr->type = type;
         sr->next = se->sorted_results;
         se->sorted_results = sr;
-        session_log(se, YLOG_DEBUG, "No research/ingesting done");
+        session_log(se, YLOG_DEBUG, "session_sort: no research/ingesting done");
         return ;
     }
     session_log(se, YLOG_DEBUG, "Re- search/ingesting for clients due to change in sort order");
@@ -709,18 +736,21 @@ static void session_sort_unlocked(struct session *se, struct reclist_sortparms *
             client_get_state(cl) == Client_Working) {
             client_start_search(cl);
         }
-        else {
+        else
+        {
             session_log(se, YLOG_DEBUG,
-                        "Client %s: No re-start/ingest in show. Wrong client state: %d",
+                        "session_sort: %s: No re-start/ingest in show. "
+                        "Wrong client state: %d",
                         client_get_id(cl), client_get_state(cl));
         }
-
     }
 }
 
-void session_sort(struct session *se, struct reclist_sortparms *sp) {
+void session_sort(struct session *se, struct reclist_sortparms *sp,
+                  const char *mergekey, const char *rank)
+{
     //session_enter(se, "session_sort");
-    session_sort_unlocked(se, sp);
+    session_sort_unlocked(se, sp, mergekey, rank);
     //session_leave(se, "session_sort");
 }
 
@@ -732,7 +762,9 @@ enum pazpar2_error_code session_search(struct session *se,
                                        const char *filter,
                                        const char *limit,
                                        const char **addinfo,
-                                       struct reclist_sortparms *sp)
+                                       struct reclist_sortparms *sp,
+                                       const char *mergekey,
+                                       const char *rank)
 {
     int live_channels = 0;
     int no_working = 0;
@@ -753,6 +785,17 @@ enum pazpar2_error_code session_search(struct session *se,
     session_enter(se, "session_search");
     se->settings_modified = 0;
 
+    if (mergekey)
+    {
+        xfree(se->mergekey);
+        se->mergekey = *mergekey ? xstrdup(mergekey) : 0;
+    }
+    if (rank)
+    {
+        xfree(se->rank);
+        se->rank = *rank ? xstrdup(rank) : 0;
+    }
+
     session_clear_set(se, sp);
     relevance_destroy(&se->relevance);
 
@@ -926,6 +969,8 @@ void session_destroy(struct session *se)
     normalize_cache_destroy(se->normalize_cache);
     relevance_destroy(&se->relevance);
     reclist_destroy(se->reclist);
+    xfree(se->mergekey);
+    xfree(se->rank);
     if (nmem_total(se->nmem))
         session_log(se, YLOG_DEBUG, "NMEN operation usage %zd", nmem_total(se->nmem));
     if (nmem_total(se->session_nmem))
@@ -965,7 +1010,7 @@ struct session *new_session(NMEM nmem, struct conf_service *service,
     session->number_of_warnings_unknown_elements = 0;
     session->number_of_warnings_unknown_metadata = 0;
     session->num_termlists = 0;
-    session->reclist = 0;
+    session->reclist = reclist_create(nmem);
     session->clients_active = 0;
     session->clients_cached = 0;
     session->settings_modified = 0;
@@ -974,6 +1019,8 @@ struct session *new_session(NMEM nmem, struct conf_service *service,
     session->databases = 0;
     session->sorted_results = 0;
     session->facet_limits = 0;
+    session->mergekey = 0;
+    session->rank = 0;
 
     for (i = 0; i <= SESSION_WATCH_MAX; i++)
     {
@@ -1207,22 +1254,19 @@ struct record_cluster *show_single_start(struct session *se, const char *id,
     session_enter(se, "show_single_start");
     *prev_r = 0;
     *next_r = 0;
-    if (se->reclist)
-    {
-        reclist_limit(se->reclist, se);
+    reclist_limit(se->reclist, se);
 
-        reclist_enter(se->reclist);
-        while ((r = reclist_read_record(se->reclist)))
+    reclist_enter(se->reclist);
+    while ((r = reclist_read_record(se->reclist)))
+    {
+        if (!strcmp(r->recid, id))
         {
-            if (!strcmp(r->recid, id))
-            {
-                *next_r = reclist_read_record(se->reclist);
-                break;
-            }
-            *prev_r = r;
+            *next_r = reclist_read_record(se->reclist);
+            break;
         }
-        reclist_leave(se->reclist);
+        *prev_r = r;
     }
+    reclist_leave(se->reclist);
     if (!r)
         session_leave(se, "show_single_start");
     return r;
@@ -1321,9 +1365,7 @@ struct record_cluster **show_range_start(struct session *se,
                 client_update_show_stat(rec->client, 1);
         }
     }
-    if (*num > 0)
-        recs =
-            nmem_malloc(se->nmem, *num * sizeof(struct record_cluster *));
+    recs = nmem_malloc(se->nmem, (*num > 0 ? *num : 1) * sizeof(*recs));
     for (i = 0; i < *num; i++)
     {
         struct record_cluster *r = reclist_read_record(se->reclist);
@@ -1458,6 +1500,26 @@ static struct record_metadata *record_metadata_init(
     return rec_md;
 }
 
+static void mergekey_norm_wr(pp2_charset_fact_t charsets,
+                             WRBUF norm_wr, const char *value)
+{
+    const char *norm_str;
+    pp2_charset_token_t prt =
+        pp2_charset_token_create(charsets, "mergekey");
+
+    pp2_charset_token_first(prt, value, 0);
+    while ((norm_str = pp2_charset_token_next(prt)))
+    {
+        if (*norm_str)
+        {
+            if (wrbuf_len(norm_wr))
+                wrbuf_puts(norm_wr, " ");
+            wrbuf_puts(norm_wr, norm_str);
+        }
+    }
+    pp2_charset_token_destroy(prt);
+}
+
 static int get_mergekey_from_doc(xmlDoc *doc, xmlNode *root, const char *name,
                                  struct conf_service *service, WRBUF norm_wr)
 {
@@ -1476,29 +1538,17 @@ static int get_mergekey_from_doc(xmlDoc *doc, xmlNode *root, const char *name,
             else if (!strcmp(name, (const char *) type))
             {
                 xmlChar *value = xmlNodeListGetString(doc, n->children, 1);
-                if (value)
+                if (value && *value)
                 {
-                    const char *norm_str;
-                    pp2_charset_token_t prt =
-                        pp2_charset_token_create(service->charsets, "mergekey");
-
-                    pp2_charset_token_first(prt, (const char *) value, 0);
                     if (wrbuf_len(norm_wr) > 0)
                         wrbuf_puts(norm_wr, " ");
                     wrbuf_puts(norm_wr, name);
-                    while ((norm_str =
-                            pp2_charset_token_next(prt)))
-                    {
-                        if (*norm_str)
-                        {
-                            wrbuf_puts(norm_wr, " ");
-                            wrbuf_puts(norm_wr, norm_str);
-                        }
-                    }
-                    xmlFree(value);
-                    pp2_charset_token_destroy(prt);
+                    mergekey_norm_wr(service->charsets, norm_wr,
+                                     (const char *) value);
                     no_found++;
                 }
+                if (value)
+                    xmlFree(value);
             }
             xmlFree(type);
         }
@@ -1507,31 +1557,27 @@ static int get_mergekey_from_doc(xmlDoc *doc, xmlNode *root, const char *name,
 }
 
 static const char *get_mergekey(xmlDoc *doc, struct client *cl, int record_no,
-                                struct conf_service *service, NMEM nmem)
+                                struct conf_service *service, NMEM nmem,
+                                const char *session_mergekey)
 {
     char *mergekey_norm = 0;
     xmlNode *root = xmlDocGetRootElement(doc);
     WRBUF norm_wr = wrbuf_alloc();
+    xmlChar *mergekey;
 
-    /* consider mergekey from XSL first */
-    xmlChar *mergekey = xmlGetProp(root, (xmlChar *) "mergekey");
-    if (mergekey)
+    if (session_mergekey)
     {
-        const char *norm_str;
-        pp2_charset_token_t prt =
-            pp2_charset_token_create(service->charsets, "mergekey");
+        int i, num = 0;
+        char **values = 0;
+        nmem_strsplit_escape2(nmem, ",", session_mergekey, &values,
+                              &num, 1, '\\', 1);
 
-        pp2_charset_token_first(prt, (const char *) mergekey, 0);
-        while ((norm_str = pp2_charset_token_next(prt)))
-        {
-            if (*norm_str)
-            {
-                if (wrbuf_len(norm_wr))
-                    wrbuf_puts(norm_wr, " ");
-                wrbuf_puts(norm_wr, norm_str);
-            }
-        }
-        pp2_charset_token_destroy(prt);
+        for (i = 0; i < num; i++)
+            get_mergekey_from_doc(doc, root, values[i], service, norm_wr);
+    }
+    else if ((mergekey = xmlGetProp(root, (xmlChar *) "mergekey")))
+    {
+        mergekey_norm_wr(service->charsets, norm_wr, (const char *) mergekey);
         xmlFree(mergekey);
     }
     else
@@ -1673,7 +1719,8 @@ int ingest_record(struct client *cl, const char *rec,
         return -2;
     }
 
-    mergekey_norm = get_mergekey(xdoc, cl, record_no, service, nmem);
+    mergekey_norm = get_mergekey(xdoc, cl, record_no, service, nmem,
+        se->mergekey);
     if (!mergekey_norm)
     {
         session_log(se, YLOG_WARN, "Got no mergekey");
@@ -1681,7 +1728,7 @@ int ingest_record(struct client *cl, const char *rec,
         return -1;
     }
     session_enter(se, "ingest_record");
-    if (client_get_session(cl) == se)
+    if (client_get_session(cl) == se && se->relevance)
         ret = ingest_to_cluster(cl, xdoc, root, record_no, mergekey_norm);
     session_leave(se, "ingest_record");
 
@@ -1691,12 +1738,15 @@ int ingest_record(struct client *cl, const char *rec,
 
 //    struct conf_metadata *ser_md = &service->metadata[md_field_id];
 //    struct record_metadata *rec_md = record->metadata[md_field_id];
-static int match_metadata_local(struct conf_metadata *ser_md,
+static int match_metadata_local(struct conf_service *service,
+                                struct conf_metadata *ser_md,
                                 struct record_metadata *rec_md0,
                                 char **values, int num_v)
 {
     int i;
     struct record_metadata *rec_md = rec_md0;
+    WRBUF val_wr = 0;
+    WRBUF text_wr = wrbuf_alloc();
     for (i = 0; i < num_v; )
     {
         if (rec_md)
@@ -1711,21 +1761,29 @@ static int match_metadata_local(struct conf_metadata *ser_md,
             }
             else
             {
-                yaz_log(YLOG_DEBUG, "cmp: '%s' '%s'", rec_md->data.text.disp, values[i]);
-                if (!strcmp(rec_md->data.text.disp, values[i]))
+                if (!val_wr)
                 {
-                    // Value equals, should not be filtered.
-                    break;
+                    val_wr = wrbuf_alloc();
+                    mergekey_norm_wr(service->charsets, val_wr, values[i]);
                 }
+                wrbuf_rewind(text_wr);
+                mergekey_norm_wr(service->charsets, text_wr,
+                                 rec_md->data.text.disp);
+                if (!strcmp(wrbuf_cstr(val_wr), wrbuf_cstr(text_wr)))
+                    break;
             }
             rec_md = rec_md->next;
         }
         else
         {
             rec_md = rec_md0;
+            wrbuf_destroy(val_wr);
+            val_wr = 0;
             i++;
         }
     }
+    wrbuf_destroy(val_wr);
+    wrbuf_destroy(text_wr);
     return i < num_v ? 1 : 0;
 }
 
@@ -1761,7 +1819,8 @@ int session_check_cluster_limit(struct session *se, struct record_cluster *rec)
                 nmem_strsplit_escape2(nmem_tmp, "|", value, &values,
                                       &num, 1, '\\', 1);
 
-                if (!match_metadata_local(&service->metadata[md_field_id],
+                if (!match_metadata_local(service,
+                                          &service->metadata[md_field_id],
                                           rec->metadata[md_field_id],
                                           values, num))
                 {
@@ -1803,6 +1862,7 @@ static int check_limit_local(struct client *cl,
                  md_field_id++)
             {
                 if (match_metadata_local(
+                        service,
                         &service->metadata[md_field_id],
                         record->metadata[md_field_id],
                         values, num_v))
@@ -1820,6 +1880,7 @@ static int check_limit_local(struct client *cl,
                 break;
             }
             if (!match_metadata_local(
+                    service,
                     &service->metadata[md_field_id],
                     record->metadata[md_field_id],
                     values, num_v))
@@ -1847,6 +1908,9 @@ static int ingest_to_cluster(struct client *cl,
     struct record_cluster *cluster;
     struct record_metadata **metadata0;
     struct session_database *sdb = client_get_database(cl);
+    NMEM ingest_nmem = 0;
+    char **rank_values = 0;
+    int rank_num = 0;
     struct record *record = record_create(se->nmem,
                                           service->num_metadata,
                                           service->num_sortkeys, cl,
@@ -1954,6 +2018,14 @@ static int ingest_to_cluster(struct client *cl,
     memcpy(metadata0, cluster->metadata,
            sizeof(*metadata0) * service->num_metadata);
 
+    ingest_nmem = nmem_create();
+    if (se->rank)
+    {
+        yaz_log(YLOG_LOG, "local in sort : %s", se->rank);
+        nmem_strsplit_escape2(ingest_nmem, ",", se->rank, &rank_values,
+                              &rank_num, 1, '\\', 1);
+    }
+
     // now parsing XML record and adding data to cluster or record metadata
     for (n = root->children; n; n = n->next)
     {
@@ -1974,8 +2046,8 @@ static int ingest_to_cluster(struct client *cl,
             struct record_metadata *rec_md = 0;
             int md_field_id = -1;
             int sk_field_id = -1;
-            const char *rank;
-            xmlChar *xml_rank;
+            const char *rank = 0;
+            xmlChar *xml_rank = 0;
 
             type = xmlGetProp(n, (xmlChar *) "type");
             value = xmlNodeListGetString(xdoc, n->children, 1);
@@ -2005,8 +2077,28 @@ static int ingest_to_cluster(struct client *cl,
             if (!rec_md)
                 continue;
 
-            xml_rank = xmlGetProp(n, (xmlChar *) "rank");
-            rank = xml_rank ? (const char *) xml_rank : ser_md->rank;
+            if (rank_num)
+            {
+                int i;
+                for (i = 0; i < rank_num; i++)
+                {
+                    const char *val = rank_values[i];
+                    const char *cp = strchr(val, '=');
+                    if (!cp)
+                        continue;
+                    if ((cp - val) == strlen((const char *) type)
+                        && !memcmp(val, type, cp - val))
+                    {
+                        rank = cp + 1;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                xml_rank = xmlGetProp(n, (xmlChar *) "rank");
+                rank = xml_rank ? (const char *) xml_rank : ser_md->rank;
+            }
 
             wheretoput = &cluster->metadata[md_field_id];
 
@@ -2145,6 +2237,7 @@ static int ingest_to_cluster(struct client *cl,
     if (value)
         xmlFree(value);
 
+    nmem_destroy(ingest_nmem);
     xfree(metadata0);
     relevance_donerecord(se->relevance, cluster);
     se->total_records++;
@@ -2159,7 +2252,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 ? s->session_id : 0, buf);
 
     va_end(ap);
 }