void
extkey_cache_destroy(extkey_cache_t *cache)
{
ham_size_t i;
extkey_t *e, *n;
ham_db_t *db=extkey_cache_get_db(cache);
ham_env_t *env = db_get_env(db);
/*
* make sure that all entries are empty
*/
for (i=0; i<extkey_cache_get_bucketsize(cache); i++) {
e=extkey_cache_get_bucket(cache, i);
while (e) {
#if HAM_DEBUG
/*
* make sure that the extkey-cache is empty - only for in-memory
* databases and DEBUG builds.
*/
if (env_get_rt_flags(env)&HAM_IN_MEMORY_DB)
ham_assert(!"extkey-cache is not empty!", (0));
#endif
n=extkey_get_next(e);
allocator_free(env_get_allocator(env), e);
e=n;
}
}
allocator_free(env_get_allocator(env), cache);
}
ham_status_t
blob_duplicate_get(ham_env_t *env, ham_offset_t table_id,
ham_size_t position, dupe_entry_t *entry)
{
ham_status_t st;
dupe_table_t *table;
ham_page_t *page=0;
st = __get_duplicate_table(&table, &page, env, table_id);
ham_assert(st ? table == NULL : 1, (0));
ham_assert(st ? page == NULL : 1, (0));
if (!table)
return st ? st : HAM_INTERNAL_ERROR;
if (position>=dupe_table_get_count(table))
{
if (!(env_get_rt_flags(env)&HAM_IN_MEMORY_DB))
if (!page)
allocator_free(env_get_allocator(env), table);
return HAM_KEY_NOT_FOUND;
}
memcpy(entry, dupe_table_get_entry(table, position), sizeof(*entry));
if (!(env_get_rt_flags(env)&HAM_IN_MEMORY_DB))
{
if (!page)
allocator_free(env_get_allocator(env), table);
}
return (0);
}
/*
* when the last hit leaf node is split or shrunk, blow it away for all operations!
*
* Also blow away a page when a transaction aborts which has modified this page. We'd rather
* reconstruct our critical statistics then carry the wrong bounds, etc. around.
*
* This is done to prevent the hinter from hinting/pointing at an (by now)
* INVALID btree node later on!
*/
void
stats_page_is_nuked(ham_db_t *db, struct ham_page_t *page, ham_bool_t split)
{
ham_runtime_statistics_dbdata_t *dbdata = db_get_db_perf_data(db);
ham_env_t *env = db_get_env(db);
int i;
for (i = 0; i <= 2; i++)
{
ham_runtime_statistics_opdbdata_t *opstats = db_get_op_perf_data(db, i);
ham_assert(i == HAM_OPERATION_STATS_FIND
|| i == HAM_OPERATION_STATS_INSERT
|| i == HAM_OPERATION_STATS_ERASE, (0));
if (opstats->btree_last_page_addr == page_get_self(page))
{
opstats->btree_last_page_addr = 0;
opstats->btree_last_page_sq_hits = 0;
}
}
if (dbdata->lower_bound_page_address == page_get_self(page))
{
if (dbdata->lower_bound.data)
{
ham_assert(env_get_allocator(env) != 0, (0));
allocator_free(env_get_allocator(env), dbdata->lower_bound.data);
}
memset(&dbdata->lower_bound, 0, sizeof(dbdata->lower_bound));
dbdata->lower_bound_index = 0;
dbdata->lower_bound_page_address = 0;
dbdata->lower_bound_set = HAM_FALSE;
}
if (dbdata->upper_bound_page_address == page_get_self(page))
{
if (dbdata->upper_bound.data)
{
ham_assert(env_get_allocator(env) != 0, (0));
allocator_free(env_get_allocator(env), dbdata->upper_bound.data);
}
memset(&dbdata->upper_bound, 0, sizeof(dbdata->upper_bound));
dbdata->upper_bound_index = 0;
dbdata->upper_bound_page_address = 0;
dbdata->upper_bound_set = HAM_FALSE;
}
}
ham_status_t
extkey_cache_remove(extkey_cache_t *cache, ham_offset_t blobid)
{
ham_db_t *db=extkey_cache_get_db(cache);
ham_env_t *env = db_get_env(db);
ham_size_t h=my_calc_hash(cache, blobid);
extkey_t *e, *prev=0;
e=extkey_cache_get_bucket(cache, h);
while (e) {
if (extkey_get_blobid(e)==blobid)
break;
prev=e;
e=extkey_get_next(e);
}
if (!e)
return (HAM_KEY_NOT_FOUND);
if (prev)
extkey_set_next(prev, extkey_get_next(e));
else
extkey_cache_set_bucket(cache, h, extkey_get_next(e));
extkey_cache_set_usedsize(cache,
extkey_cache_get_usedsize(cache)-extkey_get_size(e));
allocator_free(env_get_allocator(env), e);
return (0);
}
static ham_status_t
_remote_fun_txn_abort(ham_env_t *env, ham_txn_t *txn, ham_u32_t flags)
{
ham_status_t st;
proto_wrapper_t *request, *reply;
request=proto_init_txn_abort_request(txn_get_remote_handle(txn), flags);
st=_perform_request(env, env_get_curl(env), request, &reply);
proto_delete(request);
if (st) {
if (reply)
proto_delete(reply);
return (st);
}
ham_assert(reply!=0, (""));
ham_assert(proto_has_txn_abort_reply(reply), (""));
st=proto_txn_abort_reply_get_status(reply);
if (st==0) {
memset(txn, 0, sizeof(*txn));
allocator_free(env_get_allocator(env), txn);
/* remove the link between env and txn */
env_set_txn(env, 0);
}
proto_delete(reply);
return (st);
}
void
stats_trash_dbdata(ham_db_t *db, ham_runtime_statistics_dbdata_t *dbdata)
{
ham_env_t *env = db_get_env(db);
/* trash the upper/lower bound keys, when set: */
if (dbdata->upper_bound.data) {
ham_assert(env_get_allocator(env) != 0, (0));
allocator_free(env_get_allocator(env), dbdata->upper_bound.data);
}
if (dbdata->lower_bound.data) {
ham_assert(env_get_allocator(env) != 0, (0));
allocator_free(env_get_allocator(env), dbdata->lower_bound.data);
}
memset(dbdata, 0, sizeof(*dbdata));
}
static ham_status_t
__get_duplicate_table(dupe_table_t **table_ref, ham_page_t **page, ham_env_t *env, ham_u64_t table_id)
{
ham_status_t st;
blob_t hdr;
ham_page_t *hdrpage=0;
dupe_table_t *table;
*page = 0;
if (env_get_rt_flags(env)&HAM_IN_MEMORY_DB) {
ham_u8_t *p=(ham_u8_t *)U64_TO_PTR(table_id);
*table_ref = (dupe_table_t *)(p+sizeof(hdr));
return HAM_SUCCESS;
}
*table_ref = 0;
/*
* load the blob header
*/
st=__read_chunk(env, 0, &hdrpage, table_id, (ham_u8_t *)&hdr, sizeof(hdr));
if (st) {
return st;
}
/*
* if the whole table is in a page (and not split between several
* pages), just return a pointer directly in the page
*/
if (page_get_self(hdrpage)+env_get_usable_pagesize(env) >=
table_id+blob_get_size(&hdr))
{
ham_u8_t *p=page_get_raw_payload(hdrpage);
/* yes, table is in the page */
*page=hdrpage;
*table_ref = (dupe_table_t *)
&p[table_id-page_get_self(hdrpage)+sizeof(hdr)];
return HAM_SUCCESS;
}
/*
* otherwise allocate memory for the table
*/
table=allocator_alloc(env_get_allocator(env), (ham_size_t)blob_get_size(&hdr));
if (!table) {
return HAM_OUT_OF_MEMORY;
}
/*
* then read the rest of the blob
*/
st=__read_chunk(env, hdrpage, 0, table_id+sizeof(hdr),
(ham_u8_t *)table, (ham_size_t)blob_get_size(&hdr));
if (st) {
return st;
}
*table_ref = table;
return HAM_SUCCESS;
}
ham_status_t
extkey_cache_insert(extkey_cache_t *cache, ham_offset_t blobid,
ham_size_t size, const ham_u8_t *data)
{
ham_size_t h=my_calc_hash(cache, blobid);
extkey_t *e;
ham_db_t *db=extkey_cache_get_db(cache);
ham_env_t *env = db_get_env(db);
/*
* DEBUG build: make sure that the item is not inserted twice!
*/
#ifdef HAM_DEBUG
e=extkey_cache_get_bucket(cache, h);
while (e) {
ham_assert(extkey_get_blobid(e)!=blobid, (0));
e=extkey_get_next(e);
}
#endif
e=(extkey_t *)allocator_alloc(env_get_allocator(env), SIZEOF_EXTKEY_T+size);
if (!e)
return HAM_OUT_OF_MEMORY;
extkey_set_blobid(e, blobid);
extkey_set_txn_id(e, env_get_txn_id(env));
extkey_set_next(e, extkey_cache_get_bucket(cache, h));
extkey_set_size(e, size);
memcpy(extkey_get_data(e), data, size);
extkey_cache_set_bucket(cache, h, e);
extkey_cache_set_usedsize(cache, extkey_cache_get_usedsize(cache)+size);
return (0);
}
ham_status_t
extkey_cache_purge(extkey_cache_t *cache)
{
ham_size_t i;
extkey_t *e, *n;
ham_env_t *env;
ham_assert(extkey_cache_get_db(cache), (0));
env = db_get_env(extkey_cache_get_db(cache));
/*
* delete all entries which are "too old" (were not
* used in the last EXTKEY_MAX_AGE transactions)
*/
for (i=0; i<extkey_cache_get_bucketsize(cache); i++) {
extkey_t *p=0;
e=extkey_cache_get_bucket(cache, i);
while (e) {
n=extkey_get_next(e);
if (env_get_txn_id(env)-extkey_get_txn_id(e)>EXTKEY_MAX_AGE) {
/* deleted the head element of the list? */
if (!p)
extkey_cache_set_bucket(cache, i, n);
else
extkey_set_next(p, n);
allocator_free(env_get_allocator(env), e);
}
else
p=e;
e=n;
}
}
return (0);
}
static ham_status_t
_remote_fun_txn_begin(ham_env_t *env, ham_db_t *db,
ham_txn_t **txn, ham_u32_t flags)
{
ham_status_t st;
proto_wrapper_t *request, *reply;
request=proto_init_txn_begin_request(db_get_remote_handle(db), flags);
st=_perform_request(env, env_get_curl(env), request, &reply);
proto_delete(request);
if (st) {
if (reply)
proto_delete(reply);
return (st);
}
ham_assert(reply!=0, (""));
ham_assert(proto_has_txn_begin_reply(reply), (""));
st=proto_txn_begin_reply_get_status(reply);
if (st) {
proto_delete(reply);
return (st);
}
*txn=(ham_txn_t *)allocator_alloc(env_get_allocator(env),
sizeof(ham_txn_t));
if (!(*txn))
return (HAM_OUT_OF_MEMORY);
st=txn_begin(*txn, env, flags);
if (st) {
allocator_free(env_get_allocator(env), *txn);
*txn=0;
}
else {
txn_set_remote_handle(*txn,
proto_txn_begin_reply_get_txn_handle(reply));
}
proto_delete(reply);
return (st);
}
extkey_cache_t *
extkey_cache_new(ham_db_t *db)
{
extkey_cache_t *c;
int memsize;
memsize=sizeof(extkey_cache_t)+EXTKEY_CACHE_BUCKETSIZE*sizeof(extkey_t *);
c=(extkey_cache_t *)allocator_calloc(env_get_allocator(db_get_env(db)), memsize);
if (!c) {
// HAM_OUT_OF_MEMORY;
return (0);
}
extkey_cache_set_db(c, db);
extkey_cache_set_bucketsize(c, EXTKEY_CACHE_BUCKETSIZE);
return (c);
}
ham_status_t
blob_free(ham_env_t *env, ham_db_t *db, ham_offset_t blobid, ham_u32_t flags)
{
ham_status_t st;
blob_t hdr;
/*
* in-memory-database: the blobid is actually a pointer to the memory
* buffer, in which the blob is stored
*/
if (env_get_rt_flags(env)&HAM_IN_MEMORY_DB) {
allocator_free(env_get_allocator(env), (void *)U64_TO_PTR(blobid));
return (0);
}
ham_assert(blobid%DB_CHUNKSIZE==0, (0));
/*
* fetch the blob header
*/
st=__read_chunk(env, 0, 0, blobid, (ham_u8_t *)&hdr, sizeof(hdr));
if (st)
return (st);
ham_assert(blob_get_alloc_size(&hdr)%DB_CHUNKSIZE==0, (0));
/*
* sanity check
*/
ham_assert(blob_get_self(&hdr)==blobid,
("invalid blobid %llu != %llu", blob_get_self(&hdr), blobid));
if (blob_get_self(&hdr)!=blobid)
return (HAM_BLOB_NOT_FOUND);
/*
* move the blob to the freelist
*/
st = freel_mark_free(env, db, blobid,
(ham_size_t)blob_get_alloc_size(&hdr), HAM_FALSE);
ham_assert(!st, ("unexpected error, at least not covered in the old code"));
return st;
}
ham_cache_t *
cache_new(ham_env_t *env, ham_size_t max_size)
{
ham_cache_t *cache;
ham_size_t mem, buckets;
buckets=CACHE_BUCKET_SIZE;
ham_assert(buckets, (0));
ham_assert(max_size, (0));
mem=sizeof(ham_cache_t)+(buckets-1)*sizeof(void *);
cache=allocator_calloc(env_get_allocator(env), mem);
if (!cache)
return (0);
cache_set_env(cache, env);
cache_set_capacity(cache, max_size);
cache_set_bucketsize(cache, buckets);
cache->_timeslot = 777; /* a reasonable start value; value is related
* to the increments applied to active cache pages */
return (cache);
}
static ham_status_t
_remote_cursor_create(ham_db_t *db, ham_txn_t *txn, ham_u32_t flags,
ham_cursor_t **cursor)
{
ham_env_t *env=db_get_env(db);
ham_status_t st;
proto_wrapper_t *request, *reply;
request=proto_init_cursor_create_request(db_get_remote_handle(db),
txn ? txn_get_remote_handle(txn) : 0, flags);
st=_perform_request(env, env_get_curl(env), request, &reply);
proto_delete(request);
if (st) {
if (reply)
proto_delete(reply);
return (st);
}
ham_assert(reply!=0, (""));
ham_assert(proto_has_cursor_create_reply(reply)!=0, (""));
st=proto_cursor_create_reply_get_status(reply);
if (st) {
proto_delete(reply);
return (st);
}
*cursor=(ham_cursor_t *)allocator_calloc(env_get_allocator(env),
sizeof(ham_cursor_t));
if (!(*cursor))
return (HAM_OUT_OF_MEMORY);
cursor_set_remote_handle(*cursor,
proto_cursor_create_reply_get_cursor_handle(reply));
proto_delete(reply);
return (st);
}
ham_status_t
btree_create(ham_backend_t **backend_ref, ham_db_t *db, ham_u32_t flags)
{
ham_btree_t *btree;
*backend_ref = 0;
btree = (ham_btree_t *)allocator_calloc(env_get_allocator(db_get_env(db)), sizeof(*btree));
if (!btree)
{
return HAM_OUT_OF_MEMORY;
}
/* initialize the backend */
btree->_db=db;
btree->_fun_create=my_fun_create;
btree->_fun_open=my_fun_open;
btree->_fun_close=my_fun_close;
btree->_fun_flush=my_fun_flush;
btree->_fun_delete=my_fun_delete;
btree->_fun_find=btree_find;
btree->_fun_insert=btree_insert;
btree->_fun_erase=btree_erase;
btree->_fun_enumerate=btree_enumerate;
#ifdef HAM_ENABLE_INTERNAL
btree->_fun_check_integrity=btree_check_integrity;
btree->_fun_calc_keycount_per_page=my_fun_calc_keycount_per_page;
#else
btree->_fun_check_integrity=0;
btree->_fun_calc_keycount_per_page=0;
#endif
btree->_fun_cursor_create = my_fun_cursor_create;
btree->_fun_close_cursors = my_fun_close_cursors;
btree->_fun_uncouple_all_cursors=my_fun_uncouple_all_cursors;
btree->_fun_free_page_extkeys=my_fun_free_page_extkeys;
*backend_ref = (ham_backend_t *)btree;
return HAM_SUCCESS;
}
static ham_status_t
_remote_cursor_clone(ham_cursor_t *src, ham_cursor_t **dest)
{
ham_env_t *env=db_get_env(cursor_get_db(src));
ham_status_t st;
proto_wrapper_t *request, *reply;
request=proto_init_cursor_clone_request(cursor_get_remote_handle(src));
st=_perform_request(env, env_get_curl(env), request, &reply);
proto_delete(request);
if (st) {
if (reply)
proto_delete(reply);
return (st);
}
ham_assert(reply!=0, (""));
ham_assert(proto_has_cursor_clone_reply(reply)!=0, (""));
st=proto_cursor_clone_reply_get_status(reply);
if (st) {
proto_delete(reply);
return (st);
}
*dest=(ham_cursor_t *)allocator_calloc(env_get_allocator(env),
sizeof(ham_cursor_t));
if (!(*dest))
return (HAM_OUT_OF_MEMORY);
cursor_set_remote_handle(*dest,
proto_cursor_clone_reply_get_cursor_handle(reply));
proto_delete(reply);
return (st);
}
ham_status_t
blob_overwrite(ham_env_t *env, ham_db_t *db, ham_offset_t old_blobid,
ham_record_t *record, ham_u32_t flags, ham_offset_t *new_blobid)
{
ham_status_t st;
ham_size_t alloc_size;
blob_t old_hdr;
blob_t new_hdr;
ham_page_t *page;
/*
* PARTIAL WRITE
*
* if offset+partial_size equals the full record size, then we won't
* have any gaps. In this case we just write the full record and ignore
* the partial parameters.
*/
if (flags&HAM_PARTIAL) {
if (record->partial_offset==0
&& record->partial_offset+record->partial_size==record->size)
flags&=~HAM_PARTIAL;
}
/*
* inmemory-databases: free the old blob,
* allocate a new blob (but if both sizes are equal, just overwrite
* the data)
*/
if (env_get_rt_flags(env)&HAM_IN_MEMORY_DB)
{
blob_t *nhdr, *phdr=(blob_t *)U64_TO_PTR(old_blobid);
if (blob_get_size(phdr)==record->size) {
ham_u8_t *p=(ham_u8_t *)phdr;
if (flags&HAM_PARTIAL) {
memmove(p+sizeof(blob_t)+record->partial_offset,
record->data, record->partial_size);
}
else {
memmove(p+sizeof(blob_t), record->data, record->size);
}
*new_blobid=(ham_offset_t)PTR_TO_U64(phdr);
}
else {
st=blob_allocate(env, db, record, flags, new_blobid);
if (st)
return (st);
nhdr=(blob_t *)U64_TO_PTR(*new_blobid);
blob_set_flags(nhdr, blob_get_flags(phdr));
allocator_free(env_get_allocator(env), phdr);
}
return (HAM_SUCCESS);
}
ham_assert(old_blobid%DB_CHUNKSIZE==0, (0));
/*
* blobs are CHUNKSIZE-allocated
*/
alloc_size=sizeof(blob_t)+record->size;
alloc_size += DB_CHUNKSIZE - 1;
alloc_size -= alloc_size % DB_CHUNKSIZE;
/*
* first, read the blob header; if the new blob fits into the
* old blob, we overwrite the old blob (and add the remaining
* space to the freelist, if there is any)
*/
st=__read_chunk(env, 0, &page, old_blobid, (ham_u8_t *)&old_hdr,
sizeof(old_hdr));
if (st)
return (st);
ham_assert(blob_get_alloc_size(&old_hdr)%DB_CHUNKSIZE==0, (0));
/*
* sanity check
*/
ham_verify(blob_get_self(&old_hdr)==old_blobid,
("invalid blobid %llu != %llu", blob_get_self(&old_hdr),
old_blobid));
if (blob_get_self(&old_hdr)!=old_blobid)
return (HAM_BLOB_NOT_FOUND);
/*
* now compare the sizes; does the new data fit in the old allocated
* space?
*/
if (alloc_size<=blob_get_alloc_size(&old_hdr))
{
ham_u8_t *chunk_data[2];
ham_size_t chunk_size[2];
/*
* setup the new blob header
*/
blob_set_self(&new_hdr, blob_get_self(&old_hdr));
blob_set_size(&new_hdr, record->size);
blob_set_flags(&new_hdr, blob_get_flags(&old_hdr));
if (blob_get_alloc_size(&old_hdr)-alloc_size>SMALLEST_CHUNK_SIZE)
blob_set_alloc_size(&new_hdr, alloc_size);
else
blob_set_alloc_size(&new_hdr, blob_get_alloc_size(&old_hdr));
/*
* PARTIAL WRITE
*
* if we have a gap at the beginning, then we have to write the
* blob header and the blob data in two steps; otherwise we can
* write both immediately
*/
if ((flags&HAM_PARTIAL) && (record->partial_offset)) {
chunk_data[0]=(ham_u8_t *)&new_hdr;
chunk_size[0]=sizeof(new_hdr);
st=__write_chunks(env, page, blob_get_self(&new_hdr), HAM_FALSE,
HAM_FALSE, chunk_data, chunk_size, 1);
if (st)
return (st);
chunk_data[0]=record->data;
chunk_size[0]=record->partial_size;
st=__write_chunks(env, page,
blob_get_self(&new_hdr)+sizeof(new_hdr)
+record->partial_offset,
HAM_FALSE, HAM_FALSE, chunk_data, chunk_size, 1);
if (st)
return (st);
}
else {
chunk_data[0]=(ham_u8_t *)&new_hdr;
chunk_size[0]=sizeof(new_hdr);
chunk_data[1]=record->data;
chunk_size[1]=(flags&HAM_PARTIAL)
? record->partial_size
: record->size;
st=__write_chunks(env, page, blob_get_self(&new_hdr), HAM_FALSE,
HAM_FALSE, chunk_data, chunk_size, 2);
if (st)
return (st);
}
/*
* move remaining data to the freelist
*/
if (blob_get_alloc_size(&old_hdr)!=blob_get_alloc_size(&new_hdr)) {
(void)freel_mark_free(env, db,
blob_get_self(&new_hdr)+blob_get_alloc_size(&new_hdr),
(ham_size_t)(blob_get_alloc_size(&old_hdr)-
blob_get_alloc_size(&new_hdr)), HAM_FALSE);
}
/*
* the old rid is the new rid
*/
*new_blobid=blob_get_self(&new_hdr);
return (HAM_SUCCESS);
}
else {
/*
* when the new data is larger, allocate a fresh space for it
* and discard the old;
'overwrite' has become (delete + insert) now.
*/
st=blob_allocate(env, db, record, flags, new_blobid);
if (st)
return (st);
(void)freel_mark_free(env, db, old_blobid,
(ham_size_t)blob_get_alloc_size(&old_hdr), HAM_FALSE);
}
return (HAM_SUCCESS);
}
/**
* Allocate space in storage for and write the content references by 'data'
* (and length 'size') to storage.
*
* Conditions will apply whether the data is written through cache or direct
* to device.
*
* The content is, of course, prefixed by a BLOB header.
*
* Partial writes are handled in this function.
*/
ham_status_t
blob_allocate(ham_env_t *env, ham_db_t *db, ham_record_t *record,
ham_u32_t flags, ham_offset_t *blobid)
{
ham_status_t st;
ham_page_t *page=0;
ham_offset_t addr;
blob_t hdr;
ham_u8_t *chunk_data[2];
ham_size_t alloc_size;
ham_size_t chunk_size[2];
ham_device_t *device=env_get_device(env);
ham_bool_t freshly_created = HAM_FALSE;
*blobid=0;
/*
* PARTIAL WRITE
*
* if offset+partial_size equals the full record size, then we won't
* have any gaps. In this case we just write the full record and ignore
* the partial parameters.
*/
if (flags&HAM_PARTIAL) {
if (record->partial_offset==0
&& record->partial_offset+record->partial_size==record->size)
flags&=~HAM_PARTIAL;
}
/*
* in-memory-database: the blobid is actually a pointer to the memory
* buffer, in which the blob (with the blob-header) is stored
*/
if (env_get_rt_flags(env)&HAM_IN_MEMORY_DB) {
blob_t *hdr;
ham_u8_t *p=(ham_u8_t *)allocator_alloc(env_get_allocator(env),
record->size+sizeof(blob_t));
if (!p) {
return HAM_OUT_OF_MEMORY;
}
/* initialize the header */
hdr=(blob_t *)p;
memset(hdr, 0, sizeof(*hdr));
blob_set_self(hdr, (ham_offset_t)PTR_TO_U64(p));
blob_set_alloc_size(hdr, record->size+sizeof(blob_t));
blob_set_size(hdr, record->size);
/* do we have gaps? if yes, fill them with zeroes */
if (flags&HAM_PARTIAL) {
ham_u8_t *s=p+sizeof(blob_t);
if (record->partial_offset)
memset(s, 0, record->partial_offset);
memcpy(s+record->partial_offset,
record->data, record->partial_size);
if (record->partial_offset+record->partial_size<record->size)
memset(s+record->partial_offset+record->partial_size, 0,
record->size-(record->partial_offset+record->partial_size));
}
else {
memcpy(p+sizeof(blob_t), record->data, record->size);
}
*blobid=(ham_offset_t)PTR_TO_U64(p);
return (0);
}
memset(&hdr, 0, sizeof(hdr));
/*
* blobs are CHUNKSIZE-allocated
*/
alloc_size=sizeof(blob_t)+record->size;
alloc_size += DB_CHUNKSIZE - 1;
alloc_size -= alloc_size % DB_CHUNKSIZE;
/*
* check if we have space in the freelist
*/
st = freel_alloc_area(&addr, env, db, alloc_size);
if (!addr)
{
if (st)
return st;
/*
* if the blob is small AND if logging is disabled: load the page
* through the cache
*/
if (__blob_from_cache(env, alloc_size)) {
st = db_alloc_page(&page, db, PAGE_TYPE_BLOB,
PAGE_IGNORE_FREELIST);
ham_assert(st ? page == NULL : 1, (0));
ham_assert(!st ? page != NULL : 1, (0));
if (st)
return st;
/* blob pages don't have a page header */
page_set_npers_flags(page,
page_get_npers_flags(page)|PAGE_NPERS_NO_HEADER);
addr=page_get_self(page);
/* move the remaining space to the freelist */
(void)freel_mark_free(env, db, addr+alloc_size,
env_get_pagesize(env)-alloc_size, HAM_FALSE);
blob_set_alloc_size(&hdr, alloc_size);
}
else {
/*
* otherwise use direct IO to allocate the space
*/
ham_size_t aligned=alloc_size;
aligned += env_get_pagesize(env) - 1;
aligned -= aligned % env_get_pagesize(env);
st=device->alloc(device, aligned, &addr);
if (st)
return (st);
/* if aligned!=size, and the remaining chunk is large enough:
* move it to the freelist */
{
ham_size_t diff=aligned-alloc_size;
if (diff > SMALLEST_CHUNK_SIZE) {
(void)freel_mark_free(env, db, addr+alloc_size,
diff, HAM_FALSE);
blob_set_alloc_size(&hdr, aligned-diff);
}
else {
blob_set_alloc_size(&hdr, aligned);
}
}
freshly_created = HAM_TRUE;
}
ham_assert(HAM_SUCCESS == freel_check_area_is_allocated(env, db,
addr, alloc_size), (0));
}
else {
ham_assert(!st, (0));
blob_set_alloc_size(&hdr, alloc_size);
}
blob_set_size(&hdr, record->size);
blob_set_self(&hdr, addr);
/*
* PARTIAL WRITE
*
* are there gaps at the beginning? If yes, then we'll fill with zeros
*/
if ((flags&HAM_PARTIAL) && (record->partial_offset)) {
ham_u8_t *ptr;
ham_size_t gapsize=record->partial_offset;
ptr=allocator_calloc(env_get_allocator(env),
gapsize > env_get_pagesize(env)
? env_get_pagesize(env)
: gapsize);
if (!ptr)
return (HAM_OUT_OF_MEMORY);
/*
* first: write the header
*/
chunk_data[0]=(ham_u8_t *)&hdr;
chunk_size[0]=sizeof(hdr);
st=__write_chunks(env, page, addr, HAM_TRUE, freshly_created,
chunk_data, chunk_size, 1);
if (st)
return (st);
addr+=sizeof(hdr);
/* now fill the gap; if the gap is bigger than a pagesize we'll
* split the gap into smaller chunks
*/
while (gapsize>=env_get_pagesize(env)) {
chunk_data[0]=ptr;
chunk_size[0]=env_get_pagesize(env);
st=__write_chunks(env, page, addr, HAM_TRUE,
freshly_created, chunk_data, chunk_size, 1);
if (st)
break;
gapsize-=env_get_pagesize(env);
addr+=env_get_pagesize(env);
}
/* fill the remaining gap */
if (gapsize) {
chunk_data[0]=ptr;
chunk_size[0]=gapsize;
st=__write_chunks(env, page, addr, HAM_TRUE, freshly_created,
chunk_data, chunk_size, 1);
if (st)
return (st);
addr+=gapsize;
}
allocator_free(env_get_allocator(env), ptr);
/* now write the "real" data */
chunk_data[0]=(ham_u8_t *)record->data;
chunk_size[0]=record->partial_size;
st=__write_chunks(env, page, addr, HAM_TRUE, freshly_created,
chunk_data, chunk_size, 1);
if (st)
return (st);
addr+=record->partial_size;
}
else {
/*
* not writing partially: write header and data, then we're done
*/
chunk_data[0]=(ham_u8_t *)&hdr;
chunk_size[0]=sizeof(hdr);
chunk_data[1]=(ham_u8_t *)record->data;
chunk_size[1]=(flags&HAM_PARTIAL)
? record->partial_size
: record->size;
st=__write_chunks(env, page, addr, HAM_TRUE, freshly_created,
chunk_data, chunk_size, 2);
if (st)
return (st);
addr+=sizeof(hdr)+
((flags&HAM_PARTIAL) ? record->partial_size : record->size);
}
/*
* store the blobid; it will be returned to the caller
*/
*blobid=blob_get_self(&hdr);
/*
* PARTIAL WRITES:
*
* if we have gaps at the end of the blob: just append more chunks to
* fill these gaps. Since they can be pretty large we split them into
* smaller chunks if necessary.
*/
if (flags&HAM_PARTIAL) {
if (record->partial_offset+record->partial_size < record->size) {
ham_u8_t *ptr;
ham_size_t gapsize=record->size
- (record->partial_offset+record->partial_size);
/* now fill the gap; if the gap is bigger than a pagesize we'll
* split the gap into smaller chunks
*
* we split this loop in two - the outer loop will allocate the
* memory buffer, thus saving some allocations
*/
while (gapsize>env_get_pagesize(env)) {
ham_u8_t *ptr=allocator_calloc(env_get_allocator(env),
env_get_pagesize(env));
if (!ptr)
return (HAM_OUT_OF_MEMORY);
while (gapsize>env_get_pagesize(env)) {
chunk_data[0]=ptr;
chunk_size[0]=env_get_pagesize(env);
st=__write_chunks(env, page, addr, HAM_TRUE,
freshly_created, chunk_data, chunk_size, 1);
if (st)
break;
gapsize-=env_get_pagesize(env);
addr+=env_get_pagesize(env);
}
allocator_free(env_get_allocator(env), ptr);
if (st)
return (st);
}
/* now write the remainder, which is less than a pagesize */
ham_assert(gapsize<env_get_pagesize(env), (""));
chunk_size[0]=gapsize;
ptr=chunk_data[0]=allocator_calloc(env_get_allocator(env), gapsize);
if (!ptr)
return (HAM_OUT_OF_MEMORY);
st=__write_chunks(env, page, addr, HAM_TRUE, freshly_created,
chunk_data, chunk_size, 1);
allocator_free(env_get_allocator(env), ptr);
if (st)
return (st);
}
}
return (0);
}
void
cache_delete(ham_cache_t *cache)
{
allocator_free(env_get_allocator(cache_get_env(cache)), cache);
}
static ham_status_t
__insert_cursor(ham_btree_t *be, ham_key_t *key, ham_record_t *record,
ham_bt_cursor_t *cursor, insert_hints_t *hints)
{
ham_status_t st;
ham_page_t *root;
ham_db_t *db=be_get_db(be);
ham_env_t *env = db_get_env(db);
insert_scratchpad_t scratchpad;
ham_assert(hints->force_append == HAM_FALSE, (0));
ham_assert(hints->force_prepend == HAM_FALSE, (0));
/*
* initialize the scratchpad
*/
memset(&scratchpad, 0, sizeof(scratchpad));
scratchpad.be=be;
scratchpad.record=record;
scratchpad.cursor=cursor;
/*
* get the root-page...
*/
ham_assert(btree_get_rootpage(be)!=0, ("btree has no root page"));
st=db_fetch_page(&root, db, btree_get_rootpage(be), 0);
ham_assert(st ? root == NULL : 1, (0));
if (st)
return st;
/*
* ... and start the recursion
*/
st=__insert_recursive(root, key, 0, &scratchpad, hints);
/*
* if the root page was split, we have to create a new
* root page.
*/
if (st==SPLIT) {
ham_page_t *newroot;
btree_node_t *node;
/*
* the root-page will be changed...
*/
st=ham_log_add_page_before(root);
if (st)
return (st);
/*
* allocate a new root page
*/
st=db_alloc_page(&newroot, db, PAGE_TYPE_B_ROOT, 0);
ham_assert(st ? newroot == NULL : 1, (0));
if (st)
return (st);
ham_assert(page_get_owner(newroot), (""));
/* clear the node header */
memset(page_get_payload(newroot), 0, sizeof(btree_node_t));
stats_page_is_nuked(db, root, HAM_TRUE);
/*
* insert the pivot element and the ptr_left
*/
node=ham_page_get_btree_node(newroot);
btree_node_set_ptr_left(node, btree_get_rootpage(be));
st=__insert_nosplit(newroot, &scratchpad.key,
scratchpad.rid, scratchpad.record, scratchpad.cursor,
hints);
ham_assert(!(scratchpad.key.flags & HAM_KEY_USER_ALLOC), (0));
scratchpad.cursor=0; /* don't overwrite cursor if __insert_nosplit
is called again */
if (st) {
ham_assert(!(scratchpad.key.flags & HAM_KEY_USER_ALLOC), (0));
if (scratchpad.key.data)
allocator_free(env_get_allocator(env), scratchpad.key.data);
return (st);
}
/*
* set the new root page
*
* !!
* do NOT delete the old root page - it's still in use!
*
* also don't forget to flush the backend - otherwise the header
* page of the database will not contain the updated information.
* The backend is flushed when the database is closed, but if
* recovery is enabled then the flush here is critical.
*/
btree_set_rootpage(be, page_get_self(newroot));
be_set_dirty(be, HAM_TRUE);
be->_fun_flush(be);
/*
* As we re-purpose a page, we will reset its pagecounter
* as well to signal its first use as the new type assigned
* here.
*/
if (env_get_cache(env) && (page_get_type(root)!=PAGE_TYPE_B_INDEX))
cache_update_page_access_counter(root, env_get_cache(env), 0);
page_set_type(root, PAGE_TYPE_B_INDEX);
page_set_dirty(root, env);
page_set_dirty(newroot, env);
/* the root page was modified (btree_set_rootpage) - make sure that
* it's logged */
if (env_get_rt_flags(env)&HAM_ENABLE_RECOVERY) {
st=txn_add_page(env_get_txn(env), env_get_header_page(env),
HAM_TRUE);
if (st)
return (st);
}
}
/*
* release the scratchpad-memory and return to caller
*/
ham_assert(!(scratchpad.key.flags & HAM_KEY_USER_ALLOC), (0));
if (scratchpad.key.data)
allocator_free(env_get_allocator(env), scratchpad.key.data);
return (st);
}
ham_status_t
blob_duplicate_erase(ham_db_t *db, ham_offset_t table_id,
ham_size_t position, ham_u32_t flags, ham_offset_t *new_table_id)
{
ham_status_t st;
ham_record_t rec;
ham_size_t i;
dupe_table_t *table;
ham_offset_t rid;
ham_env_t *env = db_get_env(db);
/* store the public record pointer, otherwise it's destroyed */
ham_size_t rs=db_get_record_allocsize(db);
void *rp=db_get_record_allocdata(db);
db_set_record_allocdata(db, 0);
db_set_record_allocsize(db, 0);
memset(&rec, 0, sizeof(rec));
if (new_table_id)
*new_table_id=table_id;
st=blob_read(db, table_id, &rec, 0);
if (st)
return (st);
/* restore the public record pointer */
db_set_record_allocsize(db, rs);
db_set_record_allocdata(db, rp);
table=(dupe_table_t *)rec.data;
/*
* if BLOB_FREE_ALL_DUPES is set *OR* if the last duplicate is deleted:
* free the whole duplicate table
*/
if (flags&BLOB_FREE_ALL_DUPES
|| (position==0 && dupe_table_get_count(table)==1)) {
for (i=0; i<dupe_table_get_count(table); i++) {
dupe_entry_t *e=dupe_table_get_entry(table, i);
if (!(dupe_entry_get_flags(e)&(KEY_BLOB_SIZE_SMALL
|KEY_BLOB_SIZE_TINY
|KEY_BLOB_SIZE_EMPTY))) {
st=blob_free(env, db, dupe_entry_get_rid(e), 0);
if (st) {
allocator_free(env_get_allocator(env), table);
return (st);
}
}
}
st=blob_free(env, db, table_id, 0); /* [i_a] isn't this superfluous (&
* dangerous), thanks to the
* free_all_dupes loop above??? */
allocator_free(env_get_allocator(env), table);
if (st)
return (st);
if (new_table_id)
*new_table_id=0;
return (0);
}
else {
ham_record_t rec={0};
dupe_entry_t *e=dupe_table_get_entry(table, position);
if (!(dupe_entry_get_flags(e)&(KEY_BLOB_SIZE_SMALL
|KEY_BLOB_SIZE_TINY
|KEY_BLOB_SIZE_EMPTY))) {
st=blob_free(env, db, dupe_entry_get_rid(e), 0);
if (st) {
allocator_free(env_get_allocator(env), table);
return (st);
}
}
memmove(e, e+1,
((dupe_table_get_count(table)-position)-1)*sizeof(dupe_entry_t));
dupe_table_set_count(table, dupe_table_get_count(table)-1);
rec.data=(ham_u8_t *)table;
rec.size=sizeof(dupe_table_t)
+(dupe_table_get_capacity(table)-1)*sizeof(dupe_entry_t);
st=blob_overwrite(env, db, table_id, &rec, 0, &rid);
if (st) {
allocator_free(env_get_allocator(env), table);
return (st);
}
if (new_table_id)
*new_table_id=rid;
}
/*
* return 0 as a rid if the table is empty
*/
if (dupe_table_get_count(table)==0)
if (new_table_id)
*new_table_id=0;
allocator_free(env_get_allocator(env), table);
return (0);
}
ham_status_t
blob_duplicate_insert(ham_db_t *db, ham_offset_t table_id,
ham_record_t *record, ham_size_t position, ham_u32_t flags,
dupe_entry_t *entries, ham_size_t num_entries,
ham_offset_t *rid, ham_size_t *new_position)
{
ham_status_t st=0;
dupe_table_t *table=0;
ham_bool_t alloc_table=0;
ham_bool_t resize=0;
ham_page_t *page=0;
ham_env_t *env=db_get_env(db);
/*
* create a new duplicate table if none existed, and insert
* the first entry
*/
if (!table_id) {
ham_assert(num_entries==2, (""));
/* allocates space for 8 (!) entries */
table=allocator_calloc(env_get_allocator(env),
sizeof(dupe_table_t)+7*sizeof(dupe_entry_t));
if (!table)
return HAM_OUT_OF_MEMORY;
dupe_table_set_capacity(table, 8);
dupe_table_set_count(table, 1);
memcpy(dupe_table_get_entry(table, 0), &entries[0],
sizeof(entries[0]));
/* skip the first entry */
entries++;
num_entries--;
alloc_table=1;
}
else {
/*
* otherwise load the existing table
*/
st=__get_duplicate_table(&table, &page, env, table_id);
ham_assert(st ? table == NULL : 1, (0));
ham_assert(st ? page == NULL : 1, (0));
if (!table)
return st ? st : HAM_INTERNAL_ERROR;
if (!page && !(env_get_rt_flags(env)&HAM_IN_MEMORY_DB))
alloc_table=1;
}
if (page)
if ((st=ham_log_add_page_before(page)))
return (st);
ham_assert(num_entries==1, (""));
/*
* resize the table, if necessary
*/
if (!(flags & HAM_OVERWRITE)
&& dupe_table_get_count(table)+1>=dupe_table_get_capacity(table)) {
dupe_table_t *old=table;
ham_size_t new_cap=dupe_table_get_capacity(table);
if (new_cap < 3*8)
new_cap += 8;
else
new_cap += new_cap/3;
table=allocator_calloc(env_get_allocator(env), sizeof(dupe_table_t)+
(new_cap-1)*sizeof(dupe_entry_t));
if (!table)
return (HAM_OUT_OF_MEMORY);
dupe_table_set_capacity(table, new_cap);
dupe_table_set_count(table, dupe_table_get_count(old));
memcpy(dupe_table_get_entry(table, 0), dupe_table_get_entry(old, 0),
dupe_table_get_count(old)*sizeof(dupe_entry_t));
if (alloc_table)
allocator_free(env_get_allocator(env), old);
alloc_table=1;
resize=1;
}
/*
* insert sorted, unsorted or overwrite the entry at the requested position
*/
if (flags&HAM_OVERWRITE) {
dupe_entry_t *e=dupe_table_get_entry(table, position);
if (!(dupe_entry_get_flags(e)&(KEY_BLOB_SIZE_SMALL
|KEY_BLOB_SIZE_TINY
|KEY_BLOB_SIZE_EMPTY))) {
(void)blob_free(env, db, dupe_entry_get_rid(e), 0);
}
memcpy(dupe_table_get_entry(table, position),
&entries[0], sizeof(entries[0]));
}
else {
if (db_get_rt_flags(db)&HAM_SORT_DUPLICATES) {
if (page)
page_add_ref(page);
position=__get_sorted_position(db, table, record, flags);
if (page)
page_release_ref(page);
if (position<0)
return ((ham_status_t)position);
}
else if (flags&HAM_DUPLICATE_INSERT_BEFORE) {
/* do nothing, insert at the current position */
}
else if (flags&HAM_DUPLICATE_INSERT_AFTER) {
position++;
if (position > dupe_table_get_count(table))
position=dupe_table_get_count(table);
}
else if (flags&HAM_DUPLICATE_INSERT_FIRST) {
position=0;
}
else if (flags&HAM_DUPLICATE_INSERT_LAST) {
position=dupe_table_get_count(table);
}
else {
position=dupe_table_get_count(table);
}
if (position != dupe_table_get_count(table)) {
memmove(dupe_table_get_entry(table, position+1),
dupe_table_get_entry(table, position),
sizeof(entries[0])*(dupe_table_get_count(table)-position));
}
memcpy(dupe_table_get_entry(table, position),
&entries[0], sizeof(entries[0]));
dupe_table_set_count(table, dupe_table_get_count(table)+1);
}
/*
* write the table back to disk and return the blobid of the table
*/
if ((table_id && !page) || resize) {
ham_record_t rec={0};
rec.data=(ham_u8_t *)table;
rec.size=sizeof(dupe_table_t)
+(dupe_table_get_capacity(table)-1)*sizeof(dupe_entry_t);
st=blob_overwrite(env, db, table_id, &rec, 0, rid);
}
else if (!table_id) {
ham_record_t rec={0};
rec.data=(ham_u8_t *)table;
rec.size=sizeof(dupe_table_t)
+(dupe_table_get_capacity(table)-1)*sizeof(dupe_entry_t);
st=blob_allocate(env, db, &rec, 0, rid);
}
else if (table_id && page) {
page_set_dirty(page, env);
}
else {
ham_assert(!"shouldn't be here", (0));
}
if (alloc_table)
allocator_free(env_get_allocator(env), table);
if (new_position)
*new_position=position;
return (st);
}
static ham_status_t
__insert_split(ham_page_t *page, ham_key_t *key,
ham_offset_t rid, insert_scratchpad_t *scratchpad,
insert_hints_t *hints)
{
int cmp;
ham_status_t st;
ham_page_t *newpage, *oldsib;
int_key_t *nbte, *obte;
btree_node_t *nbtp, *obtp, *sbtp;
ham_size_t count, keysize;
ham_db_t *db=page_get_owner(page);
ham_env_t *env = db_get_env(db);
ham_key_t pivotkey, oldkey;
ham_offset_t pivotrid;
ham_u16_t pivot;
ham_bool_t pivot_at_end=HAM_FALSE;
ham_assert(page_get_owner(page), (0));
ham_assert(device_get_env(page_get_device(page))
== db_get_env(page_get_owner(page)), (0));
ham_assert(hints->force_append == HAM_FALSE, (0));
keysize=db_get_keysize(db);
/*
* allocate a new page
*/
hints->cost++;
st=db_alloc_page(&newpage, db, PAGE_TYPE_B_INDEX, 0);
ham_assert(st ? page == NULL : 1, (0));
ham_assert(!st ? page != NULL : 1, (0));
if (st)
return st;
ham_assert(page_get_owner(newpage), (""));
/* clear the node header */
memset(page_get_payload(newpage), 0, sizeof(btree_node_t));
stats_page_is_nuked(db, page, HAM_TRUE);
/*
* move half of the key/rid-tuples to the new page
*
* !! recno: keys are sorted; we do a "lazy split"
*/
nbtp=ham_page_get_btree_node(newpage);
nbte=btree_node_get_key(db, nbtp, 0);
obtp=ham_page_get_btree_node(page);
obte=btree_node_get_key(db, obtp, 0);
count=btree_node_get_count(obtp);
/*
* for databases with sequential access (this includes recno databases):
* do not split in the middle, but at the very end of the page
*
* if this page is the right-most page in the index, and this key is
* inserted at the very end, then we select the same pivot as for
* sequential access
*/
if (db_get_data_access_mode(db)&HAM_DAM_SEQUENTIAL_INSERT)
pivot_at_end=HAM_TRUE;
else if (btree_node_get_right(obtp)==0) {
cmp=key_compare_pub_to_int(db, page, key, btree_node_get_count(obtp)-1);
if (cmp>0)
pivot_at_end=HAM_TRUE;
}
/*
* internal pages set the count of the new page to count-pivot-1 (because
* the pivot element will become ptr_left of the new page).
* by using pivot=count-2 we make sure that at least 1 element will remain
* in the new node.
*/
if (pivot_at_end) {
pivot=count-2;
}
else {
pivot=count/2;
}
/*
* uncouple all cursors
*/
st=bt_uncouple_all_cursors(page, pivot);
if (st)
return (st);
/*
* if we split a leaf, we'll insert the pivot element in the leaf
* page, too. in internal nodes, we don't insert it, but propagate
* it to the parent node only.
*/
if (btree_node_is_leaf(obtp)) {
hints->cost += stats_memmove_cost((db_get_int_key_header_size()+keysize)*(count-pivot));
memcpy((char *)nbte,
((char *)obte)+(db_get_int_key_header_size()+keysize)*pivot,
(db_get_int_key_header_size()+keysize)*(count-pivot));
}
else {
hints->cost += stats_memmove_cost((db_get_int_key_header_size()+keysize)*(count-pivot-1));
memcpy((char *)nbte,
((char *)obte)+(db_get_int_key_header_size()+keysize)*(pivot+1),
(db_get_int_key_header_size()+keysize)*(count-pivot-1));
}
/*
* store the pivot element, we'll need it later to propagate it
* to the parent page
*/
nbte=btree_node_get_key(db, obtp, pivot);
memset(&pivotkey, 0, sizeof(pivotkey));
memset(&oldkey, 0, sizeof(oldkey));
oldkey.data=key_get_key(nbte);
oldkey.size=key_get_size(nbte);
oldkey._flags=key_get_flags(nbte);
st = util_copy_key(db, &oldkey, &pivotkey);
if (st)
{
(void)db_free_page(newpage, DB_MOVE_TO_FREELIST);
goto fail_dramatically;
}
pivotrid=page_get_self(newpage);
/*
* adjust the page count
*/
if (btree_node_is_leaf(obtp)) {
btree_node_set_count(obtp, pivot);
btree_node_set_count(nbtp, count-pivot);
}
else {
btree_node_set_count(obtp, pivot);
btree_node_set_count(nbtp, count-pivot-1);
}
/*
* if we're in an internal page: fix the ptr_left of the new page
* (it points to the ptr of the pivot key)
*/
if (!btree_node_is_leaf(obtp)) {
/*
* nbte still contains the pivot key
*/
btree_node_set_ptr_left(nbtp, key_get_ptr(nbte));
}
/*
* insert the new element
*/
hints->cost++;
cmp=key_compare_pub_to_int(db, page, key, pivot);
if (cmp < -1)
{
st = (ham_status_t)cmp;
goto fail_dramatically;
}
if (cmp>=0)
st=__insert_nosplit(newpage, key, rid,
scratchpad->record, scratchpad->cursor, hints);
else
st=__insert_nosplit(page, key, rid,
scratchpad->record, scratchpad->cursor, hints);
if (st)
{
goto fail_dramatically;
}
scratchpad->cursor=0; /* don't overwrite cursor if __insert_nosplit
is called again */
/*
* fix the double-linked list of pages, and mark the pages as dirty
*/
if (btree_node_get_right(obtp))
{
st=db_fetch_page(&oldsib, db, btree_node_get_right(obtp), 0);
if (st)
goto fail_dramatically;
}
else
{
oldsib=0;
}
if (oldsib) {
st=ham_log_add_page_before(oldsib);
if (st)
goto fail_dramatically;
}
btree_node_set_left (nbtp, page_get_self(page));
btree_node_set_right(nbtp, btree_node_get_right(obtp));
btree_node_set_right(obtp, page_get_self(newpage));
if (oldsib) {
sbtp=ham_page_get_btree_node(oldsib);
btree_node_set_left(sbtp, page_get_self(newpage));
page_set_dirty(oldsib, env);
}
page_set_dirty(newpage, env);
page_set_dirty(page, env);
/*
* propagate the pivot key to the parent page
*/
ham_assert(!(scratchpad->key.flags & HAM_KEY_USER_ALLOC), (0));
if (scratchpad->key.data)
allocator_free(env_get_allocator(env), scratchpad->key.data);
scratchpad->key=pivotkey;
scratchpad->rid=pivotrid;
ham_assert(!(scratchpad->key.flags & HAM_KEY_USER_ALLOC), (0));
return (SPLIT);
fail_dramatically:
ham_assert(!(pivotkey.flags & HAM_KEY_USER_ALLOC), (0));
if (pivotkey.data)
allocator_free(env_get_allocator(env), pivotkey.data);
return st;
}
static ham_status_t
_remote_fun_get_parameters(ham_db_t *db, ham_parameter_t *param)
{
static char filename[1024];
ham_status_t st;
ham_env_t *env=db_get_env(db);
proto_wrapper_t *request, *reply;
ham_size_t i, num_names=0;
ham_u32_t *names;
ham_parameter_t *p;
/* count number of parameters */
p=param;
if (p) {
for (; p->name; p++) {
num_names++;
}
}
/* allocate a memory and copy the parameter names */
names=(ham_u32_t *)allocator_alloc(env_get_allocator(env),
num_names*sizeof(ham_u32_t));
if (!names)
return (HAM_OUT_OF_MEMORY);
p=param;
if (p) {
for (i=0; p->name; p++) {
names[i]=p->name;
i++;
}
}
request=proto_init_db_get_parameters_request(db_get_remote_handle(db),
names, num_names);
st=_perform_request(env, env_get_curl(env), request, &reply);
proto_delete(request);
allocator_free(env_get_allocator(env), names);
if (st) {
if (reply)
proto_delete(reply);
return (st);
}
ham_assert(reply!=0, (""));
ham_assert(proto_has_db_get_parameters_reply(reply), (""));
st=proto_db_get_parameters_reply_get_status(reply);
if (st) {
proto_delete(reply);
return (st);
}
p=param;
while (p && p->name) {
switch (p->name) {
case HAM_PARAM_CACHESIZE:
ham_assert(proto_db_get_parameters_reply_has_cachesize(reply), (""));
p->value=proto_db_get_parameters_reply_get_cachesize(reply);
break;
case HAM_PARAM_PAGESIZE:
ham_assert(proto_db_get_parameters_reply_has_pagesize(reply), (""));
p->value=proto_db_get_parameters_reply_get_pagesize(reply);
break;
case HAM_PARAM_MAX_ENV_DATABASES:
ham_assert(proto_db_get_parameters_reply_has_max_env_databases(reply), (""));
p->value=proto_db_get_parameters_reply_get_max_env_databases(reply);
break;
case HAM_PARAM_GET_FLAGS:
ham_assert(proto_db_get_parameters_reply_has_flags(reply), (""));
p->value=proto_db_get_parameters_reply_get_flags(reply);
break;
case HAM_PARAM_GET_FILEMODE:
ham_assert(proto_db_get_parameters_reply_has_filemode(reply), (""));
p->value=proto_db_get_parameters_reply_get_filemode(reply);
break;
case HAM_PARAM_GET_FILENAME:
ham_assert(proto_db_get_parameters_reply_has_filename(reply), (""));
strncpy(filename, proto_db_get_parameters_reply_get_filename(reply),
sizeof(filename));
p->value=PTR_TO_U64(&filename[0]);
break;
case HAM_PARAM_KEYSIZE:
ham_assert(proto_db_get_parameters_reply_has_keysize(reply), (""));
p->value=proto_db_get_parameters_reply_get_keysize(reply);
break;
case HAM_PARAM_GET_DATABASE_NAME:
ham_assert(proto_db_get_parameters_reply_has_dbname(reply), (""));
p->value=proto_db_get_parameters_reply_get_dbname(reply);
break;
case HAM_PARAM_GET_KEYS_PER_PAGE:
ham_assert(proto_db_get_parameters_reply_has_keys_per_page(reply), (""));
p->value=proto_db_get_parameters_reply_get_keys_per_page(reply);
break;
case HAM_PARAM_GET_DATA_ACCESS_MODE:
ham_assert(proto_db_get_parameters_reply_has_dam(reply), (""));
p->value=proto_db_get_parameters_reply_get_dam(reply);
break;
default:
ham_trace(("unknown parameter %d", (int)p->name));
break;
}
p++;
}
proto_delete(reply);
return (st);
}
void
stats_update_any_bound(ham_db_t *db, struct ham_page_t *page, ham_key_t *key, ham_u32_t find_flags, ham_s32_t slot)
{
ham_status_t st;
ham_runtime_statistics_dbdata_t *dbdata = db_get_db_perf_data(db);
ham_env_t *env = db_get_env(db);
btree_node_t *node = ham_page_get_btree_node(page);
ham_assert(env_get_allocator(env) != 0, (0));
ham_assert(btree_node_is_leaf(node), (0));
if (!btree_node_get_left(node))
{
/* this is the leaf page which carries the lower bound key */
ham_assert(btree_node_get_count(node) == 0 ? !btree_node_get_right(node) : 1, (0));
if (btree_node_get_count(node) == 0)
{
/* range is empty
*
* do not set the lower/upper boundary; otherwise we may trigger
* a key comparison with an empty key, and the comparison function
* could not be fit to handle this.
EDIT: the code should be able to handle that particular situation
as this was tested a while ago. Besides, the settings here
are a signal for the hinter the table is currently
completely empty and no btree traversal whatsoever is
needed before we find, insert or erase.
EDIT #2: custom compare routines may b0rk on the data NULL pointers
(the monster test comparison function does, for example),
so the smarter thing to do here is NOT set the bounds here.
The trouble with that approach is that the hinter no longer
'knows about' an empty table, but is that so bad? An empty
table would constitute only a btree root node anyway, so the
regular traversal would be quick anyhow.
*/
if (dbdata->lower_bound_index != 1
|| dbdata->upper_bound_index != 0)
{
/* only set when not done already */
if (dbdata->lower_bound.data)
allocator_free(env_get_allocator(env), dbdata->lower_bound.data);
if (dbdata->upper_bound.data)
allocator_free(env_get_allocator(env), dbdata->upper_bound.data);
memset(&dbdata->lower_bound, 0, sizeof(dbdata->lower_bound));
memset(&dbdata->upper_bound, 0, sizeof(dbdata->upper_bound));
dbdata->lower_bound_index = 1; /* impossible value for lower bound index */
dbdata->upper_bound_index = 0;
dbdata->lower_bound_page_address = page_get_self(page);
dbdata->upper_bound_page_address = 0; /* page_get_self(page); */
dbdata->lower_bound_set = HAM_TRUE;
dbdata->upper_bound_set = HAM_FALSE; /* cannot be TRUE or subsequent updates for single record carrying tables may fail */
//ham_assert(dbdata->lower_bound.data != NULL, (0));
ham_assert(dbdata->lower_bound_page_address != 0, (0));
}
}
else
{
/*
lower bound key is always located at index [0]
update our key info when either our current data is undefined (startup condition)
or the first key was edited in some way (slot == 0). This 'copy anyway' approach
saves us one costly key comparison.
*/
if (dbdata->lower_bound_index != 0
|| dbdata->lower_bound_page_address != page_get_self(page)
|| slot == 0)
{
page_add_ref(page);
/* only set when not done already */
dbdata->lower_bound_set = HAM_TRUE;
dbdata->lower_bound_index = 0;
dbdata->lower_bound_page_address = page_get_self(page);
if (dbdata->lower_bound.data) {
allocator_free(env_get_allocator(env), dbdata->lower_bound.data);
dbdata->lower_bound.data=0;
dbdata->lower_bound.size=0;
}
st = util_copy_key_int2pub(db,
btree_node_get_key(db, node, dbdata->lower_bound_index),
&dbdata->lower_bound);
if (st)
{
/* panic! is case of failure, just drop the lower bound
* entirely. */
if (dbdata->lower_bound.data)
allocator_free(env_get_allocator(env), dbdata->lower_bound.data);
memset(&dbdata->lower_bound, 0,
sizeof(dbdata->lower_bound));
dbdata->lower_bound_index = 0;
dbdata->lower_bound_page_address = 0;
dbdata->lower_bound_set = HAM_FALSE;
}
else
{
ham_assert(dbdata->lower_bound.data == NULL ?
dbdata->lower_bound.size == 0 :
dbdata->lower_bound.size > 0, (0));
ham_assert(dbdata->lower_bound_page_address != 0, (0));
}
page_release_ref(page);
}
}
}
if (!btree_node_get_right(node))
{
/* this is the leaf page which carries the upper bound key */
ham_assert(btree_node_get_count(node) == 0
? !btree_node_get_left(node)
: 1, (0));
if (btree_node_get_count(node) != 0)
{
/*
* range is non-empty; the other case has already been handled
* above upper bound key is always located at index [size-1]
* update our key info when either our current data is
* undefined (startup condition) or the last key was edited in
* some way (slot == size-1). This 'copy anyway' approach
* saves us one costly key comparison.
*/
if (dbdata->upper_bound_index != btree_node_get_count(node) - 1
|| dbdata->upper_bound_page_address != page_get_self(page)
|| slot == btree_node_get_count(node) - 1)
{
page_add_ref(page);
/* only set when not done already */
dbdata->upper_bound_set = HAM_TRUE;
dbdata->upper_bound_index = btree_node_get_count(node) - 1;
dbdata->upper_bound_page_address = page_get_self(page);
if (dbdata->upper_bound.data) {
allocator_free(env_get_allocator(env), dbdata->upper_bound.data);
dbdata->upper_bound.data=0;
dbdata->upper_bound.size=0;
}
st = util_copy_key_int2pub(db,
btree_node_get_key(db, node, dbdata->upper_bound_index),
&dbdata->upper_bound);
if (st)
{
/* panic! is case of failure, just drop the upper bound
* entirely. */
if (dbdata->upper_bound.data)
allocator_free(env_get_allocator(env), dbdata->upper_bound.data);
memset(&dbdata->upper_bound, 0,
sizeof(dbdata->upper_bound));
dbdata->upper_bound_index = 0;
dbdata->upper_bound_page_address = 0;
dbdata->upper_bound_set = HAM_FALSE;
}
page_release_ref(page);
}
}
}
}
static ham_status_t
_perform_request(ham_env_t *env, CURL *handle, proto_wrapper_t *request,
proto_wrapper_t **reply)
{
CURLcode cc;
long response=0;
char header[128];
curl_buffer_t rbuf={0};
curl_buffer_t wbuf={0};
struct curl_slist *slist=0;
wbuf.alloc=env_get_allocator(env);
*reply=0;
if (!proto_pack(request, wbuf.alloc, &rbuf.packed_data, &rbuf.packed_size))
return (HAM_INTERNAL_ERROR);
sprintf(header, "Content-Length: %u", rbuf.packed_size);
slist=curl_slist_append(slist, header);
slist=curl_slist_append(slist, "Transfer-Encoding:");
slist=curl_slist_append(slist, "Expect:");
#ifdef HAM_DEBUG
SETOPT(handle, CURLOPT_VERBOSE, 1);
#endif
SETOPT(handle, CURLOPT_URL, env_get_filename(env));
SETOPT(handle, CURLOPT_READFUNCTION, __readfunc);
SETOPT(handle, CURLOPT_READDATA, &rbuf);
SETOPT(handle, CURLOPT_UPLOAD, 1);
SETOPT(handle, CURLOPT_PUT, 1);
SETOPT(handle, CURLOPT_WRITEFUNCTION, __writefunc);
SETOPT(handle, CURLOPT_WRITEDATA, &wbuf);
SETOPT(handle, CURLOPT_HTTPHEADER, slist);
cc=curl_easy_perform(handle);
if (rbuf.packed_data)
allocator_free(env_get_allocator(env), rbuf.packed_data);
curl_slist_free_all(slist);
if (cc) {
ham_trace(("network transmission failed: %s", curl_easy_strerror(cc)));
return (HAM_NETWORK_ERROR);
}
cc=curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &response);
if (cc) {
ham_trace(("network transmission failed: %s", curl_easy_strerror(cc)));
return (HAM_NETWORK_ERROR);
}
if (response!=200) {
ham_trace(("server returned error %u", response));
return (HAM_NETWORK_ERROR);
}
*reply=wbuf.wrapper;
return (0);
}
static ham_status_t
_remote_fun_open_db(ham_env_t *env, ham_db_t *db,
ham_u16_t dbname, ham_u32_t flags, const ham_parameter_t *param)
{
ham_status_t st;
proto_wrapper_t *request, *reply;
ham_size_t i=0, num_params=0;
ham_u32_t *names;
ham_u64_t *values;
const ham_parameter_t *p;
/* count number of parameters */
p=param;
if (p) {
for (; p->name; p++) {
num_params++;
}
}
/* allocate a memory and copy the parameter names */
names=(ham_u32_t *)allocator_alloc(env_get_allocator(env),
num_params*sizeof(ham_u32_t));
values=(ham_u64_t *)allocator_alloc(env_get_allocator(env),
num_params*sizeof(ham_u64_t));
if (!names || !values)
return (HAM_OUT_OF_MEMORY);
p=param;
if (p) {
for (; p->name; p++) {
names[i]=p->name;
values[i]=p->value;
i++;
}
}
request=proto_init_env_open_db_request(dbname, flags,
names, values, num_params);
st=_perform_request(env, env_get_curl(env), request, &reply);
proto_delete(request);
allocator_free(env_get_allocator(env), names);
allocator_free(env_get_allocator(env), values);
if (st) {
if (reply)
proto_delete(reply);
return (st);
}
ham_assert(reply!=0, (""));
ham_assert(proto_has_env_open_db_reply(reply), (""));
st=proto_env_open_db_reply_get_status(reply);
if (st) {
proto_delete(reply);
return (st);
}
/*
* store the env pointer in the database
*/
db_set_env(db, env);
db_set_remote_handle(db, proto_env_open_db_reply_get_db_handle(reply));
db_set_rt_flags(db, proto_env_open_db_reply_get_flags(reply));
proto_delete(reply);
/*
* on success: store the open database in the environment's list of
* opened databases
*/
db_set_next(db, env_get_list(env));
env_set_list(env, db);
/*
* initialize the remaining function pointers in ham_db_t
*/
return (db_initialize_remote(db));
}
