自学教程：C++ ss_iteropen函数代码示例

static inline intsi_qgetindex(siquery *q, sinode *node){	svindex *second;	svindex *first = si_nodeindex_priority(node, &second);	ssiter i;	ss_iterinit(sv_indexiter, &i);	int rc;	if (first->count > 0) {		rc = ss_iteropen(sv_indexiter, &i, q->r, first,		                 SS_GTE, q->key, q->keysize);		if (rc) {			goto result;		}	}	if (sslikely(second == NULL || !second->count))		return 0;	rc = ss_iteropen(sv_indexiter, &i, q->r, second,	                 SS_GTE, q->key, q->keysize);	if (! rc) {		return 0;	}result:;	sv *v = ss_iterof(sv_indexiter, &i);	assert(v != NULL);	svv *visible = v->v;	if (sslikely(! q->has)) {		visible = sv_visible((svv*)v->v, q->vlsn);		if (visible == NULL)			return 0;	}	sv vret;	sv_init(&vret, &sv_vif, visible, NULL);	return si_qgetresult(q, &vret, 0);}

static intsi_redistribute_index(si *index, sr *r, sdc *c, sinode *node){	svindex *vindex = si_nodeindex(node);	ssiter i;	ss_iterinit(sv_indexiter, &i);	ss_iteropen(sv_indexiter, &i, r, vindex, SS_GTE, NULL, 0);	while (ss_iterhas(sv_indexiter, &i)) {		sv *v = ss_iterof(sv_indexiter, &i);		int rc = ss_bufadd(&c->b, r->a, &v->v, sizeof(svv**));		if (ssunlikely(rc == -1))			return sr_oom_malfunction(r->e);		ss_iternext(sv_indexiter, &i);	}	if (ssunlikely(ss_bufused(&c->b) == 0))		return 0;	uint64_t now = ss_utime();	ss_iterinit(ss_bufiterref, &i);	ss_iteropen(ss_bufiterref, &i, &c->b, sizeof(svv*));	while (ss_iterhas(ss_bufiterref, &i)) {		svv *v = ss_iterof(ss_bufiterref, &i);		si_redistribute_set(index, r, now, v);		ss_iternext(ss_bufiterref, &i);	}	return 0;}

static intsi_redistribute(si *index, sr *r, sdc *c, sinode *node, ssbuf *result){	(void)index;	svindex *vindex = si_nodeindex(node);	ssiter i;	ss_iterinit(sv_indexiter, &i);	ss_iteropen(sv_indexiter, &i, r, vindex, SS_GTE, NULL, 0);	while (ss_iterhas(sv_indexiter, &i))	{		sv *v = ss_iterof(sv_indexiter, &i);		int rc = ss_bufadd(&c->b, r->a, &v->v, sizeof(svv**));		if (ssunlikely(rc == -1))			return sr_oom_malfunction(r->e);		ss_iternext(sv_indexiter, &i);	}	if (ssunlikely(ss_bufused(&c->b) == 0))		return 0;	ss_iterinit(ss_bufiterref, &i);	ss_iteropen(ss_bufiterref, &i, &c->b, sizeof(svv*));	ssiter j;	ss_iterinit(ss_bufiterref, &j);	ss_iteropen(ss_bufiterref, &j, result, sizeof(sinode*));	sinode *prev = ss_iterof(ss_bufiterref, &j);	ss_iternext(ss_bufiterref, &j);	while (1)	{		sinode *p = ss_iterof(ss_bufiterref, &j);		if (p == NULL) {			assert(prev != NULL);			while (ss_iterhas(ss_bufiterref, &i)) {				svv *v = ss_iterof(ss_bufiterref, &i);				v->next = NULL;				sv_indexset(&prev->i0, r, v);				ss_iternext(ss_bufiterref, &i);			}			break;		}		while (ss_iterhas(ss_bufiterref, &i))		{			svv *v = ss_iterof(ss_bufiterref, &i);			v->next = NULL;			sdindexpage *page = sd_indexmin(&p->self.index);			int rc = sr_compare(r->scheme, sv_vpointer(v), v->size,			                    sd_indexpage_min(&p->self.index, page),			                    page->sizemin);			if (ssunlikely(rc >= 0))				break;			sv_indexset(&prev->i0, r, v);			ss_iternext(ss_bufiterref, &i);		}		if (ssunlikely(! ss_iterhas(ss_bufiterref, &i)))			break;		prev = p;		ss_iternext(ss_bufiterref, &j);	}	assert(ss_iterof(ss_bufiterref, &i) == NULL);	return 0;}

