/* This file is part of Pazpar2.
- Copyright (C) 2006-2013 Index Data
+ Copyright (C) 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
#include <yaz/oid_db.h>
#include <yaz/snprintf.h>
-#define USE_TIMING 1
+#define USE_TIMING 0
#if USE_TIMING
#include <yaz/timing.h>
#endif
if (wrbuf_len(facet_wrbuf))
{
- int i;
- for (i = 0; i < s->num_termlists; i++)
- if (!strcmp(s->termlists[i].name, type))
+ struct named_termlist **tp = &s->termlists;
+ for (; (*tp); tp = &(*tp)->next)
+ if (!strcmp((*tp)->name, type))
break;
- if (i == s->num_termlists)
+ if (!*tp)
{
- if (i == SESSION_MAX_TERMLISTS)
- {
- session_log(s, YLOG_FATAL, "Too many termlists");
- wrbuf_destroy(facet_wrbuf);
- wrbuf_destroy(display_wrbuf);
- return;
- }
-
- s->termlists[i].name = nmem_strdup(s->nmem, type);
- s->termlists[i].termlist = termlist_create(s->nmem);
- s->num_termlists = i + 1;
+ *tp = nmem_malloc(s->nmem, sizeof(**tp));
+ (*tp)->name = nmem_strdup(s->nmem, type);
+ (*tp)->termlist = termlist_create(s->nmem);
+ (*tp)->next = 0;
}
-
-#if 0
- session_log(s, YLOG_LOG, "Facets for %s: %s norm:%s (%d)", type, value, wrbuf_cstr(facet_wrbuf), count);
-#endif
- termlist_insert(s->termlists[i].termlist, wrbuf_cstr(display_wrbuf),
+ termlist_insert((*tp)->termlist, wrbuf_cstr(display_wrbuf),
wrbuf_cstr(facet_wrbuf), count);
}
wrbuf_destroy(facet_wrbuf);
nmem_total(se->nmem));
nmem_reset(se->nmem);
se->total_records = se->total_merged = 0;
- se->num_termlists = 0;
-
+ se->termlists = 0;
relevance_clear(se->relevance);
/* reset list of sorted results and clear to relevance search */
se->reclist = reclist_create(se->nmem);
}
-static void session_sort_unlocked(struct session *se,
- struct reclist_sortparms *sp,
- const char *mergekey,
- const char *rank)
+void session_sort(struct session *se, struct reclist_sortparms *sp,
+ const char *mergekey, const char *rank)
{
struct client_list *l;
const char *field = sp->name;
int type = sp->type;
int clients_research = 0;
+ session_enter(se, "session_sort");
session_log(se, YLOG_DEBUG, "session_sort field=%s increasing=%d type=%d",
field, increasing, type);
{
session_log(se, YLOG_DEBUG, "session_sort: field=%s increasing=%d type=%d already fetched",
field, increasing, type);
+ session_leave(se, "session_sort");
return;
}
}
client_parse_init(cl, 1);
clients_research += client_parse_sort(cl, sp);
}
- if (clients_research)
- {
- session_log(se, YLOG_DEBUG,
- "session_sort: reset results due to %d clients researching",
- clients_research);
- session_clear_set(se, sp);
- }
- else
+ if (!clients_research || se->clients_starting)
{
// A new sorting based on same record set
struct reclist_sortparms *sr = nmem_malloc(se->nmem, sizeof(*sr));
sr->next = se->sorted_results;
se->sorted_results = sr;
session_log(se, YLOG_DEBUG, "session_sort: no research/ingesting done");
- return ;
+ session_leave(se, "session_sort");
}
- session_log(se, YLOG_DEBUG, "Re- search/ingesting for clients due to change in sort order");
-
- for (l = se->clients_active; l; l = l->next)
+ else
{
- struct client *cl = l->client;
- if (client_get_state(cl) == Client_Connecting ||
- client_get_state(cl) == Client_Idle ||
- client_get_state(cl) == Client_Working) {
- client_start_search(cl);
- }
- else
+ se->clients_starting = 1;
+ session_log(se, YLOG_DEBUG,
+ "session_sort: reset results due to %d clients researching",
+ clients_research);
+ session_clear_set(se, sp);
+ session_log(se, YLOG_DEBUG, "Re- search/ingesting for clients due to change in sort order");
+
+ session_leave(se, "session_sort");
+ for (l = se->clients_active; l; l = l->next)
{
- session_log(se, YLOG_DEBUG,
- "session_sort: %s: No re-start/ingest in show. "
- "Wrong client state: %d",
- client_get_id(cl), client_get_state(cl));
+ struct client *cl = l->client;
+ if (client_get_state(cl) == Client_Connecting ||
+ client_get_state(cl) == Client_Idle ||
+ client_get_state(cl) == Client_Working) {
+ client_start_search(cl);
+ }
+ else
+ {
+ session_log(se, YLOG_DEBUG,
+ "session_sort: %s: No re-start/ingest in show. "
+ "Wrong client state: %d",
+ client_get_id(cl), client_get_state(cl));
+ }
}
+ session_enter(se, "session_sort");
+ se->clients_starting = 0;
+ session_leave(se, "session_sort");
}
}
-void session_sort(struct session *se, struct reclist_sortparms *sp,
- const char *mergekey, const char *rank)
+void session_stop(struct session *se)
{
- //session_enter(se, "session_sort");
- session_sort_unlocked(se, sp, mergekey, rank);
- //session_leave(se, "session_sort");
-}
+ struct client_list *l;
+ session_enter(se, "session_stop1");
+ if (se->clients_starting)
+ {
+ session_leave(se, "session_stop1");
+ return;
+ }
+ se->clients_starting = 1;
+ session_leave(se, "session_stop1");
+ session_alert_watch(se, SESSION_WATCH_SHOW);
+ session_alert_watch(se, SESSION_WATCH_BYTARGET);
+ session_alert_watch(se, SESSION_WATCH_TERMLIST);
+ session_alert_watch(se, SESSION_WATCH_SHOW_PREF);
+
+ for (l = se->clients_active; l; l = l->next)
+ {
+ struct client *cl = l->client;
+ client_stop(cl);
+ }
+ session_enter(se, "session_stop2");
+ se->clients_starting = 0;
+ session_leave(se, "session_stop2");
+}
enum pazpar2_error_code session_search(struct session *se,
const char *query,
int no_working = 0;
int no_failed_query = 0;
int no_failed_limit = 0;
- struct client_list *l, *l0;
-
- session_alert_watch(se, SESSION_WATCH_SHOW);
- session_alert_watch(se, SESSION_WATCH_BYTARGET);
- session_alert_watch(se, SESSION_WATCH_TERMLIST);
- session_alert_watch(se, SESSION_WATCH_SHOW_PREF);
+ struct client_list *l;
session_log(se, YLOG_DEBUG, "Search");
*addinfo = 0;
+ session_enter(se, "session_search0");
+ if (se->clients_starting)
+ {
+ session_leave(se, "session_search0");
+ return PAZPAR2_NO_ERROR;
+ }
+ se->clients_starting = 1;
+ session_leave(se, "session_search0");
+
if (se->settings_modified) {
session_remove_cached_clients(se);
}
if (!live_channels)
{
session_leave(se, "session_search");
+ se->clients_starting = 0;
return PAZPAR2_NO_TARGETS;
}
{
*addinfo = "limit";
session_leave(se, "session_search");
+ se->clients_starting = 0;
return PAZPAR2_MALFORMED_PARAMETER_VALUE;
}
- l0 = se->clients_active;
- se->clients_active = 0;
session_leave(se, "session_search");
- for (l = l0; l; l = l->next)
+ session_alert_watch(se, SESSION_WATCH_SHOW);
+ session_alert_watch(se, SESSION_WATCH_BYTARGET);
+ session_alert_watch(se, SESSION_WATCH_TERMLIST);
+ session_alert_watch(se, SESSION_WATCH_SHOW_PREF);
+
+ for (l = se->clients_active; l; l = l->next)
{
int parse_ret;
struct client *cl = l->client;
no_working++;
}
}
- session_reset_active_clients(se, l0);
-
+ session_enter(se, "session_search2");
+ se->clients_starting = 0;
+ session_leave(se, "session_search2");
if (no_working == 0)
{
if (no_failed_query > 0)
// Probably session_init_databases_fun should be refactored instead of
// called here.
static struct session_database *load_session_database(struct session *se,
- char *id)
+ const char *id)
{
struct database *db = new_database_inherit_settings(id, se->session_nmem, se->service->settings);
session_init_databases_fun((void*) se, db);
// Find an existing session database. If not found, load it
static struct session_database *find_session_database(struct session *se,
- char *id)
+ const char *id)
{
struct session_database *sdb;
}
// Apply a session override to a database
-void session_apply_setting(struct session *se, char *dbname, char *setting,
- char *value)
+void session_apply_setting(struct session *se, const char *dbname,
+ const char *name, const char *value)
{
- struct session_database *sdb = find_session_database(se, dbname);
- struct conf_service *service = se->service;
- struct setting *new = nmem_malloc(se->session_nmem, sizeof(*new));
- int offset = settings_create_offset(service, setting);
-
- expand_settings_array(&sdb->settings, &sdb->num_settings, offset,
- se->session_nmem);
- new->precedence = 0;
- new->target = dbname;
- new->name = setting;
- new->value = value;
- new->next = sdb->settings[offset];
- sdb->settings[offset] = new;
-
- se->settings_modified = 1;
-
- // Force later recompute of settings-driven data structures
- // (happens when a search starts and client connections are prepared)
- switch (offset)
- {
- case PZ_XSLT:
- if (sdb->map)
- {
+ session_enter(se, "session_apply_setting");
+ {
+ struct session_database *sdb = find_session_database(se, dbname);
+ struct conf_service *service = se->service;
+ struct setting *s;
+ int offset = settings_create_offset(service, name);
+
+ expand_settings_array(&sdb->settings, &sdb->num_settings, offset,
+ se->session_nmem);
+ // Force later recompute of settings-driven data structures
+ // (happens when a search starts and client connections are prepared)
+ if (offset == PZ_XSLT)
sdb->map = 0;
+ se->settings_modified = 1;
+ for (s = sdb->settings[offset]; s; s = s->next)
+ if (!strcmp(s->name, name) &&
+ dbname && s->target && !strcmp(dbname, s->target))
+ break;
+ if (!s)
+ {
+ s = nmem_malloc(se->session_nmem, sizeof(*s));
+ s->precedence = 0;
+ s->target = nmem_strdup(se->session_nmem, dbname);
+ s->name = nmem_strdup(se->session_nmem, name);
+ s->next = sdb->settings[offset];
+ sdb->settings[offset] = s;
}
- break;
+ s->value = nmem_strdup(se->session_nmem, value);
}
+ session_leave(se, "session_apply_setting");
}
void session_destroy(struct session *se)
session->total_records = 0;
session->number_of_warnings_unknown_elements = 0;
session->number_of_warnings_unknown_metadata = 0;
- session->num_termlists = 0;
+ session->termlists = 0;
session->reclist = reclist_create(nmem);
session->clients_active = 0;
session->clients_cached = 0;
session->facet_limits = 0;
session->mergekey = 0;
session->rank = 0;
+ session->clients_starting = 0;
for (i = 0; i <= SESSION_WATCH_MAX; i++)
{
WRBUF w = wrbuf_alloc();
const char *name = session_setting_oneval(client_get_database(cl),
PZ_NAME);
-
res[*count].id = client_get_id(cl);
res[*count].name = *name ? name : "Unknown";
res[*count].hits = client_get_hits(cl);
res[*count].approximation = client_get_approximation(cl);
- res[*count].records = client_get_num_records(cl);
- res[*count].filtered = client_get_num_records_filtered(cl);
+ res[*count].records = client_get_num_records(cl,
+ &res[*count].filtered,
+ 0, 0);
res[*count].diagnostic =
client_get_diagnostic(cl, &res[*count].message,
&res[*count].addinfo);
void perform_termlist(struct http_channel *c, struct session *se,
const char *name, int num, int version)
{
- int i, j;
+ int j;
NMEM nmem_tmp = nmem_create();
char **names;
int num_names = 0;
const char *tname;
int must_generate_empty = 1; /* bug 5350 */
- for (i = 0; i < se->num_termlists; i++)
+ struct named_termlist *t = se->termlists;
+ for (; t; t = t->next)
{
- tname = se->termlists[i].name;
+ tname = t->name;
if (!strcmp(names[j], tname) || !strcmp(names[j], "*"))
{
struct termlist_score **p = 0;
wrbuf_puts(c->wrbuf, "\">\n");
must_generate_empty = 0;
- p = termlist_highscore(se->termlists[i].termlist, &len,
- nmem_tmp);
+ p = termlist_highscore(t->termlist, &len, nmem_tmp);
if (p)
{
int i;
}
else
{
- session_log(se, YLOG_LOG, "%s: no more to fetch",
- client_get_id(cl));
+ int filtered;
+ int ingest_failures;
+ int record_failures;
+ int num = client_get_num_records(
+ cl, &filtered, &ingest_failures, &record_failures);
+
+ session_log(se, YLOG_LOG, "%s: hits=" ODR_INT_PRINTF
+ " fetched=%d filtered=%d",
+ client_get_id(cl),
+ client_get_hits(cl),
+ num, filtered);
+ if (ingest_failures || record_failures)
+ {
+ session_log(se, YLOG_WARN, "%s:"
+ " ingest failures=%d record failures=%d",
+ client_get_id(cl),
+ ingest_failures, record_failures);
+ }
}
}
else
if (se->relevance)
{
for (spp = sp; spp; spp = spp->next)
- if (spp->type == Metadata_sortkey_relevance)
+ if (spp->type == Metadata_type_relevance)
{
relevance_prepare_read(se->relevance, se->reclist);
break;
}
*attrp = 0;
- if (type == Metadata_type_generic)
+ switch (type)
{
- char *p = nmem_strdup(nmem, value);
-
- p = normalize7bit_generic(p, " ,/.:([");
-
- rec_md->data.text.disp = p;
+ case Metadata_type_generic:
+ case Metadata_type_skiparticle:
+ 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.sort = 0;
rec_md->data.text.snippet = 0;
- }
- else if (type == Metadata_type_year || type == Metadata_type_date)
+ break;
+ case Metadata_type_year:
+ case Metadata_type_date:
{
int first, last;
int longdate = 0;
rec_md->data.number.min = first;
rec_md->data.number.max = last;
}
- else
+ break;
+ case Metadata_type_float:
+ rec_md->data.fnumber = atof(value);
+ break;
+ case Metadata_type_relevance:
+ case Metadata_type_position:
return 0;
+ }
return rec_md;
}
{
int ret = 0;
struct session *se = client_get_session(cl);
- struct conf_service *service = se->service;
-
- insert_settings_values(sdb, xdoc, root, service);
if (!check_record_filter(root, sdb))
{
struct session_database *sdb = client_get_database(cl);
struct conf_service *service = se->service;
xmlDoc *xdoc = normalize_record(se, sdb, service, rec, nmem);
- int r = 0;
- xmlNode *root;
+ int r = ingest_xml_record(cl, xdoc, record_no, nmem, 0);
+ client_store_xdoc(cl, record_no, xdoc);
+ return r;
+}
+int ingest_xml_record(struct client *cl, xmlDoc *xdoc,
+ int record_no, NMEM nmem, int cached_copy)
+{
+ struct session *se = client_get_session(cl);
+ struct session_database *sdb = client_get_database(cl);
+ struct conf_service *service = se->service;
+ xmlNode *root;
+ int r = 0;
if (!xdoc)
return -1;
if (sroot->type == XML_ELEMENT_NODE &&
!strcmp((const char *) sroot->name, "record"))
{
+ if (!cached_copy)
+ insert_settings_values(sdb, xdoc, root, service);
r = ingest_sub_record(cl, xdoc, sroot, record_no, nmem, sdb,
mk);
}
mk->value = nmem_strdup(nmem, mergekey_norm);
mk->next = 0;
+ if (!cached_copy)
+ insert_settings_values(sdb, xdoc, root, service);
r = ingest_sub_record(cl, xdoc, root, record_no, nmem, sdb, mk);
}
}
(const char *) root->name);
r = -1;
}
- xmlFreeDoc(xdoc);
return r;
}
if (check_limit_local(cl, record, record_no))
{
- session_log(se, YLOG_LOG, "Facet filtered out record no %d from %s",
- record_no, sdb->database->id);
if (type)
xmlFree(type);
if (value)
{
const char *sort_str = 0;
int skip_article =
- ser_sk->type == Metadata_sortkey_skiparticle;
+ ser_sk->type == Metadata_type_skiparticle;
if (!cluster->sortkeys[sk_field_id])
cluster->sortkeys[sk_field_id] =