static inline int
si_getresult(siread *q, sv *v, int compare)
{
int rc;
if (compare) {
rc = sr_compare(q->r->scheme, sv_pointer(v), sv_size(v),
q->key, q->keysize);
if (ssunlikely(rc != 0))
return 0;
}
if (q->prefix) {
rc = sr_compareprefix(q->r->scheme,
q->prefix,
q->prefixsize,
sv_pointer(v), sv_size(v));
if (ssunlikely(! rc))
return 0;
}
if (ssunlikely(q->has))
return sv_lsn(v) > q->vlsn;
if (ssunlikely(sv_is(v, SVDELETE)))
return 2;
rc = si_readdup(q, v);
if (ssunlikely(rc == -1))
return -1;
return 1;
}
static inline int
si_rangebranch(siread *q, sinode *n, sibranch *b, svmerge *m)
{
sicachebranch *c = si_cachefollow(q->cache);
assert(c->branch == b);
/* iterate cache */
if (ss_iterhas(sd_read, &c->i)) {
svmergesrc *s = sv_mergeadd(m, &c->i);
si_readstat(q, 1, n, 1);
s->ptr = c;
return 1;
}
if (c->open) {
return 1;
}
if (q->cache_only) {
return 2;
}
c->open = 1;
/* choose compression type */
int compression;
ssfilterif *compression_if;
if (! si_branchis_root(b)) {
compression = q->index->scheme->compression_branch;
compression_if = q->index->scheme->compression_branch_if;
} else {
compression = q->index->scheme->compression;
compression_if = q->index->scheme->compression_if;
}
sdreadarg arg = {
.index = &b->index,
.buf = &c->buf_a,
.buf_xf = &c->buf_b,
.buf_read = &q->index->readbuf,
.index_iter = &c->index_iter,
.page_iter = &c->page_iter,
.use_memory = n->in_memory,
.use_mmap = q->index->scheme->mmap,
.use_mmap_copy = 1,
.use_compression = compression,
.compression_if = compression_if,
.has = 0,
.has_vlsn = 0,
.o = q->order,
.memory = &b->copy,
.mmap = &n->map,
.file = &n->file,
.r = q->r
};
ss_iterinit(sd_read, &c->i);
int rc = ss_iteropen(sd_read, &c->i, &arg, q->key, q->keysize);
int reads = sd_read_stat(&c->i);
si_readstat(q, 0, n, reads);
if (ssunlikely(rc == -1))
return -1;
if (ssunlikely(! ss_iterhas(sd_read, &c->i)))
return 0;
svmergesrc *s = sv_mergeadd(m, &c->i);
s->ptr = c;
return 1;
}
static inline int
si_range(siread *q)
{
assert(q->has == 0);
ssiter i;
ss_iterinit(si_iter, &i);
ss_iteropen(si_iter, &i, q->r, q->index, q->order, q->key, q->keysize);
sinode *node;
next_node:
node = ss_iterof(si_iter, &i);
if (ssunlikely(node == NULL))
return 0;
si_txtrack(q->x, node);
/* prepare sources */
svmerge *m = &q->merge;
int count = node->branch_count + 2 + 1;
int rc = sv_mergeprepare(m, q->r, count);
if (ssunlikely(rc == -1)) {
sr_errorreset(q->r->e);
return -1;
}
/* external source (upsert) */
svmergesrc *s;
sv upbuf_reserve;
ssbuf upbuf;
if (ssunlikely(q->upsert_v && q->upsert_v->v)) {
ss_bufinit_reserve(&upbuf, &upbuf_reserve, sizeof(upbuf_reserve));
ss_bufadd(&upbuf, NULL, (void*)&q->upsert_v, sizeof(sv*));
s = sv_mergeadd(m, NULL);
ss_iterinit(ss_bufiterref, &s->src);
ss_iteropen(ss_bufiterref, &s->src, &upbuf, sizeof(sv*));
}
/* in-memory indexes */
svindex *second;
svindex *first = si_nodeindex_priority(node, &second);
if (first->count) {
s = sv_mergeadd(m, NULL);
ss_iterinit(sv_indexiter, &s->src);
ss_iteropen(sv_indexiter, &s->src, q->r, first, q->order,
q->key, q->keysize);
}
if (ssunlikely(second && second->count)) {
s = sv_mergeadd(m, NULL);
ss_iterinit(sv_indexiter, &s->src);
ss_iteropen(sv_indexiter, &s->src, q->r, second, q->order,
q->key, q->keysize);
}
/* cache and branches */
rc = si_cachevalidate(q->cache, node);
if (ssunlikely(rc == -1)) {
sr_oom(q->r->e);
return -1;
}
sibranch *b = node->branch;
while (b) {
rc = si_rangebranch(q, node, b, m);
if (ssunlikely(rc == -1 || rc == 2))
return rc;
b = b->next;
}
/* merge and filter data stream */
ssiter j;
ss_iterinit(sv_mergeiter, &j);
ss_iteropen(sv_mergeiter, &j, q->r, m, q->order);
ssiter k;
ss_iterinit(sv_readiter, &k);
ss_iteropen(sv_readiter, &k, q->r, &j, &q->index->u, q->vlsn, 0);
sv *v = ss_iterof(sv_readiter, &k);
if (ssunlikely(v == NULL)) {
sv_mergereset(&q->merge);
ss_iternext(si_iter, &i);
goto next_node;
}
rc = 1;
/* convert upsert search to SS_EQ */
if (q->upsert_eq) {
rc = sr_compare(q->r->scheme, sv_pointer(v), sv_size(v),
q->key, q->keysize);
rc = rc == 0;
}
/* do prefix search */
if (q->prefix && rc) {
rc = sr_compareprefix(q->r->scheme, q->prefix, q->prefixsize,
sv_pointer(v),
sv_size(v));
}
if (sslikely(rc == 1)) {
if (ssunlikely(si_readdup(q, v) == -1))
return -1;
}
/* skip a possible duplicates from data sources */
ss_iternext(sv_readiter, &k);
return rc;
}
static inline void
si_qrangebranch(siquery *q, sinode *n, sibranch *b, svmerge *m)
{
sicachebranch *cb = si_cachefollow(q->cache);
assert(cb->branch == b);
/* iterate cache */
if (ss_iterhas(si_read, &cb->i)) {
svmergesrc *s = sv_mergeadd(m, &cb->i);
q->index->read_cache++;
s->ptr = cb;
return;
}
if (cb->open) {
return;
}
cb->open = 1;
sireadarg arg = {
.scheme = q->index->scheme,
.index = q->index,
.n = n,
.b = b,
.buf = &cb->buf_a,
.buf_xf = &cb->buf_b,
.buf_read = &q->index->readbuf,
.index_iter = &cb->index_iter,
.page_iter = &cb->page_iter,
.vlsn = q->vlsn,
.has = 0,
.mmap_copy = 1,
.o = q->order,
.r = q->r
};
ss_iterinit(si_read, &cb->i);
int rc = ss_iteropen(si_read, &cb->i, &arg, q->key, q->keysize);
if (ssunlikely(rc == -1))
return;
if (ssunlikely(! ss_iterhas(si_read, &cb->i)))
return;
svmergesrc *s = sv_mergeadd(m, &cb->i);
s->ptr = cb;
}
static inline int
si_qrange(siquery *q)
{
ssiter i;
ss_iterinit(si_iter, &i);
ss_iteropen(si_iter, &i, q->r, q->index, q->order, q->key, q->keysize);
sinode *node;
next_node:
node = ss_iterof(si_iter, &i);
if (ssunlikely(node == NULL))
return 0;
/* prepare sources */
svmerge *m = &q->merge;
int count = node->branch_count + 2 + 1;
int rc = sv_mergeprepare(m, q->r, count);
if (ssunlikely(rc == -1)) {
sr_errorreset(q->r->e);
return -1;
}
/* external source (update) */
svmergesrc *s;
sv upbuf_reserve;
ssbuf upbuf;
if (ssunlikely(q->update_v && q->update_v->v)) {
ss_bufinit_reserve(&upbuf, &upbuf_reserve, sizeof(upbuf_reserve));
ss_bufadd(&upbuf, NULL, (void*)&q->update_v, sizeof(sv*));
s = sv_mergeadd(m, NULL);
ss_iterinit(ss_bufiterref, &s->src);
ss_iteropen(ss_bufiterref, &s->src, &upbuf, sizeof(sv*));
}
/* in-memory indexes */
svindex *second;
svindex *first = si_nodeindex_priority(node, &second);
if (first->count) {
s = sv_mergeadd(m, NULL);
ss_iterinit(sv_indexiter, &s->src);
ss_iteropen(sv_indexiter, &s->src, q->r, first, q->order,
q->key, q->keysize);
}
if (ssunlikely(second && second->count)) {
s = sv_mergeadd(m, NULL);
ss_iterinit(sv_indexiter, &s->src);
ss_iteropen(sv_indexiter, &s->src, q->r, second, q->order,
q->key, q->keysize);
}
/* cache and branches */
rc = si_cachevalidate(q->cache, node);
if (ssunlikely(rc == -1)) {
sr_oom(q->r->e);
return -1;
}
sibranch *b = node->branch;
while (b) {
si_qrangebranch(q, node, b, m);
b = b->next;
}
/* merge and filter data stream */
ssiter j;
ss_iterinit(sv_mergeiter, &j);
ss_iteropen(sv_mergeiter, &j, q->r, m, q->order);
ssiter k;
ss_iterinit(sv_readiter, &k);
ss_iteropen(sv_readiter, &k, q->r, &j, &q->index->u, q->vlsn, 0);
sv *v = ss_iterof(sv_readiter, &k);
if (ssunlikely(v == NULL)) {
sv_mergereset(&q->merge);
ss_iternext(si_iter, &i);
goto next_node;
}
rc = 1;
/* convert update search to SS_EQ */
if (q->update_eq) {
rc = sr_compare(q->r->scheme, sv_pointer(v), sv_size(v),
q->key, q->keysize);
rc = rc == 0;
}
/* do prefix search */
if (q->prefix && rc) {
rc = sr_compareprefix(q->r->scheme, q->prefix, q->prefixsize,
sv_pointer(v),
sv_size(v));
}
if (sslikely(rc == 1)) {
if (ssunlikely(si_querydup(q, v) == -1))
return -1;
}
/* skip a possible duplicates from data sources */
ss_iternext(sv_readiter, &k);
return rc;
}