static voidsv_mergeiter_merge_dup_a_chain(void){	stlist vlista;	stlist vlistb;	st_listinit(&vlista, 0);	st_listinit(&vlistb, 0);	int key = 7;	int i = 0;	int lsn = 5;	while (i < 5)	{		st_sv(&st_r.g, &vlista, lsn, 0 | ((i > 0) ? SVDUP: 0), key);		i++;		lsn--;	}	ssiter ita;	ss_iterinit(ss_bufiterref, &ita);	ss_iteropen(ss_bufiterref, &ita, &vlista.list, sizeof(sv*));	ssiter itb;	ss_iterinit(ss_bufiterref, &itb);	ss_iteropen(ss_bufiterref, &itb, &vlistb.list, sizeof(sv*));	svmerge m;	sv_mergeinit(&m);	sv_mergeprepare(&m, &st_r.r, 2);	svmergesrc *s = sv_mergeadd(&m, NULL);	t(s != NULL);	s->src = ita;	s = sv_mergeadd(&m, NULL);	t(s != NULL);	s->src = itb;	ssiter merge;	ss_iterinit(sv_mergeiter, &merge);	ss_iteropen(sv_mergeiter, &merge, &st_r.r, &m, SS_GTE);	i = 0;	while (ss_iteratorhas(&merge)) {		sv *v = (sv*)ss_iteratorof(&merge);		t( *(int*)sv_key(v, &st_r.r, 0) == key );		if (i == 0) {			t( sv_flags(v) == 0 );		} else {			t( (sv_flags(v) | sv_mergeisdup(&merge)) == (0|SVDUP) );		}		ss_iteratornext(&merge);		i++;	}	t( i == 5 );	ss_iteratorclose(&merge);	sv_mergefree(&m, &st_r.a);	st_listfree(&vlista, &st_r.r);	st_listfree(&vlistb, &st_r.r);}

static voidsv_mergeiter_merge_ba(void){	stlist vlista;	stlist vlistb;	st_listinit(&vlista, 0);	st_listinit(&vlistb, 0);	int i = 0;	while (i < 5)	{		st_sv(&st_r.g, &vlista, i, 0, i);		i++;	}	while (i < 10)	{		st_sv(&st_r.g, &vlistb, i, 0, i);		i++;	}	ssiter ita;	ss_iterinit(ss_bufiterref, &ita);	ss_iteropen(ss_bufiterref, &ita, &vlista.list, sizeof(sv*));	ssiter itb;	ss_iterinit(ss_bufiterref, &itb);	ss_iteropen(ss_bufiterref, &itb, &vlistb.list, sizeof(sv*));	svmerge m;	sv_mergeinit(&m);	sv_mergeprepare(&m, &st_r.r, 3);	svmergesrc *s = sv_mergeadd(&m, NULL);	t(s != NULL);	s->src = ita;	s = sv_mergeadd(&m, NULL);	t(s != NULL);	s->src = itb;	ssiter merge;	ss_iterinit(sv_mergeiter, &merge);	ss_iteropen(sv_mergeiter, &merge, &st_r.r, &m, SS_GTE);	i = 0;	while (ss_iteratorhas(&merge)) {		sv *v = (sv*)ss_iteratorof(&merge);		t( *(int*)sv_key(v, &st_r.r, 0) == i );		t( sv_lsn(v) == i );		t( sv_flags(v) == 0 );		ss_iteratornext(&merge);		i++;	}	t( i == 10 );	ss_iteratorclose(&merge);	sv_mergefree(&m, &st_r.a);	st_listfree(&vlista, &st_r.r);	st_listfree(&vlistb, &st_r.r);}

