run_icu(s, icu_chain_id, value, facet_wrbuf, display_wrbuf);
}
-void add_facet(struct session *s, const char *type, const char *value, int count)
+struct facet_id {
+ char *client_id;
+ char *type;
+ char *id;
+ char *term;
+ struct facet_id *next;
+};
+
+static void session_add_id_facet(struct session *s, struct client *cl,
+ const char *type,
+ const char *id,
+ size_t id_len,
+ const char *term)
+{
+ struct facet_id *t = nmem_malloc(s->session_nmem, sizeof(*t));
+
+ t->client_id = nmem_strdup(s->session_nmem, client_get_id(cl));
+ t->type = nmem_strdup(s->session_nmem, type);
+ t->id = nmem_strdupn(s->session_nmem, id, id_len);
+ t->term = nmem_strdup(s->session_nmem, term);
+ t->next = s->facet_id_list;
+ s->facet_id_list = t;
+}
+
+
+// Look up a facet term, and return matching id
+// If facet type not found, returns 0
+// If facet type found, but no matching term, returns ""
+const char *session_lookup_id_facet(struct session *s, struct client *cl,
+ const char *type,
+ const char *term)
+{
+ char *retval = 0;
+ struct facet_id *t = s->facet_id_list;
+ for (; t; t = t->next)
+ {
+ if (!strcmp(client_get_id(cl), t->client_id) && !strcmp(t->type, type) )
+ {
+ retval = "";
+ if ( !strcmp(t->term, term))
+ {
+ return t->id;
+ }
+ }
+ }
+ return retval;
+}
+
+void add_facet(struct session *s, const char *type, const char *value, int count, struct client *cl)
{
WRBUF facet_wrbuf = wrbuf_alloc();
WRBUF display_wrbuf = wrbuf_alloc();
+ const char *id = 0;
+ size_t id_len = 0;
- session_normalize_facet(s, type, value, display_wrbuf, facet_wrbuf);
+ /* inspect pz:facetmap:split:name ?? */
+ if (!strncmp(type, "split:", 6))
+ {
+ const char *cp = strchr(value, ':');
+ if (cp)
+ {
+ id = value;
+ id_len = cp - value;
+ value = cp + 1;
+ }
+ type += 6;
+ }
+ session_normalize_facet(s, type, value, display_wrbuf, facet_wrbuf);
if (wrbuf_len(facet_wrbuf))
{
struct named_termlist **tp = &s->termlists;
(*tp)->next = 0;
}
termlist_insert((*tp)->termlist, wrbuf_cstr(display_wrbuf),
- wrbuf_cstr(facet_wrbuf), count);
+ wrbuf_cstr(facet_wrbuf), id, id_len, count);
+ if (id)
+ session_add_id_facet(s, cl, type, id, id_len,
+ wrbuf_cstr(display_wrbuf));
}
wrbuf_destroy(facet_wrbuf);
wrbuf_destroy(display_wrbuf);
l->next = se->clients_cached;
se->clients_cached = l;
}
- /* set session always. If may be 0 if client is not active */
client_set_session(cl, se);
l = xmalloc(sizeof(*l));
client_lock(l->client);
client_set_session(l->client, 0);
client_set_database(l->client, 0);
+ client_mark_dead(l->client);
client_unlock(l->client);
client_destroy(l->client);
xfree(l);
break;
if (sr)
{
- session_log(se, YLOG_DEBUG, "session_sort: field=%s increasing=%d type=%d already fetched",
+ session_log(se, YLOG_LOG, "session_sort: field=%s increasing=%d type=%d already fetched",
field, increasing, type);
session_leave(se, "session_sort");
return;
struct client *cl = l->client;
// Assume no re-search is required.
client_parse_init(cl, 1);
- clients_research += client_parse_sort(cl, sp);
+ clients_research += client_parse_sort(cl, sp, 0);
}
if (!clients_research || se->clients_starting)
{
}
session_enter(se, "session_sort");
se->clients_starting = 0;
+ se->force_position = 0;
session_leave(se, "session_sort");
}
}
int no_working = 0;
int no_failed_query = 0;
int no_failed_limit = 0;
+ int no_sortmap = 0;
struct client_list *l;
session_log(se, YLOG_DEBUG, "Search");
return PAZPAR2_NO_ERROR;
}
se->clients_starting = 1;
+ se->force_position = 0;
session_leave(se, "session_search0");
if (se->settings_modified) {
*addinfo = "limit";
session_leave(se, "session_search");
se->clients_starting = 0;
+ session_reset_active_clients(se, 0);
return PAZPAR2_MALFORMED_PARAMETER_VALUE;
}
else
{
client_parse_range(cl, startrecs, maxrecs);
- client_parse_sort(cl, sp);
+ client_parse_sort(cl, sp, &no_sortmap);
client_start_search(cl);
no_working++;
}
}
+ yaz_log(YLOG_LOG, "session_search: no_working=%d no_sortmap=%d",
+ no_working, no_sortmap);
session_enter(se, "session_search2");
+ if (no_working == 1 && no_sortmap == 1)
+ {
+ se->force_position = 1;
+ yaz_log(YLOG_LOG, "force_position=1");
+ }
se->clients_starting = 0;
session_leave(se, "session_search2");
if (no_working == 0)
void session_destroy(struct session *se)
{
struct session_database *sdb;
- session_log(se, YLOG_LOG, "destroy");
- session_use(-1);
+ int i = session_use(-1);
+
+ session_log(se, YLOG_LOG, "destroy %d", i);
session_remove_cached_clients(se);
for (sdb = se->databases; sdb; sdb = sdb->next)
session->clients_cached = 0;
session->settings_modified = 0;
session->session_nmem = nmem;
+ session->facet_id_list = 0;
session->nmem = nmem_create();
session->databases = 0;
session->sorted_results = 0;
session->mergekey = 0;
session->rank = 0;
session->clients_starting = 0;
+ session->force_position = 0;
for (i = 0; i <= SESSION_WATCH_MAX; i++)
{
session->normalize_cache = normalize_cache_create();
session->session_mutex = 0;
pazpar2_mutex_create(&session->session_mutex, tmp_str);
- session_log(session, YLOG_LOG, "create");
- session_use(1);
+ i = session_use(1);
+ session_log(session, YLOG_LOG, "create %d", i);
return session;
}
-const char * client_get_suggestions_xml(struct client *cl, WRBUF wrbuf);
-
static struct hitsbytarget *hitsbytarget_nb(struct session *se,
int *count, NMEM nmem)
{
session_settings_dump(se, client_get_database(cl), w);
res[*count].settings_xml = nmem_strdup(nmem, wrbuf_cstr(w));
wrbuf_rewind(w);
- wrbuf_puts(w, "");
- res[*count].suggestions_xml = nmem_strdup(nmem, client_get_suggestions_xml(cl, w));
+ res[*count].suggestions_xml =
+ nmem_strdup(nmem, client_get_suggestions_xml(cl, w));
+
+ res[*count].query_data =
+ client_get_query(cl, &res[*count].query_type, nmem);
wrbuf_destroy(w);
(*count)++;
}
wrbuf_puts(c->wrbuf, "<name>");
wrbuf_xmlputs(c->wrbuf, p[i]->display_term);
wrbuf_puts(c->wrbuf, "</name>");
-
wrbuf_printf(c->wrbuf,
"<frequency>%d</frequency>",
p[i]->frequency);
struct reclist_sortparms *spp;
struct client_list *l;
int i;
+ NMEM nmem_tmp = 0;
#if USE_TIMING
yaz_timing_t t = yaz_timing_create();
#endif
*approx_hits += client_get_approximation(l->client);
}
}
+ if (se->force_position)
+ {
+ nmem_tmp = nmem_create();
+ sp = reclist_parse_sortparms(nmem_tmp, "position:1", 0);
+ assert(sp);
+ }
reclist_sort(se->reclist, sp);
+ if (nmem_tmp)
+ nmem_destroy(nmem_tmp);
reclist_enter(se->reclist);
*total = reclist_get_num_records(se->reclist);
}
static struct record_metadata *record_metadata_init(
- NMEM nmem, const char *value, enum conf_metadata_type type,
+ NMEM nmem, const char *value, const char *norm,
+ enum conf_metadata_type type,
struct _xmlAttr *attr)
{
struct record_metadata *rec_md = record_metadata_create(nmem);
{
case Metadata_type_generic:
case Metadata_type_skiparticle:
- if (strstr(value, "://")) /* looks like a URL */
+ if (norm)
+ {
rec_md->data.text.disp = nmem_strdup(nmem, value);
+ rec_md->data.text.norm = nmem_strdup(nmem, norm);
+ }
else
- rec_md->data.text.disp =
- normalize7bit_generic(nmem_strdup(nmem, value), " ,/.:([");
+ {
+ if (strstr(value, "://")) /* looks like a URL */
+ rec_md->data.text.disp = nmem_strdup(nmem, value);
+ else
+ rec_md->data.text.disp =
+ normalize7bit_generic(nmem_strdup(nmem, value), " ,/.:([");
+ rec_md->data.text.norm = rec_md->data.text.disp;
+ }
rec_md->data.text.sort = 0;
rec_md->data.text.snippet = 0;
break;
break;
case Metadata_type_relevance:
case Metadata_type_position:
+ case Metadata_type_retrieval:
return 0;
}
return rec_md;
/* generate unique key if none is not generated already or is empty */
if (wrbuf_len(norm_wr) == 0)
{
- wrbuf_printf(norm_wr, "position: %s-%d",
+ wrbuf_printf(norm_wr, "position: %s-%06d",
client_get_id(cl), record_no);
}
else
if (!type)
continue;
+
+ md_field_id
+ = conf_service_metadata_field_id(service, (const char *) type);
+ if (md_field_id < 0)
+ {
+ if (se->number_of_warnings_unknown_metadata == 0)
+ {
+ session_log(se, YLOG_WARN,
+ "Ignoring unknown metadata element: %s", type);
+ }
+ se->number_of_warnings_unknown_metadata++;
+ continue;
+ }
+
wrbuf_rewind(wrbuf_disp);
value0 = xmlNodeListGetString(xdoc, n->children, 1);
if (!value0 || !*value0)
}
if (value0)
xmlFree(value0);
- md_field_id
- = conf_service_metadata_field_id(service, (const char *) type);
- if (md_field_id < 0)
- {
- if (se->number_of_warnings_unknown_metadata == 0)
- {
- session_log(se, YLOG_WARN,
- "Ignoring unknown metadata element: %s", type);
- }
- se->number_of_warnings_unknown_metadata++;
- continue;
- }
-
ser_md = &service->metadata[md_field_id];
// non-merged metadata
- rec_md = record_metadata_init(se->nmem, wrbuf_cstr(wrbuf_disp),
+ rec_md = record_metadata_init(se->nmem, wrbuf_cstr(wrbuf_disp), 0,
ser_md->type, n->properties);
if (!rec_md)
{
const char *type = 0;
xmlChar *value0;
- wrbuf_rewind(wrbuf_disp);
type = yaz_xml_get_prop(n, "type");
if (!type)
continue;
ser_sk = &service->sortkeys[sk_field_id];
}
+ wrbuf_rewind(wrbuf_disp);
+ wrbuf_rewind(wrbuf_norm);
+
value0 = xmlNodeListGetString(xdoc, n->children, 1);
if (!value0 || !*value0)
{
xmlFree(value0);
continue;
}
- wrbuf_puts(wrbuf_disp, (const char *) value0);
- xmlFree(value0);
+ if (ser_md->icurule)
+ {
+ run_icu(se, ser_md->icurule, (const char *) value0,
+ wrbuf_norm, wrbuf_disp);
+ yaz_log(YLOG_LOG, "run_icu input=%s norm=%s disp=%s",
+ (const char *) value0,
+ wrbuf_cstr(wrbuf_norm), wrbuf_cstr(wrbuf_disp));
+ rec_md = record_metadata_init(se->nmem, wrbuf_cstr(wrbuf_disp),
+ wrbuf_cstr(wrbuf_norm),
+ ser_md->type, 0);
+ }
+ else
+ {
+ wrbuf_puts(wrbuf_disp, (const char *) value0);
+ rec_md = record_metadata_init(se->nmem, wrbuf_cstr(wrbuf_disp),
+ 0,
+ ser_md->type, 0);
+ }
- // merged metadata
- rec_md = record_metadata_init(se->nmem, wrbuf_cstr(wrbuf_disp),
- ser_md->type, 0);
+ xmlFree(value0);
// see if the field was not in cluster already (from beginning)
-
if (!rec_md)
continue;
{
while (*wheretoput)
{
- if (!strcmp((const char *) (*wheretoput)->data.text.disp,
- rec_md->data.text.disp))
+ if (!strcmp((const char *) (*wheretoput)->data.text.norm,
+ rec_md->data.text.norm))
break;
wheretoput = &(*wheretoput)->next;
}
else if (ser_md->merge == Metadata_merge_longest)
{
if (!*wheretoput
- || strlen(rec_md->data.text.disp)
- > strlen((*wheretoput)->data.text.disp))
+ || strlen(rec_md->data.text.norm)
+ > strlen((*wheretoput)->data.text.norm))
{
*wheretoput = rec_md;
if (ser_sk)
char year[64];
sprintf(year, "%d", rec_md->data.number.max);
- add_facet(se, (char *) type, year, term_factor);
+ add_facet(se, (char *) type, year, term_factor, cl);
if (rec_md->data.number.max != rec_md->data.number.min)
{
sprintf(year, "%d", rec_md->data.number.min);
- add_facet(se, (char *) type, year, term_factor);
+ add_facet(se, (char *) type, year, term_factor, cl);
}
}
else
- add_facet(se, type, wrbuf_cstr(wrbuf_disp), term_factor);
+ add_facet(se, type, wrbuf_cstr(wrbuf_disp), term_factor, cl);
}
}
else