X-Git-Url: http://jsfdemo.indexdata.com/?a=blobdiff_plain;f=src%2Ftest_relevance.c;h=66258b0cc20f56847b905bf97c359cc182212397;hb=f030fa5726d942a82ffebb2ee22e35338ccfed78;hp=b3b0f3e43d9340f727526efa9afefff8261481aa;hpb=5bfbd89faa07d7f0cb4db48d2970231a6ce42d47;p=pazpar2-moved-to-github.git

diff --git a/src/test_relevance.c b/src/test_relevance.c
index b3b0f3e..66258b0 100644
--- a/src/test_relevance.c
+++ b/src/test_relevance.c
@@ -1,4 +1,4 @@
-/* $Id: test_relevance.c,v 1.1 2007-04-16 13:58:20 marc Exp $
+/* $Id: test_relevance.c,v 1.5 2007-04-20 14:37:17 marc Exp $
    Copyright (c) 2006-2007, Index Data.
 
 This file is part of Pazpar2.
@@ -43,53 +43,227 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 
 //#include "pazpar2.h"
+#include "config.h"
 #include "relevance.h"
+#include "record.h"
+#include "pazpar2.h"
 
 
+void test_relevance(int argc, char **argv)
+{
+  NMEM 	nmem = nmem_create();
+  int numrecs = 10;
 
+  const char * queryterms[] = 
+      {"abe", "fisk", 0};
+  //    {"ål", "økologi", "æble", 0};
 
+  //struct record_cluster *cluster = 0;
+  struct conf_service *service = 0; 
+  struct reclist *list = 0;
+  struct record *record = 0;
+  //const char *mergekey = "amergekey";
+  //int total = 0;
 
+  struct relevance *rel = 0;
+  struct client *client = 0;
+  
 
+  rel = relevance_create(nmem, queryterms, numrecs);
+  list = reclist_create(nmem, numrecs);
 
+  service =  conf_service_create(nmem, 4, 1);
+  conf_service_add_metadata(nmem, service, 0, "title",
+                            Metadata_type_generic, Metadata_merge_unique,
+                            1, 1, 1, 0);
+
+  conf_service_add_metadata(nmem, service, 1, "author",
+                            Metadata_type_generic, Metadata_merge_longest,
+                            1, 1, 1, 0);
+
+  conf_service_add_metadata(nmem, service, 2, "isbn",
+                            Metadata_type_number, Metadata_merge_no,
+                            1, 1, 1, 0);
+
+  conf_service_add_metadata(nmem, service, 3, "year",
+                            Metadata_type_year, Metadata_merge_range,
+                            1, 1, 1, 0);
+
+
+  // testing record things
+  record = record_create(nmem, 4, 1);
+  YAZ_CHECK(record);
+
+  // why on earth do we have a client dangeling from the record ??
+  record->client = client;
+
+  //union data_types data;
+  //data.text = "sometext";
+
+  char * bla = "blabla";
+  union data_types data;
+  data.text = bla;
 
-void test_relevance(int argc, char **argv)
-{
-  NMEM 	nmem = nmem_create();
-  struct conf_service service; 
-  struct record record;
-  struct reclist list;
-  struct record_cluster *cluster = 0;
-  struct relevance *rel = 0;
-  int numrecs = 10;
-  char mergekey[128];
-  //const char * terms[] = 
-  //    {"ål",  "abe", "økologi", "fisk", "æble", "yoghurt"};
-  const char * terms[] = 
-      {"abe", "fisk"};
-  int total = 0;
-  struct record_metadata *metadata = 0;
   
+  union data_types data2;
+  data.number.min = 2;
+  data.number.max = 5;
+
+  record_add_metadata_fieldno(nmem, record, 0, data);
+  record_add_metadata_fieldno(nmem, record, 0, data2);
+
+  //record_add_metadata_text(nmem, record, 0, bla);
+
+
+  // now we need to put some actual data into the record ... how ??
+  // there is a hell of a lot spagetti code in logic.c ingest_record()
+  // line 694 ff snippet from there:
+  // this code needs to be analyzed and the fundamental stuff extracted
+
+#if 0 
+  service->metadata[imeta].name;
+  md = &service->metadata[imeta];
+   if (md->sortkey_offset >= 0)
+                        sk = &service->sortkeys[md->sortkey_offset];
+
+ 
+  // Find out where we are putting it           if (md->merge == Metadata_merge_no)
+                wheretoput = &res->metadata[imeta];
+            else
+                wheretoput = &cluster->metadata[imeta];
+            
+            
+            // Put it there
+            newm = nmem_malloc(se->nmem, sizeof(struct record_metadata));
+            newm->next = 0;
+            if (md->type == Metadata_type_generic)
+            {
+                char *p, *pe;
+                for (p = (char *) value; *p && isspace(*p); p++)
+                    ;
+                for (pe = p + strlen(p) - 1;
+                        pe > p && strchr(" ,/.:([", *pe); pe--)
+                    *pe = '\0';
+                newm->data.text = nmem_strdup(se->nmem, p);
+
+            }
+            else if (md->type == Metadata_type_year)
+            {
+                if (extract_years((char *) value, &first, &last) < 0)
+                    continue;
+            }
+            else
+            {
+                yaz_log(YLOG_WARN, "Unknown type in metadata element %s", type);
+                continue;
+            }
+            if (md->type == Metadata_type_year && md->merge != Metadata_merge_range)
+            {
+                yaz_log(YLOG_WARN, "Only range merging supported for years");
+                continue;
+            }
+            if (md->merge == Metadata_merge_unique)
+            {
+                struct record_metadata *mnode;
+                for (mnode = *wheretoput; mnode; mnode = mnode->next)
+                    if (!strcmp((const char *) mnode->data.text, newm->data.text))
+                        break;
+                if (!mnode)
+                {
+                    newm->next = *wheretoput;
+                    *wheretoput = newm;
+                }
+            }
+            else if (md->merge == Metadata_merge_longest)
+            {
+                if (!*wheretoput ||
+                        strlen(newm->data.text) > strlen((*wheretoput)->data.text))
+                {
+                    *wheretoput = newm;
+                    if (sk)
+                    {
+                        char *s = nmem_strdup(se->nmem, newm->data.text);
+                        if (!cluster->sortkeys[md->sortkey_offset])
+                            cluster->sortkeys[md->sortkey_offset] = 
+                                nmem_malloc(se->nmem, sizeof(union data_types));
+                        normalize_mergekey(s,
+                                (sk->type == Metadata_sortkey_skiparticle));
+                        cluster->sortkeys[md->sortkey_offset]->text = s;
+                    }
+                }
+            }
+            else if (md->merge == Metadata_merge_all || md->merge == Metadata_merge_no)
+            {
+                newm->next = *wheretoput;
+                *wheretoput = newm;
+            }
+            else if (md->merge == Metadata_merge_range)
+            {
+                assert(md->type == Metadata_type_year);
+                if (!*wheretoput)
+                {
+                    *wheretoput = newm;
+                    (*wheretoput)->data.number.min = first;
+                    (*wheretoput)->data.number.max = last;
+                    if (sk)
+                        cluster->sortkeys[md->sortkey_offset] = &newm->data;
+                }
+                else
+                {
+                    if (first < (*wheretoput)->data.number.min)
+                        (*wheretoput)->data.number.min = first;
+                    if (last > (*wheretoput)->data.number.max)
+                        (*wheretoput)->data.number.max = last;
+                }
+            if (md->rank)
+                relevance_countwords(se->relevance, cluster, 
+                                     (char *) value, md->rank);
+            if (md->termlist)
+            {
+                if (md->type == Metadata_type_year)
+                {
+                    char year[64];
+                    sprintf(year, "%d", last);
+                    add_facet(se, (char *) type, year);
+                    if (first != last)
+                    {
+                        sprintf(year, "%d", first);
+                        add_facet(se, (char *) type, year);
+                    }
+                }
+                else
+                    add_facet(se, (char *) type, (char *) value);
+            }
+#endif
+
+  //mergekey_norm = (xmlChar *) nmem_strdup(se->nmem, (char*) mergekey);
+  //normalize_mergekey((char *) mergekey_norm, 0);
+
+
+#if 0
+  // insert one record into recordlist/cluster - what's a cluster, exactly??
+  cluster = reclist_insert(list, service, record, (char *)mergekey, &total);
+  relevance_newrec(rel, cluster);
+#endif
 
-  relevance_create(nmem, terms, numrecs);
 
-  relevance_prepare_read(rel, &list); 
 
-  cluster = reclist_insert(&service, &list, &record, mergekey, &total);
 
-  //relevance_newrec(rel, cluster);
 
-  //relevance_donerecord(se->relevance, cluster);
-  //          relevance_countwords(se->relevance, cluster, 
-  //                                   (char *) value, md->rank);
+
+  //relevance_prepare_read(rel, list);
+
+
+  //relevance_donerecord(rel, cluster);
+  // relevance_countwords(se->rel, cluster, 
+  //                                   (char *) value, service->metadata->rank);
   //      
 
+
   nmem_destroy(nmem);
 
-  YAZ_CHECK(0 == 0);
+  //YAZ_CHECK(0 == 0);
   //YAZ_CHECK_EQ(0, 1);
-
-  
-
 }