int si_compact(si *index, sr *r, sdc *c, siplan *plan, uint64_t vlsn){	sinode *node = plan->node;	assert(node->flags & SI_LOCK);	/* read node file */	sd_creset(c);	int rc = si_noderead(r, &c->c, node);	if (ssunlikely(rc == -1))		return -1;	/* prepare for compaction */	rc = sd_censure(c, r, node->branch_count);	if (ssunlikely(rc == -1)) {		sr_malfunction(r->e, "%s", "memory allocation failed");		return -1;	}	svmerge merge;	sv_mergeinit(&merge);	rc = sv_mergeprepare(&merge, r, node->branch_count);	if (ssunlikely(rc == -1))		return -1;	uint32_t size_stream = 0;	sdcbuf *cbuf = c->head;	sibranch *b = node->branch;	while (b) {		svmergessc *s = sv_mergeadd(&merge, NULL);		rc = ss_bufensure(&cbuf->b, r->a, b->index.h->sizevmax);		if (ssunlikely(rc == -1)) {			sr_malfunction(r->e, "%s", "memory allocation failed");			return -1;		}		size_stream += sd_indextotal(&b->index);		ss_iterinit(sd_iter, &s->ssc);		ss_iteropen(sd_iter, &s->ssc, r, &b->index, c->c.s, 0,		            index->scheme->compression, &cbuf->a, &cbuf->b);		cbuf = cbuf->next;		b = b->next;	}	ssiter i;	ss_iterinit(sv_mergeiter, &i);	ss_iteropen(sv_mergeiter, &i, r, &merge, SS_GTE);	rc = si_compaction(index, r, c, vlsn, node, &i, size_stream);	if (ssunlikely(rc == -1)) {		sv_mergefree(&merge, r->a);		return -1;	}	sv_mergefree(&merge, r->a);	return 0;}

static inline intsx_deadlock_in(sxmanager *m, sslist *mark, sx *t, sx *p){	if (p->deadlock.next != &p->deadlock)		return 0;	ss_listappend(mark, &p->deadlock);	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &p->log.buf, sizeof(svlogv));	for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))	{		svlogv *lv = ss_iterof(ss_bufiter, &i);		sxv *v = lv->v.v;		if (v->prev == NULL)			continue;		do {			sx *n = sx_find(m, v->id);			assert(n != NULL);			if (ssunlikely(n == t))				return 1;			int rc = sx_deadlock_in(m, mark, t, n);			if (ssunlikely(rc == 1))				return 1;			v = v->prev;		} while (v);	}	return 0;}

static voidsv_indexiter_iterate1(void){	svindex i;	t( sv_indexinit(&i) == 0 );	int j = 0;	while (j < 16) {		svv *v = st_svv(&st_r.g, NULL, j, 0, j);		t( sv_indexset(&i, &st_r.r, v) == 0 );		j++;	}	ssiter it;	ss_iterinit(sv_indexiter, &it);	ss_iteropen(sv_indexiter, &it, &st_r.r, &i, SS_GTE, NULL, 0);	j = 0;	while (ss_iteratorhas(&it)) {		sv *v = ss_iteratorof(&it);		t( sv_lsn(v) == j );		ss_iteratornext(&it);		j++;	}	t( j == 16 );	sv_indexfree(&i, &st_r.r);}

sxstate sx_rollback(sx *x){	sxmanager *m = x->manager;	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &x->log.buf, sizeof(svlogv));	/* support log free after commit and half-commit mode */	if (x->state == SXCOMMIT) {		int gc = 0;		for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))		{			svlogv *lv = ss_iterof(ss_bufiter, &i);			svv *v = lv->v.v;			int size = sv_vsize(v);			if (sv_vunref(m->r, v))				gc += size;		}		ss_quota(m->r->quota, SS_QREMOVE, gc);		sx_promote(x, SXROLLBACK);		return SXROLLBACK;	}	sx_rollback_svp(x, &i, 1);	sx_promote(x, SXROLLBACK);	sx_end(x);	return SXROLLBACK;}

