relevance-h now calculates some kind of round-robin score

[pazpar2-moved-to-github.git] / src / reclists.c

diff --git a/src/reclists.c b/src/reclists.c
index 2594430..bec6268 100644 (file)
--- a/src/reclists.c
+++ b/src/reclists.c
@@ -1,5 +1,5 @@
 /* This file is part of Pazpar2.
-   Copyright (C) 2006-2012 Index Data
+   Copyright (C) 2006-2013 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
@@ -101,6 +101,10 @@ struct reclist_sortparms *reclist_parse_sortparms(NMEM nmem, const char *parms,
             {
                 type = Metadata_sortkey_relevance;
             }
+            else if (!strcmp(parm, "relevance_h"))
+            {
+                type = Metadata_sortkey_relevance_h;
+            }
             else if (!strcmp(parm, "position"))
             {
                 type = Metadata_sortkey_position;
@@ -159,6 +163,9 @@ static int reclist_cmp(const void *p1, const void *p2)
         case Metadata_sortkey_relevance:
             res = r2->relevance_score - r1->relevance_score;
             break;
+        case Metadata_sortkey_relevance_h:
+            res = r2->relevance_score - r1->relevance_score;
+            break;
         case Metadata_sortkey_string:
             s1 = ut1 ? ut1->text.sort : "";
             s2 = ut2 ? ut2->text.sort : "";
@@ -209,27 +216,31 @@ static int reclist_cmp(const void *p1, const void *p2)
     return res;
 }
 
-void reclist_limit(struct reclist *l, struct session *se)
+void reclist_limit(struct reclist *l, struct session *se, int lazy)
 {
     unsigned i;
     int num = 0;
     struct reclist_bucket **pp = &l->sorted_list;
 
     reclist_enter(l);
-    for (i = 0; i < l->hash_size; i++)
+
+    if (!lazy || !*pp)
     {
-        struct reclist_bucket *p;
-        for (p = l->hashtable[i]; p; p = p->hash_next)
+        for (i = 0; i < l->hash_size; i++)
         {
-            if (session_check_cluster_limit(se, p->record))
+            struct reclist_bucket *p;
+            for (p = l->hashtable[i]; p; p = p->hash_next)
             {
-                *pp = p;
-                pp = &p->sorted_next;
-                num++;
+                if (session_check_cluster_limit(se, p->record))
+                {
+                    *pp = p;
+                    pp = &p->sorted_next;
+                    num++;
+                }
             }
         }
+        *pp = 0;
     }
-    *pp = 0;
     l->num_records = num;
     reclist_leave(l);
 }
@@ -362,21 +373,20 @@ struct record_cluster *reclist_insert(struct reclist *l,
         // We found a matching record. Merge them
         if (!strcmp(merge_key, (*p)->record->merge_key))
         {
-            struct record_cluster *existing = (*p)->record;
-            struct record *re = existing->records;
+            struct record **re;
 
-            for (; re; re = re->next)
+            cluster = (*p)->record;
+            for (re = &cluster->records; *re; re = &(*re)->next)
             {
-                if (re->client == record->client &&
-                    record_compare(record, re, service))
+                if ((*re)->client == record->client &&
+                    record_compare(record, *re, service))
                 {
                     yaz_mutex_leave(l->mutex);
                     return 0;
                 }
             }
-            record->next = existing->records;
-            existing->records = record;
-            cluster = existing;
+            *re = record;
+            record->next = 0;
             break;
         }
     }
@@ -411,6 +421,7 @@ struct record_cluster *reclist_insert(struct reclist *l,
         /* attach to hash list */
         *p = new;
         l->num_records++;
+        l->sorted_list = l->sorted_ptr = 0;
     }
     yaz_mutex_leave(l->mutex);
     return cluster;