int sd_indexcommit(sdindex *i, sr *r, sdid *id, ssqf *qf, uint64_t offset)
{
int size = ss_bufused(&i->v);
int size_extension = 0;
int extensions = 0;
if (qf) {
extensions = SD_INDEXEXT_AMQF;
size_extension += sizeof(sdindexamqf);
size_extension += qf->qf_table_size;
}
int rc = ss_bufensure(&i->i, r->a, size + size_extension);
if (ssunlikely(rc == -1))
return sr_oom(r->e);
memcpy(i->i.p, i->v.s, size);
ss_bufadvance(&i->i, size);
if (qf) {
sdindexamqf *qh = (sdindexamqf*)(i->i.p);
qh->q = qf->qf_qbits;
qh->r = qf->qf_rbits;
qh->entries = qf->qf_entries;
qh->size = qf->qf_table_size;
ss_bufadvance(&i->i, sizeof(sdindexamqf));
memcpy(i->i.p, qf->qf_table, qf->qf_table_size);
ss_bufadvance(&i->i, qf->qf_table_size);
}
ss_buffree(&i->v, r->a);
i->h = sd_indexheader(i);
i->h->offset = offset;
i->h->id = *id;
i->h->extension = size_extension;
i->h->extensions = extensions;
i->h->crc = ss_crcs(r->crc, i->h, sizeof(sdindexheader), 0);
return 0;
}
int sd_indexbegin(sdindex *i, sr *r)
{
int rc = ss_bufensure(&i->i, r->a, sizeof(sdindexheader));
if (ssunlikely(rc == -1))
return sr_oom(r->e);
sdindexheader *h = sd_indexheader(i);
sr_version(&h->version);
h->crc = 0;
h->size = 0;
h->sizevmax = 0;
h->count = 0;
h->keys = 0;
h->total = 0;
h->totalorigin = 0;
h->extension = 0;
h->extensions = 0;
h->lsnmin = UINT64_MAX;
h->lsnmax = 0;
h->tsmin = 0;
h->offset = 0;
h->dupkeys = 0;
h->dupmin = UINT64_MAX;
memset(h->reserve, 0, sizeof(h->reserve));
sd_idinit(&h->id, 0, 0, 0);
i->h = NULL;
ss_bufadvance(&i->i, sizeof(sdindexheader));
return 0;
}
int sd_indexbegin(sdindex *i, sr *r, uint64_t offset)
{
int rc = sr_bufensure(&i->i, r->a, sizeof(sdindexheader));
if (srunlikely(rc == -1))
return sr_error(r->e, "%s", "memory allocation failed");
sdindexheader *h = sd_indexheader(i);
sr_version(&h->version);
h->crc = 0;
h->size = 0;
h->count = 0;
h->keys = 0;
h->total = 0;
h->totalorigin = 0;
h->extension = 0;
h->lsnmin = UINT64_MAX;
h->lsnmax = 0;
h->tsmin = 0;
h->offset = offset;
h->dupkeys = 0;
h->dupmin = UINT64_MAX;
memset(h->reserve, 0, sizeof(h->reserve));
sd_idinit(&h->id, 0, 0, 0);
i->h = NULL;
sr_bufadvance(&i->i, sizeof(sdindexheader));
return 0;
}
int sd_indexcommit(sdindex *i, sr *r, sdid *id, ssqf *qf,
uint32_t align,
uint64_t offset)
{
int size = ss_bufused(&i->v);
int size_extension = 0;
int extensions = 0;
if (qf) {
extensions = SD_INDEXEXT_AMQF;
size_extension += sizeof(sdindexamqf);
size_extension += qf->qf_table_size;
}
/* calculate index align for direct_io */
int size_meta = size + size_extension + sizeof(sdindexheader);
int size_align = 0;
if (align) {
size_align += align - ((offset + size_meta + ss_bufused(&i->i)) % align);
size_meta += size_align;
}
int rc = ss_bufensure(&i->i, r->a, size_meta);
if (ssunlikely(rc == -1))
return sr_oom(r->e);
/* min/max pairs */
memcpy(i->i.p, i->v.s, size);
ss_bufadvance(&i->i, size);
/* extension */
if (qf) {
sdindexamqf *qh = (sdindexamqf*)(i->i.p);
qh->q = qf->qf_qbits;
qh->r = qf->qf_rbits;
qh->entries = qf->qf_entries;
qh->size = qf->qf_table_size;
ss_bufadvance(&i->i, sizeof(sdindexamqf));
memcpy(i->i.p, qf->qf_table, qf->qf_table_size);
ss_bufadvance(&i->i, qf->qf_table_size);
}
ss_buffree(&i->v, r->a);
sdindexheader *h = &i->build;
/* align */
if (size_align) {
h->align = size_align;
memset(i->i.p, 0, size_align);
ss_bufadvance(&i->i, size_align);
}
/* header */
h->offset = offset;
h->id = *id;
h->extension = size_extension;
h->extensions = extensions;
h->crc = ss_crcs(r->crc, h, sizeof(sdindexheader), 0);
memcpy(i->i.p, &i->build, sizeof(sdindexheader));
ss_bufadvance(&i->i, sizeof(sdindexheader));
i->h = sd_indexheader(i);
return 0;
}
int sd_indexcopy(sdindex *i, sr *r, sdindexheader *h)
{
int size = sd_indexsize_ext(h);
int rc = ss_bufensure(&i->i, r->a, size);
if (ssunlikely(rc == -1))
return sr_oom(r->e);
memcpy(i->i.s, (char*)h, size);
ss_bufadvance(&i->i, size);
i->h = sd_indexheader(i);
return 0;
}
int sd_indexcopy(sdindex *i, sr *r, sdindexheader *h)
{
int size = sd_indexsize(h);
int rc = sr_bufensure(&i->i, r->a, size);
if (srunlikely(rc == -1))
return sr_error(r->e, "%s", "memory allocation failed");
memcpy(i->i.s, (char*)h, size);
sr_bufadvance(&i->i, size);
i->h = sd_indexheader(i);
return 0;
}
int sd_indexcopy(sdindex *i, sr *r, sdindexheader *h)
{
int size = sd_indexsize_ext(h);
int rc = ss_bufensure(&i->i, r->a, size);
if (ssunlikely(rc == -1))
return sr_oom(r->e);
char *start = (char*)h - (h->align + h->size + h->extension);
memcpy(i->i.s, start, size);
ss_bufadvance(&i->i, size);
i->h = sd_indexheader(i);
return 0;
}
int sd_indexcommit(sdindex *i, sr *r, sdid *id)
{
int size = sr_bufused(&i->v);
int rc = sr_bufensure(&i->i, r->a, size);
if (srunlikely(rc == -1)) {
sr_error(r->e, "%s", "memory allocation failed");
return -1;
}
memcpy(i->i.p, i->v.s, size);
sr_bufadvance(&i->i, size);
sr_buffree(&i->v, r->a);
i->h = sd_indexheader(i);
i->h->id = *id;
i->h->crc = sr_crcs(r->crc, i->h, sizeof(sdindexheader), 0);
return 0;
}
int sd_indexadd(sdindex *i, sr *r, sdbuild *build, uint64_t offset)
{
int rc = ss_bufensure(&i->i, r->a, sizeof(sdindexpage));
if (ssunlikely(rc == -1))
return sr_oom(r->e);
sdpageheader *ph = sd_buildheader(build);
int size = ph->size + sizeof(sdpageheader);
int sizeorigin = ph->sizeorigin + sizeof(sdpageheader);
/* prepare page header */
sdindexpage *p = (sdindexpage*)i->i.p;
p->offset = offset;
p->offsetindex = ss_bufused(&i->v);
p->lsnmin = ph->lsnmin;
p->lsnmax = ph->lsnmax;
p->size = size;
p->sizeorigin = sizeorigin;
p->sizemin = 0;
p->sizemax = 0;
/* copy keys */
if (ssunlikely(ph->count > 0))
{
char *min;
char *max;
min = sd_buildminkey(build);
min += ss_leb128skip(min);
min += ss_leb128skip(min);
max = sd_buildmaxkey(build);
max += ss_leb128skip(max);
max += ss_leb128skip(max);
switch (r->fmt_storage) {
case SF_SRAW:
rc = sd_indexadd_raw(i, r, p, min, max);
break;
case SF_SKEYVALUE:
rc = sd_indexadd_keyvalue(i, r, build, p, min, max);
break;
}
if (ssunlikely(rc == -1))
return -1;
}
/* update index info */
sdindexheader *h = sd_indexheader(i);
h->count++;
h->size += sizeof(sdindexpage) + p->sizemin + p->sizemax;
h->keys += ph->count;
h->total += size;
h->totalorigin += sizeorigin;
if (build->vmax > h->sizevmax)
h->sizevmax = build->vmax;
if (ph->lsnmin < h->lsnmin)
h->lsnmin = ph->lsnmin;
if (ph->lsnmax > h->lsnmax)
h->lsnmax = ph->lsnmax;
h->dupkeys += ph->countdup;
if (ph->lsnmindup < h->dupmin)
h->dupmin = ph->lsnmindup;
ss_bufadvance(&i->i, sizeof(sdindexpage));
return 0;
}
int sd_indexadd(sdindex *i, sr *r, sdbuild *build)
{
int rc = sr_bufensure(&i->i, r->a, sizeof(sdindexpage));
if (srunlikely(rc == -1)) {
sr_error(r->e, "%s", "memory allocation failed");
return -1;
}
sdpageheader *ph = sd_buildheader(build);
int size = ph->size + sizeof(sdpageheader);
int sizeorigin = ph->sizeorigin + sizeof(sdpageheader);
/* prepare page header.
*
* offset is relative to index:
* m->offset + (index_size) + page->offset
*/
sdindexpage *p = (sdindexpage*)i->i.p;
p->offset = sd_buildoffset(build);
p->offsetindex = sr_bufused(&i->v);
p->size = size;
p->sizeorigin = sizeorigin;
if (srlikely(ph->count > 0)) {
p->sizemin = sr_formatkey_total(r->cmp, sd_buildminkey(build));
p->sizemax = sr_formatkey_total(r->cmp, sd_buildmaxkey(build));
} else {
p->sizemin = 0;
p->sizemax = 0;
}
p->lsnmin = ph->lsnmin;
p->lsnmax = ph->lsnmax;
/* update index info */
sdindexheader *h = sd_indexheader(i);
h->count++;
h->size += sizeof(sdindexpage) + p->sizemin + p->sizemax;
h->keys += ph->count;
h->total += size;
h->totalorigin += sizeorigin;
if (ph->lsnmin < h->lsnmin)
h->lsnmin = ph->lsnmin;
if (ph->lsnmax > h->lsnmax)
h->lsnmax = ph->lsnmax;
h->dupkeys += ph->countdup;
if (ph->lsnmindup < h->dupmin)
h->dupmin = ph->lsnmindup;
sr_bufadvance(&i->i, sizeof(sdindexpage));
if (srunlikely(ph->count == 0))
return 0;
/* copy keys */
rc = sr_bufensure(&i->v, r->a, p->sizemin + p->sizemax);
if (srunlikely(rc == -1)) {
sr_error(r->e, "%s", "memory allocation failed");
return -1;
}
/* reformat key object to exclude value */
rc = sr_formatkey_copy(r->cmp, i->v.p, sd_buildminkey(build));
assert(rc == p->sizemin);
(void)rc;
sr_bufadvance(&i->v, p->sizemin);
rc = sr_formatkey_copy(r->cmp, i->v.p, sd_buildmaxkey(build));
assert(rc == p->sizemax);
(void)rc;
sr_bufadvance(&i->v, p->sizemax);
return 0;
}