static inline voidsx_rollback_index(sx *t, int translate){	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &t->log.buf, sizeof(svlogv));	for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))	{		svlogv *lv = ss_iterof(ss_bufiter, &i);		sxv *v = lv->v.v;		/* remove from index and replace head with		 * a first waiter */		if (v->prev)			goto unlink;		sxindex *i = v->index;		if (v->next == NULL)			ss_rbremove(&i->i, &v->node);		else			ss_rbreplace(&i->i, &v->node, &v->next->node);unlink:		sx_vunlink(v);		/* translate log version from sxv to svv */		if (translate) {			sv_init(&lv->v, &sv_vif, v->v, NULL);			lv->vgc = v;		}	}}

sxstate sx_commit(sx *t){	assert(t->s == SXPREPARE);	if (t->complete)		goto complete;	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &t->log.buf, sizeof(svlogv));	for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))	{		svlogv *lv = ss_iterof(ss_bufiter, &i);		sxv *v = lv->v.v;		/* mark waiters as aborted */		sx_vabortwaiters(v);		/* remove from concurrent index and replace		 * head with a first waiter */		sxindex *i = v->index;		if (v->next == NULL)			ss_rbremove(&i->i, &v->node);		else			ss_rbreplace(&i->i, &v->node, &v->next->node);		/* unlink version */		sx_vunlink(v);		/* translate log version from sxv to svv */		sv_init(&lv->v, &sv_vif, v->v, NULL);		lv->vgc = v;	}complete:	t->s = SXCOMMIT;	sx_end(t);	return SXCOMMIT;}

sxstate sx_prepare(sx *t, sxpreparef prepare, void *arg){	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &t->log.buf, sizeof(svlogv));	sxstate s = SXPREPARE;	for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))	{		svlogv *lv = ss_iterof(ss_bufiter, &i);		sxv *v = lv->v.v;		/* cancelled by a concurrent commited		 * transaction */		if (v->v->flags & SVABORT) {			s = SXROLLBACK;			goto done;		}		/* concurrent update in progress */		if (v->prev != NULL) {			s = SXLOCK;			goto done;		}		/* check that new key has not been committed by		 * a concurrent transaction */		if (prepare) {			sxindex *i = v->index;			s = prepare(t, &lv->v, arg, i->ptr);			if (ssunlikely(s != SXPREPARE))				goto done;		}	}done:	t->s = s;	return s;}

void sx_gc(sx *t, sr *r){	sxmanager *m = t->manager;	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &t->log.buf, sizeof(svlogv));	if (sslikely(t->s == SXCOMMIT)) {		for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))		{			svlogv *lv = ss_iterof(ss_bufiter, &i);			sxv *v = lv->vgc;			ss_free(m->asxv, v);		}	} else	if (t->s == SXROLLBACK) {		int gc = 0;		for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))		{			svlogv *lv = ss_iterof(ss_bufiter, &i);			sxv *v = lv->v.v;			gc += sv_vsize((svv*)v->v);			sx_vfree(m->a, m->asxv, v);		}		ss_quota(r->quota, SS_QREMOVE, gc);	}	sv_logfree(&t->log, m->a);	t->s = SXUNDEF;}

static inline intsi_recovercomplete(sitrack *track, sr *r, si *index, ssbuf *buf){	/* prepare and build primary index */	ss_bufreset(buf);	ssrbnode *p = ss_rbmin(&track->i);	while (p) {		sinode *n = sscast(p, sinode, node);		int rc = ss_bufadd(buf, r->a, &n, sizeof(sinode*));		if (ssunlikely(rc == -1))			return sr_oom_malfunction(r->e);		p = ss_rbnext(&track->i, p);	}	ssiter i;	ss_iterinit(ss_bufiterref, &i);	ss_iteropen(ss_bufiterref, &i, buf, sizeof(sinode*));	while (ss_iterhas(ss_bufiterref, &i))	{		sinode *n = ss_iterof(ss_bufiterref, &i);		if (n->recover & SI_RDB_REMOVE) {			int rc = si_nodefree(n, r, 1);			if (ssunlikely(rc == -1))				return -1;			ss_iternext(ss_bufiterref, &i);			continue;		}		n->recover = SI_RDB;		si_insert(index, n);		si_plannerupdate(&index->p, SI_COMPACT|SI_BRANCH|SI_TEMP, n);		ss_iternext(ss_bufiterref, &i);	}	return 0;}

