+struct record *ingest_record(struct client *cl, Z_External *rec,
+ int record_no)
+{
+ xmlDoc *xdoc = normalize_record(client_get_database(cl), rec);
+ xmlNode *root, *n;
+ struct record *record;
+ struct record_cluster *cluster;
+ struct session *se = client_get_session(cl);
+ xmlChar *mergekey, *mergekey_norm;
+ xmlChar *type = 0;
+ xmlChar *value = 0;
+ struct conf_service *service = global_parameters.server->service;
+
+ if (!xdoc)
+ return 0;
+
+ root = xmlDocGetRootElement(xdoc);
+ if (!(mergekey = xmlGetProp(root, (xmlChar *) "mergekey")))
+ {
+ yaz_log(YLOG_WARN, "No mergekey found in record");
+ xmlFreeDoc(xdoc);
+ return 0;
+ }
+
+#if 0
+ record = nmem_malloc(se->nmem, sizeof(struct record));
+ record->next = 0;
+ record->client = cl;
+ record->metadata = nmem_malloc(se->nmem,
+ sizeof(struct record_metadata*) * service->num_metadata);
+ memset(record->metadata, 0,
+ sizeof(struct record_metadata*) * service->num_metadata);
+
+#else
+ record = record_create(se->nmem,
+ service->num_metadata, service->num_sortkeys);
+ record_assign_client(record, cl);
+#endif
+
+ mergekey_norm = (xmlChar *) nmem_strdup(se->nmem, (char*) mergekey);
+ xmlFree(mergekey);
+ normalize7bit_mergekey((char *) mergekey_norm, 0);
+
+ cluster = reclist_insert(se->reclist,
+ global_parameters.server->service,
+ record, (char *) mergekey_norm,
+ &se->total_merged);
+ if (global_parameters.dump_records)
+ yaz_log(YLOG_LOG, "Cluster id %d from %s (#%d)", cluster->recid,
+ client_get_database(cl)->database->url, record_no);
+ if (!cluster)
+ {
+ /* no room for record */
+ xmlFreeDoc(xdoc);
+ return 0;
+ }
+ relevance_newrec(se->relevance, cluster);
+
+
+ // now parsing XML record and adding data to cluster or record metadata
+ for (n = root->children; n; n = n->next)
+ {
+ if (type)
+ xmlFree(type);
+ if (value)
+ xmlFree(value);
+ type = value = 0;
+
+ if (n->type != XML_ELEMENT_NODE)
+ continue;
+ if (!strcmp((const char *) n->name, "metadata"))
+ {
+ struct conf_metadata *ser_md = 0;
+ struct conf_sortkey *ser_sk = 0;
+ struct record_metadata **wheretoput = 0;
+ struct record_metadata *rec_md = 0;
+ int md_field_id = -1;
+ int sk_field_id = -1;
+ int first, last;
+
+ type = xmlGetProp(n, (xmlChar *) "type");
+ value = xmlNodeListGetString(xdoc, n->children, 0);
+
+ if (!type || !value)
+ continue;
+
+#if 0
+ // First, find out what field we're looking at
+ for (md_field_id = 0; md_field_id < service->num_metadata;
+ md_field_id++)
+ if (!strcmp((const char *) type,
+ service->metadata[md_field_id].name))
+ {
+ ser_md = &service->metadata[md_field_id];
+ if (ser_md->sortkey_offset >= 0){
+ sk_field_id = ser_md->sortkey_offset;
+ ser_sk = &service->sortkeys[sk_field_id];
+ }
+ break;
+ }
+
+ if (!ser_md)
+ {
+ yaz_log(YLOG_WARN,
+ "Ignoring unknown metadata element: %s", type);
+ continue;
+ }
+
+#else
+ md_field_id
+ = conf_service_metadata_field_id(service, (const char *) type);
+ if (md_field_id < 0)
+ {
+ yaz_log(YLOG_WARN,
+ "Ignoring unknown metadata element: %s", type);
+ continue;
+ }
+
+ ser_md = &service->metadata[md_field_id];
+
+ if (ser_md->sortkey_offset >= 0){
+ sk_field_id = ser_md->sortkey_offset;
+ ser_sk = &service->sortkeys[sk_field_id];
+ }
+#endif
+
+ // Find out where we are putting it - based on merge or not
+ if (ser_md->merge == Metadata_merge_no)
+ wheretoput = &record->metadata[md_field_id];
+ else
+ wheretoput = &cluster->metadata[md_field_id];
+
+ // create new record_metadata
+#if 0
+ rec_md = nmem_malloc(se->nmem, sizeof(struct record_metadata));
+ rec_md->next = 0;
+#else
+ rec_md = record_metadata_create(se->nmem);
+#endif
+
+ // and polulate with data:
+ // type based charmapping decisions follow here
+ if (ser_md->type == Metadata_type_generic)
+ {
+
+#if 0
+ char *p, *pe;
+ for (p = (char *) value; *p && isspace(*p); p++)
+ ;
+ for (pe = p + strlen(p) - 1;
+ pe > p && strchr(" ,/.:([", *pe); pe--)
+ *pe = '\0';
+#else
+ char * p = (char *) value;
+ p = normalize7bit_generic(p, " ,/.:([");
+#endif
+
+ rec_md->data.text = nmem_strdup(se->nmem, p);
+
+ }
+ else if (ser_md->type == Metadata_type_year)
+ {
+ if (extract7bit_years((char *) value, &first, &last) < 0)
+ continue;
+ }
+ else
+ {
+ yaz_log(YLOG_WARN,
+ "Unknown type in metadata element %s", type);
+ continue;
+ }
+
+#if 0 // this test does not belong here.
+ // the condition is enforced in the constructor
+ // inside conf_metadata_assign()
+ // and will _never_ occur
+ if (ser_md->type == Metadata_type_year
+ && ser_md->merge != Metadata_merge_range)
+ {
+ yaz_log(YLOG_WARN, "Only range merging supported for years");
+ continue;
+ }
+# endif
+
+
+ // and polulate with data:
+ // assign cluster or record based on merge action
+ if (ser_md->merge == Metadata_merge_unique)
+ {
+ struct record_metadata *mnode;
+ for (mnode = *wheretoput; mnode; mnode = mnode->next)
+ if (!strcmp((const char *) mnode->data.text,
+ rec_md->data.text))
+ break;
+ if (!mnode)
+ {
+ rec_md->next = *wheretoput;
+ *wheretoput = rec_md;
+ }
+ }
+ else if (ser_md->merge == Metadata_merge_longest)
+ {
+ if (!*wheretoput
+ || strlen(rec_md->data.text)
+ > strlen((*wheretoput)->data.text))
+ {
+ *wheretoput = rec_md;
+ if (ser_sk)
+ {
+ char *s = nmem_strdup(se->nmem, rec_md->data.text);
+ if (!cluster->sortkeys[sk_field_id])
+ cluster->sortkeys[sk_field_id] =
+ nmem_malloc(se->nmem,
+ sizeof(union data_types));
+ normalize7bit_mergekey(s,
+ (ser_sk->type == Metadata_sortkey_skiparticle));
+ cluster->sortkeys[sk_field_id]->text = s;
+ }
+ }
+ }
+ else if (ser_md->merge == Metadata_merge_all
+ || ser_md->merge == Metadata_merge_no)
+ {
+ rec_md->next = *wheretoput;
+ *wheretoput = rec_md;
+ }
+ else if (ser_md->merge == Metadata_merge_range)
+ {
+
+#if 0 // this assert does not belong here.
+ // the condition is enforced in the constructor
+ // inside conf_metadata_assign()
+ // and will _never_ occur
+ assert(ser_md->type == Metadata_type_year);
+#endif
+
+ if (!*wheretoput)
+ {
+ *wheretoput = rec_md;
+ (*wheretoput)->data.number.min = first;
+ (*wheretoput)->data.number.max = last;
+ if (ser_sk)
+ cluster->sortkeys[sk_field_id]
+ = &rec_md->data;
+ }
+ else
+ {
+ if (first < (*wheretoput)->data.number.min)
+ (*wheretoput)->data.number.min = first;
+ if (last > (*wheretoput)->data.number.max)
+ (*wheretoput)->data.number.max = last;
+ }
+#ifdef GAGA
+ if (ser_sk)
+ {
+ union data_types *sdata
+ = cluster->sortkeys[sk_field_id];
+ yaz_log(YLOG_LOG, "SK range: %d-%d",
+ sdata->number.min, sdata->number.max);
+ }
+#endif
+ }
+
+#if 0 // this else is only entered when Metadata_merge_no
+ // but I believe then we should _not_ pollute with log messages
+ else
+
+ yaz_log(YLOG_WARN,
+ "Don't know how to merge on element name %s",
+ ser_md->name);
+#endif
+
+
+ // ranking of _all_ fields enabled ...
+ if (ser_md->rank)
+ relevance_countwords(se->relevance, cluster,
+ (char *) value, ser_md->rank);
+
+ // construct facets ...
+ if (ser_md->termlist)
+ {
+ if (ser_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);
+ }
+
+ // cleaning up
+ xmlFree(type);
+ xmlFree(value);
+ type = value = 0;
+ }
+ else
+ yaz_log(YLOG_WARN,
+ "Unexpected element %s in internal record", n->name);
+ }
+ if (type)
+ xmlFree(type);
+ if (value)
+ xmlFree(value);
+
+ xmlFreeDoc(xdoc);
+
+ relevance_donerecord(se->relevance, cluster);
+ se->total_records++;
+
+ return record;
+}
+
+
+