src/test_relevance.c

   1 /* $Id: test_relevance.c,v 1.9 2007-04-25 07:00:33 marc Exp $
   2    Copyright (c) 2006-2007, Index Data.
   3
   4 This file is part of Pazpar2.
   5
   6 Pazpar2 is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 2, or (at your option) any later
   9 version.
  10
  11 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Pazpar2; see the file LICENSE.  If not, write to the
  18 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.
  20  */
  21
  22 #if HAVE_CONFIG_H
  23 #include "cconfig.h"
  24 #endif
  25
  26 #define USE_TIMING 0
  27 #if USE_TIMING
  28 #include <yaz/timing.h>
  29 #endif
  30
  31 #include <yaz/test.h>
  32
  33
  34 #include "config.h"
  35 #include "relevance.h"
  36 #include "record.h"
  37 #include "reclists.h"
  38
  39
  40 void test_relevance(int argc, char **argv)
  41 {
  42   NMEM  nmem = nmem_create();
  43   int numrecs = 10;
  44
  45   const char * queryterms[] =
  46       {"abe", "fisk", 0};
  47   //    {"ål", "økologi", "æble", 0};
  48
  49   //struct record_cluster *cluster = 0;
  50   struct conf_service *service = 0;
  51   struct reclist *list = 0;
  52   struct record *record = 0;
  53   //const char *mergekey = "amergekey";
  54   //int total = 0;
  55
  56   struct relevance *rel = 0;
  57   //struct client *client = 0;
  58
  59
  60   rel = relevance_create(nmem, queryterms, numrecs);
  61   YAZ_CHECK(rel);
  62
  63   list = reclist_create(nmem, numrecs);
  64   YAZ_CHECK(list);
  65
  66   service =  conf_service_create(nmem, 4, 3);
  67   YAZ_CHECK(service);
  68
  69   YAZ_CHECK(conf_service_add_metadata(nmem, service, 0, "title",
  70                             Metadata_type_generic, Metadata_merge_unique,
  71                             1, 1, 1, 0));
  72
  73   YAZ_CHECK(conf_service_add_metadata(nmem, service, 1, "author",
  74                             Metadata_type_generic, Metadata_merge_longest,
  75                             1, 1, 1, 0));
  76
  77   YAZ_CHECK(conf_service_add_metadata(nmem, service, 2, "isbn",
  78                             Metadata_type_number, Metadata_merge_no,
  79                             1, 1, 1, 0));
  80
  81   YAZ_CHECK(conf_service_add_metadata(nmem, service, 3, "year",
  82                             Metadata_type_year, Metadata_merge_range,
  83                             1, 1, 1, 0));
  84
  85   YAZ_CHECK(conf_service_add_sortkey(nmem, service, 0, "relevance",
  86                                      Metadata_sortkey_relevance));
  87
  88   YAZ_CHECK(conf_service_add_sortkey(nmem, service, 1, "title",
  89                                      Metadata_sortkey_string));
  90
  91   YAZ_CHECK(conf_service_add_sortkey(nmem, service, 2, "year",
  92                                      Metadata_sortkey_numeric));
  93
  94
  95
  96
  97   // testing record things
  98   record = record_create(nmem, 4, 3);
  99   YAZ_CHECK(record);
 100
 101   // why on earth do we have a client dangeling from the record ??
 102   // record->client = client;
 103
 104   char * bla = "blabla";
 105   union data_types data_text;
 106   data_text.text = bla;
 107
 108
 109   union data_types data_num;
 110   data_num.number.min = 2;
 111   data_num.number.max = 5;
 112
 113   struct record_metadata * tmp_md = 0;
 114   tmp_md = record_metadata_insert(nmem, &(record->metadata[0]), data_text);
 115   YAZ_CHECK(tmp_md);
 116   tmp_md = record_metadata_insert(nmem, &tmp_md, data_text);
 117   YAZ_CHECK(tmp_md);
 118
 119   YAZ_CHECK(record_add_metadata_field_id(nmem, record, 3, data_num));
 120   YAZ_CHECK(record_add_metadata_field_id(nmem, record, 3, data_num));
 121
 122   YAZ_CHECK(record_add_metadata(nmem, record, service, "author", data_text));
 123   YAZ_CHECK(record_add_metadata(nmem, record, service, "author", data_text));
 124
 125
 126   YAZ_CHECK(record_assign_sortkey_field_id(nmem, record, 0, data_text));
 127   YAZ_CHECK(record_assign_sortkey_field_id(nmem, record, 1, data_text));
 128   YAZ_CHECK(record_assign_sortkey_field_id(nmem, record, 2, data_num));
 129
 130   YAZ_CHECK(record_assign_sortkey(nmem, record, service, "relevance", data_text));
 131   YAZ_CHECK(record_assign_sortkey(nmem, record, service, "title", data_text));
 132   YAZ_CHECK(record_assign_sortkey(nmem, record, service, "year", data_num));
 133
 134
 135
 136
 137
 138
 139
 140   // now we need to put some actual data into the record ... how ??
 141   // there is a hell of a lot spagetti code in logic.c ingest_record()
 142   // line 694 ff snippet from there:
 143   // this code needs to be analyzed and the fundamental stuff extracted
 144
 145 #if 0
 146   service->metadata[imeta].name;
 147   md = &service->metadata[imeta];
 148    if (md->sortkey_offset >= 0)
 149                         sk = &service->sortkeys[md->sortkey_offset];
 150
 151
 152   // Find out where we are putting it           if (md->merge == Metadata_merge_no)
 153                 wheretoput = &res->metadata[imeta];
 154             else
 155                 wheretoput = &cluster->metadata[imeta];
 156
 157
 158             // Put it there
 159             newm = nmem_malloc(se->nmem, sizeof(struct record_metadata));
 160             newm->next = 0;
 161             if (md->type == Metadata_type_generic)
 162             {
 163                 char *p, *pe;
 164                 for (p = (char *) value; *p && isspace(*p); p++)
 165                     ;
 166                 for (pe = p + strlen(p) - 1;
 167                         pe > p && strchr(" ,/.:([", *pe); pe--)
 168                     *pe = '\0';
 169                 newm->data.text = nmem_strdup(se->nmem, p);
 170
 171             }
 172             else if (md->type == Metadata_type_year)
 173             {
 174                 if (extract_years((char *) value, &first, &last) < 0)
 175                     continue;
 176             }
 177             else
 178             {
 179                 yaz_log(YLOG_WARN, "Unknown type in metadata element %s", type);
 180                 continue;
 181             }
 182             if (md->type == Metadata_type_year && md->merge != Metadata_merge_range)
 183             {
 184                 yaz_log(YLOG_WARN, "Only range merging supported for years");
 185                 continue;
 186             }
 187             if (md->merge == Metadata_merge_unique)
 188             {
 189                 struct record_metadata *mnode;
 190                 for (mnode = *wheretoput; mnode; mnode = mnode->next)
 191                     if (!strcmp((const char *) mnode->data.text, newm->data.text))
 192                         break;
 193                 if (!mnode)
 194                 {
 195                     newm->next = *wheretoput;
 196                     *wheretoput = newm;
 197                 }
 198             }
 199             else if (md->merge == Metadata_merge_longest)
 200             {
 201                 if (!*wheretoput ||
 202                         strlen(newm->data.text) > strlen((*wheretoput)->data.text))
 203                 {
 204                     *wheretoput = newm;
 205                     if (sk)
 206                     {
 207                         char *s = nmem_strdup(se->nmem, newm->data.text);
 208                         if (!cluster->sortkeys[md->sortkey_offset])
 209                             cluster->sortkeys[md->sortkey_offset] =
 210                                 nmem_malloc(se->nmem, sizeof(union data_types));
 211                         normalize_mergekey(s,
 212                                 (sk->type == Metadata_sortkey_skiparticle));
 213                         cluster->sortkeys[md->sortkey_offset]->text = s;
 214                     }
 215                 }
 216             }
 217             else if (md->merge == Metadata_merge_all || md->merge == Metadata_merge_no)
 218             {
 219                 newm->next = *wheretoput;
 220                 *wheretoput = newm;
 221             }
 222             else if (md->merge == Metadata_merge_range)
 223             {
 224                 assert(md->type == Metadata_type_year);
 225                 if (!*wheretoput)
 226                 {
 227                     *wheretoput = newm;
 228                     (*wheretoput)->data.number.min = first;
 229                     (*wheretoput)->data.number.max = last;
 230                     if (sk)
 231                         cluster->sortkeys[md->sortkey_offset] = &newm->data;
 232                 }
 233                 else
 234                 {
 235                     if (first < (*wheretoput)->data.number.min)
 236                         (*wheretoput)->data.number.min = first;
 237                     if (last > (*wheretoput)->data.number.max)
 238                         (*wheretoput)->data.number.max = last;
 239                 }
 240             if (md->rank)
 241                 relevance_countwords(se->relevance, cluster,
 242                                      (char *) value, md->rank);
 243             if (md->termlist)
 244             {
 245                 if (md->type == Metadata_type_year)
 246                 {
 247                     char year[64];
 248                     sprintf(year, "%d", last);
 249                     add_facet(se, (char *) type, year);
 250                     if (first != last)
 251                     {
 252                         sprintf(year, "%d", first);
 253                         add_facet(se, (char *) type, year);
 254                     }
 255                 }
 256                 else
 257                     add_facet(se, (char *) type, (char *) value);
 258             }
 259 #endif
 260
 261   //mergekey_norm = (xmlChar *) nmem_strdup(se->nmem, (char*) mergekey);
 262   //normalize_mergekey((char *) mergekey_norm, 0);
 263
 264
 265 #if 0
 266   // insert one record into recordlist/cluster - what's a cluster, exactly??
 267   cluster = reclist_insert(list, service, record, (char *)mergekey, &total);
 268   relevance_newrec(rel, cluster);
 269 #endif
 270
 271
 272
 273
 274
 275
 276   //relevance_prepare_read(rel, list);
 277
 278
 279   //relevance_donerecord(rel, cluster);
 280   // relevance_countwords(se->rel, cluster,
 281   //                                   (char *) value, service->metadata->rank);
 282   //
 283
 284
 285   nmem_destroy(nmem);
 286
 287   //YAZ_CHECK(0 == 0);
 288   //YAZ_CHECK_EQ(0, 1);
 289 }
 290
 291
 292 int main(int argc, char **argv)
 293 {
 294     YAZ_CHECK_INIT(argc, argv);
 295     YAZ_CHECK_LOG();
 296
 297
 298     test_relevance(argc, argv);
 299
 300
 301     YAZ_CHECK_TERM;
 302 }
 303
 304
 305
 306
 307 /*
 308  * Local variables:
 309  * c-basic-offset: 4
 310  * indent-tabs-mode: nil
 311  * End:
 312  * vim: shiftwidth=4 tabstop=8 expandtab
 313  */