static inline intsi_noderecover(sinode *n, sr *r, sdsnapshotnode *sn, int in_memory){	/* fast recover from snapshot file */	if (sn) {		n->temperature_reads = sn->temperature_reads;		if (! in_memory)			return si_noderecover_snapshot(n, r, sn);	}	/* recover branches */	ssiter i;	ss_iterinit(sd_recover, &i);	ss_iteropen(sd_recover, &i, r, &n->file);	int first = 1;	int rc;	while (ss_iteratorhas(&i))	{		sdindexheader *h = ss_iteratorof(&i);		sibranch *b;		if (first) {			b = &n->self;		} else {			b = si_branchnew(r);			if (ssunlikely(b == NULL))				goto error;		}		sdindex index;		sd_indexinit(&index);		rc = sd_indexcopy(&index, r, h);		if (ssunlikely(rc == -1))			goto error;		si_branchset(b, &index);		if (in_memory) {			rc = si_branchload(b, r, &n->file);			if (ssunlikely(rc == -1))				goto error;		}		b->next   = n->branch;		n->branch = b;		n->branch_count++;		first = 0;		ss_iteratornext(&i);	}	rc = sd_recover_complete(&i);	if (ssunlikely(rc == -1))		goto error;	ss_iteratorclose(&i);	n->in_memory = in_memory;	return 0;error:	ss_iteratorclose(&i);	return -1;}

static inline intsi_noderecover(sinode *n, sr *r, int in_memory){	/* recover branches */	ssiter i;	ss_iterinit(sd_recover, &i);	ss_iteropen(sd_recover, &i, r, &n->file);	int first = 1;	int rc;	while (ss_iteratorhas(&i))	{		sdindexheader *h = ss_iteratorof(&i);		sibranch *b;		if (first) {			b =  &n->self;		} else {			b = si_branchnew(r);			if (ssunlikely(b == NULL))				goto error;		}		sdindex index;		sd_indexinit(&index);		rc = sd_indexcopy(&index, r, h);		if (ssunlikely(rc == -1))			goto error;		si_branchset(b, &index);		if (in_memory) {			char *start = (char*)h - h->total - sizeof(sdseal);			char *end = start + sizeof(sdseal) + h->total +			            sizeof(sdindexheader) + h->size +			            h->extension;			int branch_size = end - start;			rc = ss_blobensure(&b->copy, branch_size);			if (ssunlikely(rc == -1)) {				sr_oom_malfunction(r->e);				goto error;			}			memcpy(b->copy.p, start, branch_size);		}		b->next   = n->branch;		n->branch = b;		n->branch_count++;		first = 0;		ss_iteratornext(&i);	}	rc = sd_recover_complete(&i);	if (ssunlikely(rc == -1))		goto error;	ss_iteratorclose(&i);	return 0;error:	ss_iteratorclose(&i);	return -1;}

sxstate sx_rollback(sx *x){	assert(x->state != SX_COMMIT);	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &x->log->buf, sizeof(svlogv));	sx_rollback_svp(x, &i, 1);	sx_promote(x, SX_ROLLBACK);	sx_end(x);	return SX_ROLLBACK;}

static voidfreelog(svlog *log, sr *c){	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &log->buf, sizeof(svlogv));	for (; ss_iteratorhas(&i); ss_iteratornext(&i)) {		svlogv *v = ss_iteratorof(&i);		ss_free(c->a, v->v.v);	}	sv_logfree(log, c->a);}

