static void
mt_multi_stmt(stc *cx)
{
cx->env = sp_env();
t( cx->env != NULL );
void *c = sp_ctl(cx->env);
t( c != NULL );
t( sp_set(c, "sophia.path", cx->suite->sophiadir) == 0 );
t( sp_set(c, "scheduler.threads", "3") == 0 );
t( sp_set(c, "log.path", cx->suite->logdir) == 0 );
t( sp_set(c, "log.sync", "0") == 0 );
t( sp_set(c, "log.rotate_sync", "0") == 0 );
t( sp_set(c, "db", "test") == 0 );
t( sp_set(c, "db.test.path", cx->suite->dir) == 0 );
t( sp_set(c, "db.test.sync", "0") == 0 );
cx->db = sp_get(c, "db.test");
t( cx->db != NULL );
t( sp_open(cx->env) == 0 );
ssa a;
ss_aopen(&a, &ss_stda);
srscheme cmp;
sr_schemeinit(&cmp);
srkey *part = sr_schemeadd(&cmp, &a);
t( sr_keysetname(part, &a, "key") == 0 );
t( sr_keyset(part, &a, "u32") == 0 );
ssinjection ij;
memset(&ij, 0, sizeof(ij));
srerror error;
sr_errorinit(&error);
srseq seq;
sr_seqinit(&seq);
sscrcf crc = ss_crc32c_function();
sr r;
sr_init(&r, &error, &a, &seq, SF_KV, SF_SRAW, &cmp, &ij, crc, NULL);
soworkers w;
so_workersinit(&w);
void *ptr[2] = { cx->env, cx->db };
t( so_workersnew(&w, &r, 5, multi_stmt_thread, (void*)ptr) == 0 );
t( so_workersshutdown(&w, &r) == 0 );
sr_schemefree(&cmp, &a);
void *o = sp_get(c, "db.test.index.count");
t( o != NULL );
t( strcmp( sp_get(o, "value", NULL), "100000") == 0 );
sp_destroy(o);
t( sp_destroy(cx->env) == 0 );
}
static void
sr_scheme_saveload(void)
{
srscheme cmp;
sr_schemeinit(&cmp);
srkey *part = sr_schemeadd(&cmp, &st_r.a);
t( sr_keysetname(part, &st_r.a, "key") == 0 );
t( sr_keyset(part, &st_r.a, "u32") == 0 );
ssbuf buf;
ss_bufinit(&buf);
t( sr_schemesave(&cmp, &st_r.a, &buf) == 0 );
sr_schemefree(&cmp, &st_r.a);
sr_schemeinit(&cmp);
t( sr_schemeload(&cmp, &st_r.a, buf.s, ss_bufused(&buf)) == 0 );
t( cmp.count == 1 );
t( strcmp(cmp.parts[0].name, "key") == 0 );
t( cmp.parts[0].type == SS_U32 );
sr_schemefree(&cmp, &st_r.a);
ss_buffree(&buf, &st_r.a);
}
static int
se_dbscheme_init(sedb *db, char *name)
{
se *e = se_of(&db->o);
/* prepare index scheme */
sischeme *scheme = &db->scheme;
scheme->name = ss_strdup(&e->a, name);
if (ssunlikely(scheme->name == NULL))
goto e0;
scheme->id = sr_seq(&e->seq, SR_DSNNEXT);
scheme->sync = 2;
scheme->mmap = 0;
scheme->storage = SI_SCACHE;
scheme->cache_mode = 0;
scheme->cache_sz = NULL;
scheme->node_size = 64 * 1024 * 1024;
scheme->node_compact_load = 0;
scheme->node_page_size = 128 * 1024;
scheme->node_page_checksum = 1;
scheme->compression_key = 0;
scheme->compression = 0;
scheme->compression_if = &ss_nonefilter;
scheme->compression_branch = 0;
scheme->compression_branch_if = &ss_nonefilter;
scheme->amqf = 0;
scheme->fmt = SF_KV;
scheme->fmt_storage = SF_SRAW;
scheme->path_fail_on_exists = 0;
scheme->path_fail_on_drop = 1;
scheme->lru = 0;
scheme->lru_step = 128 * 1024;
scheme->buf_gc_wm = 1024 * 1024;
scheme->storage_sz = ss_strdup(&e->a, "cache");
if (ssunlikely(scheme->storage_sz == NULL))
goto e1;
scheme->compression_sz =
ss_strdup(&e->a, scheme->compression_if->name);
if (ssunlikely(scheme->compression_sz == NULL))
goto e1;
scheme->compression_branch_sz =
ss_strdup(&e->a, scheme->compression_branch_if->name);
if (ssunlikely(scheme->compression_branch_sz == NULL))
goto e1;
sf_upsertinit(&scheme->fmt_upsert);
scheme->fmt_sz = ss_strdup(&e->a, "kv");
if (ssunlikely(scheme->fmt_sz == NULL))
goto e1;
/* init single key part as string */
int rc;
sr_schemeinit(&scheme->scheme);
srkey *part = sr_schemeadd(&scheme->scheme);
rc = sr_keysetname(part, &e->a, "key");
if (ssunlikely(rc == -1))
goto e1;
rc = sr_keyset(part, &e->a, "string");
if (ssunlikely(rc == -1))
goto e1;
return 0;
e1:
si_schemefree(&db->scheme, &db->r);
e0:
sr_oom(&e->error);
return -1;
}
int si_schemerecover(sischeme *s, sr *r)
{
sdscheme c;
sd_schemeinit(&c);
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s/scheme", s->path);
int rc;
rc = sd_schemerecover(&c, r, path);
if (ssunlikely(rc == -1))
goto error;
ssiter i;
ss_iterinit(sd_schemeiter, &i);
rc = ss_iteropen(sd_schemeiter, &i, r, &c, 1);
if (ssunlikely(rc == -1))
goto error;
while (ss_iterhas(sd_schemeiter, &i))
{
sdschemeopt *opt = ss_iterof(sd_schemeiter, &i);
switch (opt->id) {
case SI_SCHEME_FORMAT:
s->fmt = sd_schemeu32(opt);
char *name;
if (s->fmt == SF_KV)
name = "kv";
else
if (s->fmt == SF_DOCUMENT)
name = "document";
else
goto error;
ss_free(r->a, s->fmt_sz);
s->fmt_sz = ss_strdup(r->a, name);
if (ssunlikely(s->fmt_sz == NULL))
goto error;
break;
case SI_SCHEME_FORMAT_STORAGE:
s->fmt_storage = sd_schemeu32(opt);
break;
case SI_SCHEME_SCHEME: {
sr_schemefree(&s->scheme, r->a);
sr_schemeinit(&s->scheme);
ssbuf buf;
ss_bufinit(&buf);
rc = sr_schemeload(&s->scheme, r->a, sd_schemesz(opt), opt->size);
if (ssunlikely(rc == -1))
goto error;
ss_buffree(&buf, r->a);
break;
}
case SI_SCHEME_NODE_SIZE:
s->node_size = sd_schemeu64(opt);
break;
case SI_SCHEME_NODE_PAGE_SIZE:
s->node_page_size = sd_schemeu32(opt);
break;
case SI_SCHEME_COMPRESSION_KEY:
s->compression_key = sd_schemeu32(opt);
break;
case SI_SCHEME_COMPRESSION: {
char *name = sd_schemesz(opt);
ssfilterif *cif = ss_filterof(name);
if (ssunlikely(cif == NULL))
goto error;
s->compression_if = cif;
s->compression = s->compression_if != &ss_nonefilter;
ss_free(r->a, s->compression_sz);
s->compression_sz = ss_strdup(r->a, cif->name);
if (ssunlikely(s->compression_sz == NULL))
goto error;
break;
}
case SI_SCHEME_COMPRESSION_BRANCH: {
char *name = sd_schemesz(opt);
ssfilterif *cif = ss_filterof(name);
if (ssunlikely(cif == NULL))
goto error;
s->compression_branch_if = cif;
s->compression_branch = s->compression_branch_if != &ss_nonefilter;
ss_free(r->a, s->compression_branch_sz);
s->compression_branch_sz = ss_strdup(r->a, cif->name);
if (ssunlikely(s->compression_branch_sz == NULL))
goto error;
break;
}
case SI_SCHEME_AMQF:
s->amqf = sd_schemeu32(opt);
break;
case SI_SCHEME_CACHE_MODE:
s->cache_mode = sd_schemeu32(opt);
break;
case SI_SCHEME_EXPIRE:
s->expire = sd_schemeu32(opt);
break;
default: /* skip unknown */
break;
}
ss_iternext(sd_schemeiter, &i);
}
sd_schemefree(&c, r);
return 0;
error:
sd_schemefree(&c, r);
return -1;
}