static intsi_readcommited_branch(sr *r, sibranch *b, sv *v){	ssiter i;	ss_iterinit(sd_indexiter, &i);	ss_iteropen(sd_indexiter, &i, r, &b->index, SS_GTE,	            sv_pointer(v), sv_size(v));	sdindexpage *page = ss_iterof(sd_indexiter, &i);	if (page == NULL)		return 0;	return page->lsnmax >= sv_lsn(v);}

static voidsv_indexiter_iterate0(void){	svindex i;	t( sv_indexinit(&i) == 0 );	int keyb = 3;	int keya = 7;	int keyc = 15;	svv *h = st_svv(&st_r.g, NULL, 0, 0, keyb);	t( sv_indexset(&i, &st_r.r, h) == 0 );	svv *p = st_svv(&st_r.g, NULL, 2, 0, keyc);	t( sv_indexset(&i, &st_r.r, p) == 0 );	svv *va = st_svv(&st_r.g, NULL, 1, 0, keya);	t( sv_indexset(&i, &st_r.r, va) == 0 );	svv *vb = st_svv(&st_r.g, NULL, 2, 0, keya);	t( sv_indexset(&i, &st_r.r, vb) == 0 );	svv *vc = st_svv(&st_r.g, NULL, 3, 0, keya);	t( sv_indexset(&i, &st_r.r, vc) == 0 );	ssiter it;	ss_iterinit(sv_indexiter, &it);	ss_iteropen(sv_indexiter, &it, &st_r.r, &i, SS_GTE, NULL, 0);	t( ss_iteratorhas(&it) != 0 );	sv *v = ss_iteratorof(&it);	t( v->v == h );	ss_iteratornext(&it);	v = ss_iteratorof(&it);	t( v->v == vc );	ss_iteratornext(&it);	v = ss_iteratorof(&it);	t( v->v == vb );	ss_iteratornext(&it);	v = ss_iteratorof(&it);	t( v->v == va );	ss_iteratornext(&it);	v = ss_iteratorof(&it);	t( v->v == p );	ss_iteratornext(&it);	v = ss_iteratorof(&it);	t( v == NULL );	sv_indexfree(&i, &st_r.r);}

static voidsd_v_test(void){	sdbuild b;	sd_buildinit(&b);	t( sd_buildbegin(&b, &st_r.r, 1, 0, 0) == 0);	int i = 7;	int j = 8;	addv(&b, &st_r.r, 3, 0, &i);	addv(&b, &st_r.r, 4, 0, &j);	sd_buildend(&b, &st_r.r);	ssbuf buf;	ss_bufinit(&buf);	ssbuf xfbuf;	ss_bufinit(&xfbuf);	t( ss_bufensure(&xfbuf, &st_r.a, 1024) == 0 );	t( sd_commitpage(&b, &st_r.r, &buf) == 0 );	sdpageheader *h = (sdpageheader*)buf.s;	sdpage page;	sd_pageinit(&page, h);	ssiter it;	ss_iterinit(sd_pageiter, &it);	ss_iteropen(sd_pageiter, &it, &st_r.r, &xfbuf, &page, SS_GTE, NULL, 0);	t( ss_iteratorhas(&it) != 0 );	sv *v = ss_iteratorof(&it);	t( v != NULL );	t( *(int*)sv_key(v, &st_r.r, 0) == i );	t( sv_lsn(v) == 3 );	t( sv_flags(v) == 0 );	ss_iteratornext(&it);	t( ss_iteratorhas(&it) != 0 );	v = ss_iteratorof(&it);	t( v != NULL );		t( *(int*)sv_key(v, &st_r.r, 0) == j );	t( sv_lsn(v) == 4 );	t( sv_flags(v) == 0 );	ss_iteratornext(&it);	v = ss_iteratorof(&it);	t( v == NULL );	sd_buildfree(&b, &st_r.r);	ss_buffree(&buf, &st_r.a);	ss_buffree(&xfbuf, &st_r.a);}

static intsi_splitfree(ssbuf *result, sr *r){	ssiter i;	ss_iterinit(ss_bufiterref, &i);	ss_iteropen(ss_bufiterref, &i, result, sizeof(sinode*));	while (ss_iterhas(ss_bufiterref, &i))	{		sinode *p = ss_iterof(ss_bufiterref, &i);		si_nodefree(p, r, 0);		ss_iternext(ss_bufiterref, &i);	}	return 0;}

static voidsv_indexiter_lte_empty(void){	svindex i;	t( sv_indexinit(&i) == 0 );	ssiter it;	ss_iterinit(sv_indexiter, &it);	ss_iteropen(sv_indexiter, &it, &st_r.r, &i, SS_LTE, NULL, 0);	t( ss_iteratorhas(&it) == 0 );	sv *v = ss_iteratorof(&it);	t( v == NULL );	sv_indexfree(&i, &st_r.r);}

static voidsv_indexiter_lt_eq(void){	svindex i;	t( sv_indexinit(&i) == 0 );	int keya = 7;	int keyb = 5;	int keyc = 2;	svv *va = st_svv(&st_r.g, NULL, 0, 0, keya);	t( sv_indexset(&i, &st_r.r, va) == 0 );	svv *vb = st_svv(&st_r.g, NULL, 0, 0, keyb);	t( sv_indexset(&i, &st_r.r, vb) == 0 );	svv *vc = st_svv(&st_r.g, NULL, 0, 0, keyc);	t( sv_indexset(&i, &st_r.r, vc) == 0 );	ssiter it;	ss_iterinit(sv_indexiter, &it);	ss_iteropen(sv_indexiter, &it, &st_r.r, &i, SS_LT, sv_vpointer(va), va->size);	t( ss_iteratorhas(&it) != 0 );	sv *v = ss_iteratorof(&it);	t( v->v == vb );	ss_iterinit(sv_indexiter, &it);	ss_iteropen(sv_indexiter, &it, &st_r.r, &i, SS_LT, sv_vpointer(vb), vb->size);	t( ss_iteratorhas(&it) != 0 );	v = ss_iteratorof(&it);	t( v->v == vc );	ss_iterinit(sv_indexiter, &it);	ss_iteropen(sv_indexiter, &it, &st_r.r, &i, SS_LT, sv_vpointer(vc), vc->size);	t( ss_iteratorhas(&it) == 0 );	v = ss_iteratorof(&it);	t( v == NULL );	sv_indexfree(&i, &st_r.r);}

static inline voidsi_redistribute_set(si *index, sr *r, svv *v){	/* match node */	ssiter i;	ss_iterinit(si_iter, &i);	ss_iteropen(si_iter, &i, r, index, SS_GTE, sv_vpointer(v));	sinode *node = ss_iterof(si_iter, &i);	assert(node != NULL);	/* update node */	svindex *vindex = si_nodeindex(node);	sv_indexset(vindex, r, v);	node->used += sv_vsize(v, &index->r);	/* schedule node */	si_plannerupdate(&index->p, node);}

static voidsv_indexiter_gte_empty(void){	svindex i;	t( sv_indexinit(&i) == 0 );	svv *key = st_svv(&st_r.g, &st_r.gc, 0, 0, 7);	ssiter it;	ss_iterinit(sv_indexiter, &it);	ss_iteropen(sv_indexiter, &it, &st_r.r, &i, SS_GTE, sv_vpointer(key), key->size);	t( ss_iteratorhas(&it) == 0 );	sv *v = ss_iteratorof(&it);	t( v == NULL );	sv_indexfree(&i, &st_r.r);}

sxstate sx_commit(sx *x){	if (x->state == SX_COMMIT)		return SX_COMMIT;	assert(x->state == SX_PREPARE);	sxmanager *m = x->manager;	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &x->log->buf, sizeof(svlogv));	uint64_t csn = ++m->csn;	for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))	{		svlogv *lv = ss_iterof(ss_bufiter, &i);		sxv *v = lv->ptr;		if ((int)v->lo == x->log_read)			break;		/* abort conflict reader */		if (v->prev && !sx_vcommitted(v->prev)) {			sxindex *i = v->prev->index;			assert(sv_vflags(v->prev->v, i->r) & SVGET);			sx_vabort(v->prev);		}		/* abort waiters */		sx_vabort_all(v->next);		/* mark stmt as commited */		sx_vcommit(v, csn);		lv->ptr = NULL;		/* schedule read stmt for gc */		sxindex *i = v->index;		if (sv_vflags(v->v, i->r) & SVGET) {			sv_vref(v->v);			v->gc = m->gc;			m->gc = v;			m->count_gc++;		} else {			sx_untrack(v);			sx_vpool_push(&m->pool, v);		}	}	/* rollback latest reads */	sx_rollback_svp(x, &i, 0);	sx_promote(x, SX_COMMIT);	sx_end(x);	return SX_COMMIT;}

sxstate sx_commit(sx *x){	assert(x->state == SXPREPARE);	sxmanager *m = x->manager;	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &x->log.buf, sizeof(svlogv));	uint64_t csn = ++m->csn;	for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))	{		svlogv *lv = ss_iterof(ss_bufiter, &i);		sxv *v = lv->v.v;		if ((int)v->lo == x->log_read)			break;		/* abort conflict reader */		if (v->prev && !sx_vcommitted(v->prev)) {			assert(v->prev->v->flags & SVGET);			sx_vabort(v->prev);		}		/* abort waiters */		sx_vabort_all(v->next);		/* mark stmt as commited */		sx_vcommit(v, csn);		/* translate log version from sxv to svv */		sv_init(&lv->v, &sv_vif, v->v, NULL);		/* schedule read stmt for gc */		if (v->v->flags & SVGET) {			sv_vref(v->v);			v->gc = m->gc;			m->gc = v;			m->count_gc++;		} else {			sx_untrack(v);			ss_free(m->asxv, v);		}	}	/* rollback latest reads */	sx_rollback_svp(x, &i, 0);	sx_promote(x, SXCOMMIT);	sx_end(x);	return SXCOMMIT;}

static inline voidsi_redistribute_set(si *index, sr *r, uint64_t now, svv *v){	index->update_time = now;	/* match node */	ssiter i;	ss_iterinit(si_iter, &i);	ss_iteropen(si_iter, &i, r, index, SS_ROUTE, sv_vpointer(v), v->size);	sinode *node = ss_iterof(si_iter, &i);	assert(node != NULL);	/* update node */	svindex *vindex = si_nodeindex(node);	sv_indexset(vindex, r, v);	node->update_time = index->update_time;	node->used += sv_vsize(v);	/* schedule node */	si_plannerupdate(&index->p, SI_BRANCH, node);}

static inline intsi_tracksnapshot(sitrack *track, sr *r, si *i, sdsnapshot *s){	/* read snapshot */	ssiter iter;	ss_iterinit(sd_snapshotiter, &iter);	int rc;	rc = ss_iteropen(sd_snapshotiter, &iter, r, s);	if (ssunlikely(rc == -1))		return -1;	for (; ss_iterhas(sd_snapshotiter, &iter);	      ss_iternext(sd_snapshotiter, &iter))	{		sdsnapshotnode *n = ss_iterof(sd_snapshotiter, &iter);		/* skip updated nodes */		sspath path;		ss_path(&path, i->scheme->path, n->id, ".db");		rc = ss_vfsexists(r->vfs, path.path);		if (! rc)			continue;		uint64_t size = ss_vfssize(r->vfs, path.path);		if (size != n->size_file)			continue;		/* recover node */		sinode *node = si_nodenew(r);		if (ssunlikely(node == NULL))			return -1;		node->recover = SI_RDB;		rc = si_nodeopen(node, r, i->scheme, &path, n);		if (ssunlikely(rc == -1)) {			si_nodefree(node, r, 0);			return -1;		}		si_trackmetrics(track, node);		si_trackset(track, node);	}	/* recover index temperature (read stats) */	sdsnapshotheader *h = sd_snapshot_header(s);	i->read_cache = h->read_cache;	i->read_disk  = h->read_disk;	i->lru_v      = h->lru_v;	i->lru_steps  = h->lru_steps;	return 0;}