Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/mdb_8c_source.html below:

NCBI C++ ToolKit: src/util/lmdb/mdb.c Source File

cacheflush(

*

,

nbytes,

cache);

)))

)))

mdb_sem_wait(sem_t *sem)

((rc = sem_wait(sem)) && (rc = errno) == EINTR) ;

mdb_debug;

mdb_debug_start;

fmt "\n", mdb_func_, __LINE__, __VA_ARGS__)

, arg))

me_maxkey;

, "empty-commit", "abort", "reset", \

"reset-tmp", "fail-begin", "fail-beginchild"}

newpgno,

nflags);

SECURITY_DESCRIPTOR mdb_null_sd;

SECURITY_ATTRIBUTES mdb_all_sa;

mdb_sec_inited;

utf8_to_utf16(

*src,

*dst,

xtra);

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

[MSGSIZE+PADSIZE], *ptr =

;

(

);

FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

, err, 0, ptr, MSGSIZE, (va_list *)

+MSGSIZE);

*func,

*

,

line)

sprintf(

,

,

, line, expr_txt, func);

(

->me_assert_func)

fprintf(stderr,

,

);

*c =

->mv_data;

(

->mv_size > DKBUF_MAXKEYSIZE)

;

(

=0;

<

->mv_size;

++)

ptr += sprintf(ptr,

, *c++);

sprintf(

,

,

->mv_size,

->mv_data);

*

tp[2][2] = {{

,

}, {

,

}};

pgno = mdb_dbg_pgno(mp);

, nkeys, nsize, total = 0;

fprintf(stderr,

,

pgno, mp->mp_pages,

);

fprintf(stderr,

,

fprintf(stderr,

, pgno, mp->

);

fprintf(stderr,

,

, pgno, nkeys,

);

(

=0;

<nkeys;

++) {

fprintf(stderr,

,

, nsize,

(&

));

fprintf(stderr,

,

,

(node),

nsize +=

(

);

nsize +=

(

);

fprintf(stderr,

,

, nsize,

(&

), mdb_leafnode_type(node));

total =

(total);

fprintf(stderr,

,

printf(

);

printf(

);

mdb_audit(

*txn)

(j=0; j<

(mp); j++) {

fprintf(stderr,

,

(dcmp ==

&&

->mv_size ==

(

))

dcmp(

,

);

psize =

->me_psize, sz = psize, off;

->me_dpages = ret->mp_next;

memset((

*)ret + off, 0, psize);

mp->mp_next =

->me_dpages;

->me_dpages = mp;

,

= dl[0].

;

(

= 1;

<=

;

++) {

pgno = mp->mp_pgno;

(x <= dl[0].mid && dl[x].mid == pgno) {

(mp != dl[x].mptr) {

(; mc; mc=mc->

) {

(j=0; j<m3->

; j++) {

mp = m3->

[j];

((mp->

& Mask) == pflags)

((dp->

& Mask) == pflags && level <= 1)

, j, need;

num = sl[0];

(

=1;

<=num;

++) {

(

=dl[0].mid;

&& need;

--) {

dp = dl[

].

;

(j <= tx2->mt_spill_pgs[0] && tx2->

[j] == pn) {

mr =

[

].mr_txnid;

mid.

= mp->mp_pgno;

{ Paranoid = 1, Max_retries = 500 };

{ Paranoid = 0, Max_retries = INT_MAX

};

rc, retry = num * 60;

, j, mop_len = mop ? mop[0] : 0, n2 = num-1;

(mop[

-n2] == pgno+n2)

}

(--

> n2);

oldest =

->me_pgoldest;

.mv_size =

(

);

(Paranoid && retry < 0 && mop_len)

(oldest <=

) {

->me_pgoldest = oldest;

(oldest <=

)

->me_pgoldest = oldest;

(oldest <=

)

mop =

->me_pghead;

((

,

(j =

; j; j--)

(pgno + num >=

->me_maxpg) {

(

);

mop[0] = mop_len -= num;

(j =

-num; j < mop_len; )

mop[++j] = mop[++

];

{ Align =

(

) };

upper = src->mp_upper, lower = src->mp_lower,

= upper-lower;

upper = (upper +

) & -Align;

memcpy(dst, src, (lower +

+ (Align-1)) & -Align);

memcpy((

*)((

*)dst+upper), (

*)((

*)src+upper),

memcpy(dst, src, psize -

);

pgno = mp->mp_pgno, pn = pgno << 1;

(tx2 = txn; tx2; tx2=tx2->

) {

(x <= tx2->mt_spill_pgs[0] && tx2->

[x] == pn) {

memcpy(np, mp, num *

->me_psize);

mp->mp_pgno, pgno));

(x <= dl[0].mid && dl[x].mid == pgno) {

(mp != dl[x].mptr) {

(; m2; m2=m2->

) {

(; m2; m2=m2->

) {

(m2 == mc)

;

(fsync(

->me_fd))

(; mc; mc =

->mc_next) {

(mc = cursors[

]; mc; mc =

) {

cursors[

] =

;

h = OpenProcess(

->me_pidquery,

, pid);

() != ERROR_INVALID_PARAMETER;

ret = WaitForSingleObject(h, 0) != 0;

flock lock_info;

memset(&lock_info, 0,

(lock_info));

lock_info.l_type = F_WRLCK;

lock_info.l_start = pid;

lock_info.l_len = 1;

((rc = fcntl(

->me_lfd, op, &lock_info)) == 0) {

(op == F_GETLK && lock_info.l_type != F_UNLCK)

}

((rc =

()) == EINTR) {

rc, new_notls = 0;

pthread_getspecific(

->me_txkey);

(

->mr_pid !=

->me_pid ||

->mr_txnid != (

)-1)

(!

->me_live_reader) {

->me_live_reader = 1;

= ti->mti_numreaders;

(

=0;

<

;

++)

(

==

->me_maxreaders) {

ti->mti_numreaders = ++

;

->me_close_readers =

;

(!new_notls && (rc=pthread_setspecific(

->me_txkey,

))) {

->mr_txnid = ti->mti_txnid;

(

->mr_txnid != ti->mti_txnid);

(txn->

== mdb_debug_start)

memcpy(txn->

,

->me_dbiseqs,

->me_maxdbs *

(

));

x =

->me_dbflags[

];

(

);

((

,

(

*)txn, (

*)txn->

, txn->mt_dbs[

].md_root));

rc,

, tsize;

txn =

->me_txn0;

(

->me_pghead) {

(

->me_pghead)

(txn !=

->me_txn0)

((

,

(

*) txn, (

*)

, txn->mt_dbs[

].md_root));

(!txn)

;

(tdbflags[

] &

) {

*ptr =

->me_dbxs[

].md_name.mv_data;

->me_dbxs[

].md_name.mv_data =

;

->me_dbxs[

].md_name.mv_size = 0;

->me_dbflags[

] = 0;

->me_dbiseqs[

]++;

(keep &&

->me_numdbs <

)

->me_numdbs =

;

((

,

->me_pglast = 0;

->me_pgstate = ((

*)txn)->mnt_pgstate;

rc, maxfree_1pg =

->me_maxfree_1pg, more = 1;

pglast = 0, head_id = 0;

freecnt = 0, *free_pgs, *mop;

head_room = 0, total_room = 0, mop_len, clean_limit;

(

->me_pghead) {

(x=1; x<=dl[0].

; x++)

(dl[x].mid == mp->mp_pgno)

(y=1; dl[y].

&& y <= dl[0].

; y++);

(y <= dl[0].mid) {

(!dl[y].mptr && y <= dl[0].mid) y++;

(y > dl[0].mid)

;

? SSIZE_MAX : maxfree_1pg;

pglast = head_id = *(

*)

.mv_data;

total_room = head_room = 0;

(freecnt < txn->mt_free_pgs[0]) {

freecnt = free_pgs[0];

}

(freecnt < free_pgs[0]);

memcpy(

.mv_data, free_pgs,

.mv_size);

= free_pgs[0];

((

,

((

, free_pgs[

]));

mop =

->me_pghead;

(total_room >= mop_len) {

(total_room == mop_len || --more < 0)

}

(head_room >= maxfree_1pg && head_id > 1) {

total_room -= head_room;

head_room = mop_len - total_room;

(head_room > maxfree_1pg && head_id > 1) {

head_room /= head_id;

head_room += maxfree_1pg - head_room % (maxfree_1pg + 1);

}

(head_room < 0) {

.mv_size =

(head_id);

.mv_data = &head_id;

.mv_size = (head_room + 1) *

(

);

j = head_room > clean_limit ? head_room : 0;

total_room += head_room;

mop =

->me_pghead;

loose[ ++

] = mp->mp_pgno;

(

> mop_len) {

(rc || !(mop_len -=

))

psize =

->me_psize, j;

, pagecount = dl[0].

, rc;

= 0, pos = 0;

wpos = 0, wsize = 0, wres;

next_pos = 1;

(++

<= pagecount) {

dp = dl[

].

;

(++

<= pagecount) {

dp = dl[

].

;

pgno = dl[

].

;

((

, pgno));

memset(&ov, 0,

(ov));

ov.Offset = pos & 0xffffffff;

ov.OffsetHigh = pos >> 16 >> 16;

(!WriteFile(

->me_fd, dp,

,

, &ov)) {

((

, rc));

wres = pwritev(

->me_fd, iov,

, wpos);

wres = pwrite(

->me_fd, iov[0].iov_base, wsize, wpos);

wres = writev(

->me_fd, iov,

);

(wres != wsize) {

(

);

((

, pgno));

next_pos = pos +

;

iov[

].iov_len =

;

iov[

].iov_base = (

*)dp;

(

= keep; ++

<= pagecount; ) {

dp = dl[

].

;

dl[j].

= dp->mp_pgno;

, end_mode;

(

);

x, y,

, ps_len;

((pspill = parent->

) && (ps_len = pspill[0])) {

pspill[0] = (

)-1;

(

=0,

=src[0].mid; ++

<=

; ) {

(pn > pspill[x])

(pn == pspill[x]) {

(x=y; ++x <= ps_len; )

(!(pspill[x] & 1))

pspill[++y] = pspill[x];

(y <= dst[0].mid && dst[y].mid == pn) {

(y < dst[0].mid) {

(

= x; y &&

; y--) {

(yp < dst[

].mid)

(yp == dst[

].mid) {

(

=

; y; dst[

--] = src[y--]) {

(yp < dst[x].mid)

dst[

--] = dst[x--];

(yp == dst[x].mid)

(dst[x--].mptr);

(txn !=

->me_txn) {

(

);

((

,

{ Size =

(pbuf) };

(

=off=0;

<

;

++, off += meta->mm_psize) {

memset(&ov, 0,

(ov));

rc = ReadFile(

->me_fd, &pbuf, Size, &

, &ov) ? (

)

: -1;

(rc == -1 &&

() == ERROR_HANDLE_EOF)

rc = pread(

->me_fd, &pbuf, Size, off);

(rc == 0 && off == 0)

((

, p->mp_pgno));

(

);

((

,

meta->mm_psize =

->me_psize;

meta->mm_flags =

->me_flags & 0xffff;

memset(&ov, 0,

(ov));

(

);

psize =

->me_psize;

q = (

*)((

*)p + psize);

rc,

, toggle;

((

,

mp =

->me_metas[toggle];

mapsize =

->me_metas[toggle ^ 1]->mm_mapsize;

(mapsize < env->me_mapsize)

mapsize =

->me_mapsize;

__sync_synchronize();

meta_size =

->me_psize;

= (ptr -

->me_map) & (

->me_os_psize - 1);

ptr = (

*)&meta + off;

off += (

*)mp -

->me_map;

memset(&ov, 0,

(ov));

(!WriteFile(mfd, ptr,

, (

*)&rc, &ov))

rc = pwrite(mfd, ptr,

, off);

rc = rc < 0 ?

() : EIO;

(

);

memset(&ov, 0,

(ov));

WriteFile(

->me_fd, ptr,

,

, &ov);

= pwrite(

->me_fd, ptr,

, off);

e->me_rmutex = SEM_FAILED;

e->me_wmutex = SEM_FAILED;

=

->me_flags;

LONG sizelo, sizehi;

msize =

->me_mapsize;

sizelo = msize & 0xffffffff;

sizehi = msize >> 16 >> 16;

|| !SetEndOfFile(

->me_fd)

|| SetFilePointer(

->me_fd, 0,

, 0) != 0))

PAGE_READWRITE : PAGE_READONLY,

sizehi, sizelo,

);

FILE_MAP_WRITE : FILE_MAP_READ,

0, 0, msize,

);

= PROT_READ;

(ftruncate(

->me_fd,

->me_mapsize) < 0)

(

->me_map == MAP_FAILED) {

madvise(

->me_map,

->me_mapsize, MADV_RANDOM);

posix_madvise(

->me_map,

->me_mapsize, POSIX_MADV_RANDOM);

->me_metas[1] = (

*)((

*)

->me_metas[0] +

->me_psize);

(

->me_map) {

munmap(

->me_map,

->me_mapsize);

(

->me_psize)

->me_maxpg =

->me_mapsize /

->me_psize;

(

->me_map || readers < 1)

->me_maxreaders = readers;

(!

|| !readers)

*readers =

->me_maxreaders;

LARGE_INTEGER fsize;

(!GetFileSizeEx(fd, &fsize))

*

= fsize.QuadPart;

(fstat(fd, &

))

utf8_to_utf16(path, fname, no_suffix ? 0 :

);

fname->

= strlen(path);

fname->

= (

*) path;

strcpy(fname->

, path);

acc, share, disp, attrs;

acc = GENERIC_READ|GENERIC_WRITE;

share = FILE_SHARE_READ|FILE_SHARE_WRITE;

attrs = FILE_ATTRIBUTE_NORMAL;

disp = OPEN_EXISTING;

acc = GENERIC_WRITE;

disp = OPEN_EXISTING;

attrs = FILE_ATTRIBUTE_NORMAL|FILE_FLAG_WRITE_THROUGH;

acc = GENERIC_WRITE;

attrs = FILE_FLAG_NO_BUFFERING|FILE_FLAG_WRITE_THROUGH;

fd = CreateFileW(fname->

, acc, share,

, disp, attrs,

);

(void) fcntl(fd, F_SETFD,

| FD_CLOEXEC);

(void) fcntl(fd, F_NOCACHE, 1);

((

= fcntl(fd, F_GETFL)) != -1)

(void) fcntl(fd, F_SETFL,

| O_DIRECT);

=

->me_flags;

, newenv = 0, rc;

((rc & 0xff) > 5)

->me_pidquery = MDB_PROCESS_QUERY_LIMITED_INFORMATION;

->me_pidquery = PROCESS_QUERY_INFORMATION;

fstatfs(

->me_fd, &

);

(

.f_type == 0xEF53) {

(uts.release[0] <

) {

(!

(uts.release,

, 7)) {

= atoi(uts.release+7);

}

(!

(uts.release,

, 7)) {

= atoi(uts.release+7);

}

(uts.release[0] ==

) {

= atoi(uts.release+2);

= atoi(uts.release+4);

}

(

== 2) {

= atoi(uts.release+4);

(

);

->me_psize =

->me_os_psize;

memset(&meta, 0,

(meta));

->me_psize = meta.mm_psize;

(!

->me_mapsize) {

minsize = (meta.

+ 1) * meta.mm_psize;

(

->me_mapsize < minsize)

->me_mapsize = minsize;

->me_maxpg =

->me_mapsize /

->me_psize;

((

,

(reader->mr_pid == getpid())

pthread_key_t mdb_tls_keys[MAX_TLS_KEYS];

mdb_tls_nkeys;

NTAPI mdb_tls_callback(PVOID module,

reason, PVOID ptr)

DLL_PROCESS_ATTACH:

;

DLL_THREAD_ATTACH:

;

DLL_THREAD_DETACH:

(

=0;

<mdb_tls_nkeys;

++) {

*

= pthread_getspecific(mdb_tls_keys[

]);

DLL_PROCESS_DETACH:

;

PIMAGE_TLS_CALLBACK mdb_tls_cbp __attribute__((section (

))) = mdb_tls_callback;

PIMAGE_TLS_CALLBACK mdb_tls_cbp __attribute__((section (

))) = mdb_tls_callback;

)

)

)

PIMAGE_TLS_CALLBACK mdb_tls_cbp;

PIMAGE_TLS_CALLBACK mdb_tls_cbp = mdb_tls_callback;

)

)

)

PIMAGE_TLS_CALLBACK mdb_tls_cbp = mdb_tls_callback;

memset(&ov, 0,

(ov));

(!LockFileEx(

->me_lfd, 0, 0, 1, 0, &ov)) {

UnlockFile(

->me_lfd, 0, 0, 1, 0);

flock lock_info;

memset((

*)&lock_info, 0,

(lock_info));

lock_info.l_type = F_RDLCK;

lock_info.l_start = 0;

lock_info.l_len = 1;

((rc = fcntl(

->me_lfd, F_SETLK, &lock_info)) &&

*excl = rc ? -1 : 0;

(LockFile(

->me_lfd, 0, 0, 1, 0)) {

memset(&ov, 0,

(ov));

(LockFileEx(

->me_lfd, 0, 0, 1, 0, &ov)) {

flock lock_info;

memset((

*)&lock_info, 0,

(lock_info));

lock_info.l_type = F_WRLCK;

lock_info.l_start = 0;

lock_info.l_len = 1;

((rc = fcntl(

->me_lfd, F_SETLK, &lock_info)) &&

lock_info.l_type = F_RDLCK;

((rc = fcntl(

->me_lfd, F_SETLKW, &lock_info)) &&

mdb_hash_t;

mdb_hash_val(

*

, mdb_hash_t hval)

*s = (

*)

->mv_data;

*end = s +

->mv_size;

hval ^= (mdb_hash_t)*s++;

hval += (hval << 1) + (hval << 4) + (hval << 5) +

(hval << 7) + (hval << 8) + (hval << 40);

mdb_a85[]=

;

mdb_pack85(

,

*

)

(

=0;

<5;

++) {

*

++ = mdb_a85[

% 85];

mdb_hash_t h = mdb_hash_val(

, MDB_HASH_INIT);

mdb_pack85(h, encbuf);

mdb_pack85(h>>32, encbuf+5);

(mdb_tls_nkeys >= MAX_TLS_KEYS) {

mdb_tls_keys[mdb_tls_nkeys++] =

->me_txkey;

(

== -1)

fail_errno;

(size < rsize && *excl > 0) {

(SetFilePointer(

->me_lfd, rsize,

, FILE_BEGIN) != (

)rsize

|| !SetEndOfFile(

->me_lfd))

(ftruncate(

->me_lfd, rsize) != 0)

fail_errno;

mh = CreateFileMapping(

->me_lfd,

, PAGE_READWRITE,

(!mh)

fail_errno;

->me_txns = MapViewOfFileEx(mh, FILE_MAP_WRITE, 0, 0, rsize,

);

(!

->me_txns)

fail_errno;

*m = mmap(

, rsize, PROT_READ|PROT_WRITE, MAP_SHARED,

(m == MAP_FAILED)

fail_errno;

BY_HANDLE_FILE_INFORMATION stbuf;

(!mdb_sec_inited) {

InitializeSecurityDescriptor(&mdb_null_sd,

SECURITY_DESCRIPTOR_REVISION);

SetSecurityDescriptorDacl(&mdb_null_sd,

, 0,

);

mdb_all_sa.nLength =

(SECURITY_ATTRIBUTES);

mdb_all_sa.bInheritHandle =

;

mdb_all_sa.lpSecurityDescriptor = &mdb_null_sd;

(!GetFileInformationByHandle(

->me_lfd, &stbuf))

fail_errno;

idbuf.volume = stbuf.dwVolumeSerialNumber;

idbuf.nhigh = stbuf.nFileIndexHigh;

idbuf.nlow = stbuf.nFileIndexLow;

.mv_data = &idbuf;

.mv_size =

(idbuf);

mdb_hash_enc(&

, encbuf);

sprintf(

->me_txns->mti_rmname,

, encbuf);

sprintf(

->me_txns->mti_wmname,

, encbuf);

->me_rmutex = CreateMutexA(&mdb_all_sa,

,

->me_txns->mti_rmname);

(!

->me_rmutex)

fail_errno;

->me_wmutex = CreateMutexA(&mdb_all_sa,

,

->me_txns->mti_wmname);

(!

->me_wmutex)

fail_errno;

(fstat(

->me_lfd, &stbuf))

fail_errno;

idbuf.dev = stbuf.st_dev;

idbuf.ino = stbuf.st_ino;

.mv_data = &idbuf;

.mv_size =

(idbuf);

mdb_hash_enc(&

, encbuf);

sprintf(

->me_txns->mti_rmname,

, encbuf);

sprintf(

->me_txns->mti_wmname,

, encbuf);

sem_unlink(

->me_txns->mti_rmname);

sem_unlink(

->me_txns->mti_wmname);

->me_rmutex = sem_open(

->me_txns->mti_rmname,

O_CREAT|O_EXCL,

, 1);

(

->me_rmutex == SEM_FAILED)

fail_errno;

->me_wmutex = sem_open(

->me_txns->mti_wmname,

O_CREAT|O_EXCL,

, 1);

(

->me_wmutex == SEM_FAILED)

fail_errno;

pthread_mutexattr_t mattr;

memset(

->me_txns->mti_rmutex, 0,

(*

->me_txns->mti_rmutex));

memset(

->me_txns->mti_wmutex, 0,

(*

->me_txns->mti_wmutex));

((rc = pthread_mutexattr_init(&mattr)))

rc = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);

(!rc) rc = pthread_mutexattr_setrobust(&mattr, PTHREAD_MUTEX_ROBUST);

(!rc) rc = pthread_mutex_init(

->me_txns->mti_rmutex, &mattr);

(!rc) rc = pthread_mutex_init(

->me_txns->mti_wmutex, &mattr);

pthread_mutexattr_destroy(&mattr);

->me_txns->mti_txnid = 0;

->me_txns->mti_numreaders = 0;

(

);

((

,

(rc && rc != EACCES && rc != EAGAIN) {

->me_rmutex = OpenMutexA(SYNCHRONIZE,

,

->me_txns->mti_rmname);

(!

->me_rmutex)

fail_errno;

->me_wmutex = OpenMutexA(SYNCHRONIZE,

,

->me_txns->mti_wmname);

(!

->me_wmutex)

fail_errno;

->me_rmutex = sem_open(

->me_txns->mti_rmname, 0);

(

->me_rmutex == SEM_FAILED)

fail_errno;

->me_wmutex = sem_open(

->me_txns->mti_wmname, 0);

(

->me_wmutex == SEM_FAILED)

fail_errno;

->me_dbiseqs =

(

->me_maxdbs,

(

));

(!(

->me_dbxs &&

->me_path &&

->me_dbflags &&

->me_dbiseqs)) {

((

, (

*)

));

->me_txn0 = txn;

(

->me_dbxs) {

(

->me_dbxs[

].md_name.mv_data);

pthread_key_delete(

->me_txkey);

(

=0;

<mdb_tls_nkeys;

++)

(mdb_tls_keys[

] ==

->me_txkey) {

mdb_tls_keys[

] = mdb_tls_keys[mdb_tls_nkeys-1];

(

->me_map) {

munmap(

->me_map,

->me_mapsize);

(

->me_txns) {

(

=

->me_close_readers; --

>= 0; )

(

->me_txns->mti_readers[

].mr_pid == pid)

->me_txns->mti_readers[

].mr_pid = 0;

(

->me_rmutex) {

CloseHandle(

->me_rmutex);

(

->me_wmutex) CloseHandle(

->me_wmutex);

(

->me_rmutex != SEM_FAILED) {

sem_close(

->me_rmutex);

(

->me_wmutex != SEM_FAILED)

sem_close(

->me_wmutex);

sem_unlink(

->me_txns->mti_rmname);

sem_unlink(

->me_txns->mti_wmname);

UnlockFile(

->me_lfd, 0, 0, 1, 0);

((dp =

->me_dpages) !=

) {

->me_dpages = dp->mp_next;

(*(

*)

->mv_data < *(

*)

->mv_data) ? -1 :

*(

*)

->mv_data > *(

*)

->mv_data;

(*(

*)

->mv_data < *(

*)

->mv_data) ? -1 :

*(

*)

->mv_data > *(

*)

->mv_data;

*u, *c;

u = (

*) ((

*)

->mv_data +

->mv_size);

c = (

*) ((

*)

->mv_data +

->mv_size);

}

(!x && u > (

*)

->mv_data);

*u, *c, *end;

end = (

*) ((

*)

->mv_data +

->mv_size);

u = (

*)

->mv_data;

c = (

*)

->mv_data;

}

(!x && u < end);

diff = memcmp(

->mv_data,

->mv_data,

);

diff ? diff : len_diff<0 ? -1 : len_diff;

*p1, *p2, *p1_lim;

p1_lim = (

*)

->mv_data;

p1 = (

*)

->mv_data +

->mv_size;

p2 = (

*)

->mv_data +

->mv_size;

(p1 > p1_lim) {

diff = *--p1 - *--p2;

len_diff<0 ? -1 : len_diff;

= 0, nkeys;

((

,

nkeys,

(mp) ?

:

,

(mp) ?

:

,

(

(mp, 1)->mn_ksize ==

(

))

(low <= high) {

= (low + high) >> 1;

rc =

(

, &nodekey);

((

,

,

(&nodekey), rc));

(low <= high) {

= (low + high) >> 1;

rc =

(

, &nodekey);

((

,

,

(&nodekey), rc));

((

,

*exactp = (rc == 0 && nkeys > 0);

((

,

((

, mp->mp_pgno,

(mc), (

*) mc));

(x <= tx2->mt_spill_pgs[0] && tx2->

[x] == pn) {

(x <= dl[0].mid && dl[x].mid == pgno) {

(pgno < txn->mt_next_pgno) {

((

, pgno));

((

, mp->mp_pgno,

(mp)));

((

,

((

, mp->mp_pgno,

(

);

(

);

(!mc->

[0] || mc->

[0]->mp_pgno != root)

((

,

x = 0, ovpages = mp->mp_pages;

((

, pg, ovpages));

(

->me_pghead &&

(ix = dl[x]; ix.

!= mp; ix = iy) {

j = ++(dl[0].

);

mop =

->me_pghead;

j = mop[0] + ovpages;

(

= mop[0];

&& mop[

] < pg;

--)

mop[j--] = mop[

];

((

, pgno));

((

,

((

,

move_right ?

:

));

((

,

move_right ?

:

, mc->

[mc->

]));

((

,

mdb_dbg_pgno(mp), (

*) mc));

(

);

((

,

((

,

mdb_dbg_pgno(mp), (

*) mc));

(

);

((

,

(

->mv_size == 0)

nkeys =

(mp);

(exactp !=

&& !*exactp) {

(

);

rc = dcmp(

, &olddata);

(!nkeys || mc->

[mc->

] >= nkeys) {

((

, op));

)

xdata, *rdata, dkey, olddata;

do_sub = 0, insert_key, insert_data;

mcount = 0, dcount = 0, nospill;

nflags;

dcount =

[1].mv_size;

[1].mv_size = 0;

((

,

(

);

insert_key = insert_data = rc;

->mp_pad =

->mv_size;

(

->mv_size != ksize)

memcpy(ptr,

->mv_data, ksize);

dtop = 1;

(!dcmp(

, &olddata)) {

->mp_pad =

->mv_size;

fp_flags =

->mp_flags;

.md_flags = 0;

.md_depth = 1;

.md_branch_pages = 0;

.md_leaf_pages = 1;

.md_overflow_pages = 0;

.md_root = mp->mp_pgno;

mp->mp_lower =

->mp_lower;

mp->mp_upper =

->mp_upper +

;

level, ovpages, dpages =

(

->mv_size,

->me_psize);

memcpy(&pg, olddata.

,

(pg));

ovpages = omp->mp_pages;

(ovpages >= dpages) {

sz = (size_t)

->me_psize * ovpages, off;

memcpy((

*)((

*)np + off),

(

*)((

*)omp + off), sz - off);

memcpy(np, omp, sz);

}

(

->mv_size == olddata.

) {

(m3->

[

] >= mc->

[

] && insert_key) {

xflags, new_dupdata;

(m2->

[

] == mp) {

}

(!insert_key) {

[1].mv_size = mcount;

(mcount < dcount) {

[0].mv_data = (

*)

[0].mv_data +

[0].mv_size;

insert_key = insert_data = 0;

((

,

(sz >

->me_nodemax) {

(sz >

->me_nodemax) {

sz +

(

);

((

,

(mp) ?

:

,

mdb_dbg_pgno(mp), indx,

?

->mv_size : 0,

*ptr =

(mp, indx, ksize);

(ptr+ksize, ptr, dif*ksize);

memcpy(ptr,

->mv_data, ksize);

mp->mp_lower +=

(

);

mp->mp_upper -= ksize -

(

);

node_size +=

->mv_size;

node_size +=

(

);

((

,

->mv_size, node_size+

->mv_size));

node_size =

(node_size +

(

));

((

)node_size > room)

((

, ofp->mp_pgno));

node_size +=

->mv_size;

node_size =

(node_size);

((

)node_size > room)

ofs = mp->mp_upper - node_size;

mp->mp_lower +=

(

);

memcpy(ndata,

->mv_data,

(

));

->mv_data = ndata;

memcpy(ndata,

->mv_data,

->mv_size);

memcpy(ndata, &ofp->mp_pgno,

(

));

->mv_data = ndata;

memcpy(ndata,

->mv_data,

->mv_size);

((

,

mdb_dbg_pgno(mp),

(mp)));

((

, mp->mp_upper,mp->mp_lower,room));

((

, node_size));

((

, indx,

(mp) ?

:

, mdb_dbg_pgno(mp)));

x = numkeys - 1 - indx;

(base, base + ksize, x * ksize);

mp->mp_lower -=

(

);

mp->mp_upper += ksize -

(

);

(

= j = 0;

< numkeys;

++) {

base = (

*)mp + mp->mp_upper +

;

(base + sz, base, ptr - mp->mp_upper);

mp->mp_lower -=

(

);

sp->mp_upper = sp->mp_lower;

base = (

*)mp + mp->mp_upper +

;

mp->mp_upper +=

;

(*

&& *

!= mc)

= &(*prev)->mc_next;

(!mc)

;

, ksize, oksize;

ptr,

, numkeys, indx;

kbuf2[DKBUF_MAXKEYSIZE*2+1];

((

,

mdb_dkey(&k2, kbuf2),

ksize =

(

->mv_size);

= ksize - oksize;

((

,

));

(

= 0;

< numkeys;

++) {

base = (

*)mp + mp->mp_upper +

;

mp->mp_upper -=

;

;

= srcnode->mn_flags;

snum = csrc->

;

snum = cdst->

;

mn.

[snum] = 0;

((

,

(m3 == csrc)

;

((

,

((

,

((

, psrc->mp_pgno, pdst->mp_pgno));

(

= 0;

<

(psrc);

++, j++) {

.mv_data = (

*)

.mv_data +

.mv_size;

(

= 0;

<

(psrc);

++, j++) {

((

,

pdst->mp_pgno,

(pdst),

top = csrc->

;

(m3 == csrc)

;

(m3->

[top] == psrc) {

m3->

[top] = pdst;

m3->

[top] += nkeys;

}

(m3->

[top-1] == csrc->

[top-1] &&

m3->

[top-1]--;

snum = cdst->

;

ptop, minkeys, thresh;

((

,

((

,

(

);

(

);

(m3->

[0] == mp) {

(

);

(m3 == mc)

;

(m3->

[0] == mp) {

(

);

(mc->

[ptop] == 0) {

(

);

(

);

((

,

nflags)

;

rc =

, new_root = 0, did_split = 0;

, j, split_indx, nkeys, pmax;

sepkey, rkey, xdata, *rdata = &xdata;

((

,

(mp) ?

:

, mp->mp_pgno,

((

, rp->mp_pgno));

mc->

[0] = pp;

((

, pp->mp_pgno));

((

, mc->

[ptop]->mp_pgno));

split_indx = newindx;

split_indx = (nkeys+1) / 2;

*

, *ins;

lsize, rsize, ksize;

rsize = (nkeys - split_indx) * ksize;

lsize = (nkeys - split_indx) *

(

);

mp->mp_lower -= lsize;

rp->mp_lower += lsize;

mp->mp_upper += rsize - lsize;

rp->mp_upper -= rsize - lsize;

(newindx == split_indx) {

memcpy(ins, newkey->

, ksize);

mp->mp_lower +=

(

);

mp->mp_upper -= ksize -

(

);

memcpy(ins, newkey->

, ksize);

memcpy(ins+ksize,

+ x * ksize, rsize - x * ksize);

rp->mp_lower +=

(

);

rp->mp_upper -= ksize -

(

);

psize, nsize, k;

nsize =

(nsize);

->mp_pgno = mp->mp_pgno;

(

=0, j=0;

<nkeys;

++) {

(

== newindx) {

->mp_ptrs[j++] = 0;

(nkeys < 32 || nsize > pmax/16 || newindx >= nkeys) {

(newindx <= split_indx || newindx >= nkeys) {

k = newindx >= nkeys ? nkeys : split_indx+1+

(mp);

(;

!=k;

+=j) {

(

== newindx) {

psize +=

(

);

psize =

(psize);

(psize > pmax ||

== k-j) {

split_indx =

+ (j<0);

(split_indx == newindx) {

((

, split_indx,

(&sepkey)));

(

=0;

<ptop;

++) {

(mn.

[ptop]) {

rc =

(mc, 0, newkey, newdata, newpgno, nflags);

(

== newindx) {

(!

(mp) && j == 0) {

}

(

!= split_indx);

(

=0;

<nkeys;

++)

mp->mp_lower =

->mp_lower;

mp->mp_upper =

->mp_upper;

(newindx < split_indx) {

mc->

[ptop]++;

(

=0;

<=ptop;

++) {

(newindx >= split_indx) {

mc->

[ptop]++;

(

=0;

<=ptop;

++) {

(m3->

[0] != mp)

(k=new_root; k>=0; k--) {

(m3->

[0] >= nkeys) {

}

(!did_split && m3->

>= ptop && m3->

[ptop] == mc->

[ptop] &&

m3->

[ptop]++;

toggle = 0, wsize, rc;

sigemptyset(&

);

sigaddset(&

, SIGPIPE);

((rc = pthread_sigmask(SIG_BLOCK, &

,

)) != 0)

pthread_mutex_lock(&my->

);

wsize = my->

[toggle];

(wsize > 0 && !my->

) {

}

(

> 0) {

wsize = my->

[toggle];

pthread_cond_signal(&my->

);

pthread_mutex_unlock(&my->

);

pthread_mutex_lock(&my->

);

pthread_cond_signal(&my->

);

pthread_mutex_unlock(&my->

);

(

=0;

<

;

++) {

memcpy(&pg,

(ni),

(pg));

(omp->mp_pages > 1) {

memcpy(&db,

(ni),

(db));

memcpy(

(ni), &db,

(db));

rc = ERROR_NOT_ENOUGH_MEMORY;

((rc = pthread_mutex_init(&my.

,

)) != 0)

((rc = pthread_cond_init(&my.

,

)) != 0)

((rc = posix_memalign(&p,

->me_os_psize,

*2)) != 0)

pthread_cond_destroy(&my.

);

pthread_mutex_destroy(&my.

);

(

->me_txns) {

wmutex =

->me_wmutex;

}

(

> 0) {

}

(

> 0) {

->me_flags |= flag;

->me_flags &= ~flag;

->me_assert_func = func;

*arg =

->me_path;

rc, dbflag, exact;

= 0, seq;

.mv_data = (

*)name;

(dbi < CORE_DBS || dbi >=

->me_maxdbs)

ptr =

->me_dbxs[dbi].md_name.mv_data;

->me_dbxs[dbi].md_name.mv_data =

;

->me_dbxs[dbi].md_name.mv_size = 0;

->me_dbflags[dbi] = 0;

->me_dbiseqs[dbi]++;

(

=0;

<

;

++) {

memcpy(&pg,

(ni),

(pg));

(

=0;

<

;

++) {

, rdrs;

rc = 0,

= 1;

(!

|| !func)

(!

->me_txns) {

func(

,

);

rdrs =

->me_txns->mti_numreaders;

mr =

->me_txns->mti_readers;

(

=0;

<rdrs;

++) {

:

,

rc = func(

,

);

rc = func(

,

);

cursor = 1;

= ids[0];

pivot =

>> 1;

cursor = base + pivot + 1;

= pid - ids[cursor];

}

(

> 0 ) {

(

= ids[0];

> cursor;

--)

ids[

] = ids[

-1];

, j, rdrs;

rdrs =

->me_txns->mti_numreaders;

mr =

->me_txns->mti_readers;

(

=0;

<rdrs;

++) {

pid = mr[

].mr_pid;

(pid && pid !=

->me_pid) {

(; j<rdrs; j++)

(mr[j].

== pid) {

((

,

(

) pid, mr[j].

));

(rc == MDB_OWNERDEAD) {

rlocked = (mutex ==

->me_rmutex);

(

->me_txn) {

((

, (rlocked ?

:

),

(rc ?

:

)));

(rc || (rc = rc2)) {

utf8_to_utf16(

*src,

*dst,

xtra)

need = MultiByteToWideChar(CP_UTF8, 0, src, -1,

, need);

=

(

(

) * (need + xtra));

dst->

= need - 1;

static unsigned char depth[2 *(256+1+29)+1]

std::ofstream out("events_result.xml")

main entry point for tests

static const struct name_t names[]

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

#define MDB_VERSION_STRING

The full library version as a C string.

#define MDB_VERSION_MINOR

Library minor version.

#define MDB_VERSION_MAJOR

Library major version.

#define MDB_VERSION_PATCH

Library patch version.

#define ErrCode()

Get the error code for the last failed system function.

#define THREAD_CREATE(thr, start, arg)

pthread_mutex_t * mdb_mutexref_t

Reference to an mdb_mutex_t.

#define Z

printf format modifier for size_t

#define INVALID_HANDLE_VALUE

A value for an invalid file handle.

#define UNLOCK_MUTEX(mutex)

Unlock the reader or writer mutex.

#define THREAD_FINISH(thr)

#define GET_PAGESIZE(x)

Get the size of a memory page for the system.

pthread_mutex_t mdb_mutex_t[1]

Shared mutex/semaphore as the original is stored.

#define mdb_mutex_consistent(mutex)

Mark mutex-protected data as repaired, after death of previous owner.

#define HANDLE

An abstraction for a file handle.

#define LOCK_MUTEX0(mutex)

Lock the reader or writer mutex.

#define DPUTS(arg)

Print a debug string.

#define DDBI(mc)

Debuging output value of a cursor DBI: Negative in a sub-cursor.

#define MDB_PAGE_FULL

Page has not enough space - internal error.

#define MDB_KEYEXIST

key/data pair already exists

#define MDB_MAP_FULL

Environment mapsize reached.

#define MDB_BAD_RSLOT

Invalid reuse of reader locktable slot.

#define MDB_LAST_ERRCODE

The last defined error code.

#define MDB_BAD_VALSIZE

Unsupported size of key/DB name/data, or wrong DUPFIXED size.

#define MDB_DBS_FULL

Environment maxdbs reached.

#define MDB_MAP_RESIZED

Database contents grew beyond environment mapsize.

#define MDB_PAGE_NOTFOUND

Requested page not found - this usually indicates corruption.

#define MDB_VERSION_MISMATCH

Environment version mismatch.

#define MDB_INVALID

File is not a valid LMDB file.

#define MDB_INCOMPATIBLE

Operation and DB incompatible, or DB type changed.

#define MDB_BAD_DBI

The specified DBI was changed unexpectedly.

#define MDB_TLS_FULL

Too many TLS keys in use - Windows only.

#define MDB_NOTFOUND

key/data pair not found (EOF)

#define MDB_TXN_FULL

Txn has too many dirty pages.

#define MDB_SUCCESS

Successful result.

#define MDB_BAD_TXN

Transaction must abort, has a child, or is invalid.

#define MDB_READERS_FULL

Environment maxreaders reached.

#define MDB_CURSOR_FULL

Cursor stack too deep - internal error.

#define MDB_PANIC

Update of meta page failed or environment had fatal error.

#define MDB_CORRUPTED

Located page was wrong type.

void mdb_midl_free(MDB_IDL ids)

Free an IDL.

int mdb_midl_append_list(MDB_IDL *idp, MDB_IDL app)

Append an IDL onto an IDL.

MDB_ID * MDB_IDL

An IDL is an ID List, a sorted array of IDs.

int mdb_midl_need(MDB_IDL *idp, unsigned num)

Make room for num additional elements in an IDL.

#define MDB_IDL_SIZEOF(ids)

void mdb_midl_xmerge(MDB_IDL idl, MDB_IDL merge)

Merge an IDL onto an IDL.

#define MDB_IDL_ALLOCLEN(ids)

Current max length of an mdb_midl_alloc()ed IDL.

unsigned mdb_mid2l_search(MDB_ID2L ids, MDB_ID id)

Search for an ID in an ID2L.

int mdb_mid2l_append(MDB_ID2L ids, MDB_ID2 *id)

Append an ID2 into a ID2L.

int mdb_mid2l_insert(MDB_ID2L ids, MDB_ID2 *id)

Insert an ID2 into a ID2L.

void mdb_midl_shrink(MDB_IDL *idp)

Shrink an IDL.

unsigned mdb_midl_search(MDB_IDL ids, MDB_ID id)

Search for an ID in an IDL.

MDB_IDL mdb_midl_alloc(int num)

Allocate an IDL.

void mdb_midl_sort(MDB_IDL ids)

Sort an IDL.

int mdb_midl_append_range(MDB_IDL *idp, MDB_ID id, unsigned n)

Append an ID range onto an IDL.

size_t MDB_ID

A generic unsigned ID number.

int mdb_midl_append(MDB_IDL *idp, MDB_ID id)

Append an ID onto an IDL.

#define mdb_midl_xappend(idl, id)

Append ID to IDL.

MDB_ID2 * MDB_ID2L

An ID2L is an ID2 List, a sorted array of ID2s.

struct MDB_meta MDB_meta

Meta page content.

static int mdb_cmp_long(const MDB_val *a, const MDB_val *b)

Compare two items pointing at aligned size_t's.

static void mdb_default_cmp(MDB_txn *txn, MDB_dbi dbi)

Set the default comparison functions for a database.

static void mdb_node_shrink(MDB_page *mp, indx_t indx)

Compact the main page after deleting a node on a subpage.

void mdb_txn_reset(MDB_txn *txn)

Reset a read-only transaction.

static int mdb_freelist_save(MDB_txn *txn)

Save the freelist as of this transaction to the freeDB.

#define mdb_name_cpy

Copy name (mdb_nchar_t string)

static int mdb_page_spill(MDB_cursor *m0, MDB_val *key, MDB_val *data)

Spill pages from the dirty list back to disk.

static size_t mdb_leaf_size(MDB_env *env, MDB_val *key, MDB_val *data)

Calculate the size of a leaf node.

static int mdb_cursor_prev(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op)

Move the cursor to the previous data item.

#define NODEKEY(node)

Address of the key for the node.

char * mdb_version(int *major, int *minor, int *patch)

Return the library version info.

int mdb_env_set_flags(MDB_env *env, unsigned int flag, int onoff)

Set environment flags.

static int mdb_cursor_shadow(MDB_txn *src, MDB_txn *dst)

Back up parent txn's cursors, then grab the originals for tracking.

static int mdb_env_excl_lock(MDB_env *env, int *excl)

Try to get exclusive lock, otherwise shared.

#define MAXDATASIZE

The maximum size of a data item.

static int mdb_cursor_next(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op)

Move the cursor to the next data item.

static int mdb_rebalance(MDB_cursor *mc)

Rebalance the tree after a delete operation.

static int mdb_env_write_meta(MDB_txn *txn)

Update the environment info to commit a transaction.

#define TXN_DBI_CHANGED(txn, dbi)

Check for misused dbi handles.

static int mdb_cursor_first(MDB_cursor *mc, MDB_val *key, MDB_val *data)

Move the cursor to the first item in the database.

static int mdb_env_copyfd0(MDB_env *env, int fd)

Copy environment as-is.

static int mdb_env_setup_locks(MDB_env *env, MDB_name *fname, int mode, int *excl)

Open and/or initialize the lock region for the environment.

#define MDB_EOF

mdb_env_copyfd1() is done reading

#define SETPGNO(node, pgno)

Set the page number in a branch node.

#define MDB_NOSPILL

Do not spill pages to disk if txn is getting full, may fail instead.

static MDB_page * mdb_page_malloc(MDB_txn *txn, unsigned num)

Allocate memory for a page.

static void mdb_dpage_free(MDB_env *env, MDB_page *dp)

Free a dirty page.

static int mdb_node_add(MDB_cursor *mc, indx_t indx, MDB_val *key, MDB_val *data, pgno_t pgno, unsigned int flags)

Add a node to the page pointed to by the cursor.

int mdb_env_get_fd(MDB_env *env, mdb_filehandle_t *arg)

Return the filedescriptor for the given environment.

#define MDB_END_UPDATE

update env state (DBIs)

static void mdb_page_copy(MDB_page *dst, MDB_page *src, unsigned int psize)

Copy the used portions of a non-overflow page.

static size_t mdb_branch_size(MDB_env *env, MDB_val *key)

Calculate the size of a branch node.

static int mdb_cmp_cint(const MDB_val *a, const MDB_val *b)

Compare two items pointing at unsigned ints of unknown alignment.

#define mdb_cassert(mc, expr)

assert(3) variant in cursor context

int mdb_env_open(MDB_env *env, const char *path, unsigned int flags, mdb_mode_t mode)

Open an environment handle.

static void mdb_page_free(MDB_env *env, MDB_page *mp)

Free a single page.

static int mdb_page_search_root(MDB_cursor *mc, MDB_val *key, int modify)

Finish mdb_page_search() / mdb_page_search_lowest().

#define METADATA(p)

Address of first usable data byte in a page, after the header.

int mdb_reader_check(MDB_env *env, int *dead)

Check for stale entries in the reader lock table.

static int mdb_cursor_touch(MDB_cursor *mc)

Touch all the pages in the cursor stack.

#define XCURSOR_REFRESH(mc, top, mp)

Update the xcursor's sub-page pointer, if any, in mc.

mdb_fopen_type

File type, access mode etc.

#define XCURSOR_INITED(mc)

Check if there is an inited xcursor.

static int mdb_cursor_set(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op, int *exactp)

Set the cursor on a specific data item.

static int mdb_ovpage_free(MDB_cursor *mc, MDB_page *mp)

#define FREE_DBI

Handle for the DB used to track free pages.

int mdb_env_copy2(MDB_env *env, const char *path, unsigned int flags)

Copy an LMDB environment to the specified path, with options.

static int mdb_page_search(MDB_cursor *mc, MDB_val *key, int flags)

Search for the page a given key should be in.

static char *const mdb_errstr[]

Table of descriptions for LMDB Return Codes.

#define PAGEBASE

ITS#7713, change PAGEBASE to handle 65536 byte pages.

#define MDB_END_OPMASK

mask for mdb_txn_end() operation number

void mdb_env_close(MDB_env *env)

Close the environment and release the memory map.

#define MDB_SPLIT_REPLACE

newkey is not new

static void mdb_xcursor_init2(MDB_cursor *mc, MDB_xcursor *src_mx, int force)

Fixup a sorted-dups cursor due to underlying update.

static int mdb_page_loose(MDB_cursor *mc, MDB_page *mp)

Loosen or free a single page.

void * mdb_env_get_userctx(MDB_env *env)

Get the application information associated with the MDB_env.

#define WITH_CURSOR_TRACKING(mn, act)

Perform act while tracking temporary cursor mn.

int mdb_stat(MDB_txn *txn, MDB_dbi dbi, MDB_stat *arg)

Retrieve statistics for a database.

void mdb_cursor_close(MDB_cursor *mc)

Close a cursor handle.

#define mdb_cmp_clong

Compare two items pointing at size_t's of unknown alignment.

#define IS_OVERFLOW(p)

Test if a page is an overflow page.

static int mdb_fopen(const MDB_env *env, MDB_name *fname, enum mdb_fopen_type which, mdb_mode_t mode, int *res)

Open an LMDB file.

static int mdb_page_new(MDB_cursor *mc, uint32_t flags, int num, MDB_page **mp)

Allocate and initialize new pages for a database.

#define IS_SUBP(p)

Test if a page is a sub page.

#define MDB_MAGIC

A stamp that identifies a file as an LMDB file.

struct MDB_page MDB_page

Common header for all page types.

int mdb_put(MDB_txn *txn, MDB_dbi dbi, MDB_val *key, MDB_val *data, unsigned int flags)

Store items into a database.

#define DEFAULT_MAPSIZE

Default size of memory map.

static void mdb_node_del(MDB_cursor *mc, int ksize)

Delete the specified node from a page.

void mdb_dbi_close(MDB_env *env, MDB_dbi dbi)

Close a database handle.

#define MDB_END_FREE

free txn unless it is MDB_env.

static int mdb_cmp_memnr(const MDB_val *a, const MDB_val *b)

Compare two items in reverse byte order.

struct MDB_node MDB_node

Header for a single key/data pair within a page.

static void mdb_cursor_copy(const MDB_cursor *csrc, MDB_cursor *cdst)

Copy the contents of a cursor.

char * mdb_strerror(int err)

Return a string describing a given error code.

#define TXN_DBI_EXIST(txn, dbi, validity)

Check txn and dbi arguments to a function.

static int mdb_txn_renew0(MDB_txn *txn)

Common code for mdb_txn_begin() and mdb_txn_renew().

#define PAGEFILL(env, p)

The percentage of space used in the page, in tenths of a percent.

#define MDB_DATA_VERSION

The version number for a database's datafile format.

int mdb_env_copy(MDB_env *env, const char *path)

Copy an LMDB environment to the specified path.

static int mdb_env_cthr_toggle(mdb_copy *my, int adjust)

Give buffer and/or MDB_EOF to writer thread, await unused buffer.

static int mdb_node_read(MDB_cursor *mc, MDB_node *leaf, MDB_val *data)

Return the data associated with a given node.

static const mdb_nchar_t *const mdb_suffixes[2][2]

Filename suffixes [datafile,lockfile][without,with MDB_NOSUBDIR].

#define FILL_THRESHOLD

The minimum page fill factor, in tenths of a percent.

int mdb_cursor_renew(MDB_txn *txn, MDB_cursor *mc)

Renew a cursor handle.

static int mdb_cursor_last(MDB_cursor *mc, MDB_val *key, MDB_val *data)

Move the cursor to the last item in the database.

static int mdb_pid_insert(pid_t *ids, pid_t pid)

Insert pid into list if not already present.

int mdb_env_info(MDB_env *env, MDB_envinfo *arg)

Return information about the LMDB environment.

static void mdb_page_dirty(MDB_txn *txn, MDB_page *mp)

Add a page to the txn's dirty list.

#define MAX_PAGESIZE

The maximum size of a database page.

int mdb_set_compare(MDB_txn *txn, MDB_dbi dbi, MDB_cmp_func *cmp)

Set a custom key comparison function for a database.

int mdb_set_relfunc(MDB_txn *txn, MDB_dbi dbi, MDB_rel_func *rel)

Set a relocation function for a MDB_FIXEDMAP database.

static int mdb_env_map(MDB_env *env, void *addr)

static int mdb_page_merge(MDB_cursor *csrc, MDB_cursor *cdst)

Merge one page into another.

int mdb_txn_renew(MDB_txn *txn)

Renew a read-only transaction.

static int mdb_cmp_memn(const MDB_val *a, const MDB_val *b)

Compare two items lexically.

#define MAX_WRITE

max bytes to write in one call

int mdb_env_set_assert(MDB_env *env, MDB_assert_func *func)

Set or reset the assert() callback of the environment.

static void mdb_dlist_free(MDB_txn *txn)

Return all dirty pages to dpage list.

int mdb_cursor_open(MDB_txn *txn, MDB_dbi dbi, MDB_cursor **ret)

Create a cursor handle.

static void mdb_cursor_init(MDB_cursor *mc, MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx)

Initialize a cursor for a given transaction and database.

int mdb_env_get_maxreaders(MDB_env *env, unsigned int *readers)

Get the maximum number of threads/reader slots for the environment.

uint16_t indx_t

Used for offsets within a single page.

#define SETDSZ(node, size)

Set the size of the data for a leaf node.

void mdb_txn_abort(MDB_txn *txn)

Abandon all the operations of the transaction instead of saving them.

#define CHANGEABLE

Only a subset of the Environment Flags flags can be changed at runtime.

#define MDB_SUFFLEN

Max string length in mdb_suffixes[].

static int mdb_env_read_header(MDB_env *env, MDB_meta *meta)

Read the environment parameters of a DB environment before mapping it into memory.

static int mdb_pages_xkeep(MDB_cursor *mc, unsigned pflags, int all)

Set or clear P_KEEP in dirty, non-overflow, non-sub pages watched by txn.

#define LEAF2KEY(p, i, ks)

The address of a key in a LEAF2 page.

int mdb_set_relctx(MDB_txn *txn, MDB_dbi dbi, void *ctx)

Set a context pointer for a MDB_FIXEDMAP database's relocation function.

#define NUMKEYS(p)

Number of nodes on a page.

#define NODESIZE

Size of the node header, excluding dynamic data at the end.

#define mdb_tassert(txn, expr)

assert(3) variant in transaction context

#define ENV_MAXKEY(env)

The maximum size of a key we can write to the environment.

#define MDB_MINKEYS

The minimum number of keys required in a database page.

int mdb_txn_commit(MDB_txn *txn)

Commit all the operations of a transaction into the database.

struct mdb_copy mdb_copy

State needed for a double-buffering compacting copy.

int mdb_reader_list(MDB_env *env, MDB_msg_func *func, void *ctx)

Dump the entries in the reader lock table.

static MDB_node * mdb_node_search(MDB_cursor *mc, MDB_val *key, int *exactp)

Search for key within a page, using binary search.

int mdb_env_sync(MDB_env *env, int force)

Flush the data buffers to disk.

struct MDB_name MDB_name

Filename - string of mdb_nchar_t[].

static void mdb_xcursor_init1(MDB_cursor *mc, MDB_node *node)

Final setup of a sorted-dups cursor.

union MDB_metabuf MDB_metabuf

Buffer for a stack-allocated meta page.

#define MDB_GET_KEY(node, keyptr)

Set the node's key into keyptr, if requested.

#define LOCK_MUTEX(rc, env, mutex)

int mdb_get(MDB_txn *txn, MDB_dbi dbi, MDB_val *key, MDB_val *data)

Get items from a database.

int mdb_env_copyfd2(MDB_env *env, int fd, unsigned int flags)

Copy an LMDB environment to the specified file descriptor, with options.

#define MDB_MSYNC(addr, len, flags)

static int mdb_cmp_int(const MDB_val *a, const MDB_val *b)

Compare two items pointing at aligned unsigned int's.

struct MDB_pgstate MDB_pgstate

State of FreeDB old pages, stored in the MDB_env.

static int mdb_reader_pid(MDB_env *env, enum Pidlock_op op, pid_t pid)

Set or check a pid lock.

#define NODEDSZ(node)

Get the size of the data in a leaf node.

static int mdb_page_flush(MDB_txn *txn, int keep)

Flush (some) dirty pages to the map, after clearing their dirty flag.

#define mdb_env_close0(env, excl)

static int mdb_stat0(MDB_env *env, MDB_db *db, MDB_stat *arg)

Common code for mdb_stat() and mdb_env_stat().

int mdb_dbi_flags(MDB_txn *txn, MDB_dbi dbi, unsigned int *flags)

Retrieve the DB flags for a database handle.

static int mdb_page_alloc(MDB_cursor *mc, int num, MDB_page **mp)

Allocate page numbers and memory for writing.

#define VALID_FLAGS

mdb_dbi_open() flags

int mdb_cursor_get(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op)

Retrieve by cursor.

static txnid_t mdb_find_oldest(MDB_txn *txn)

Find oldest txnid still referenced.

#define NEXT_LOOSE_PAGE(p)

Link in MDB_txn.

#define CORE_DBS

Number of DBs in metapage (free and main) - also hardcoded elsewhere.

static void mdb_txn_end(MDB_txn *txn, unsigned mode)

End a transaction, except successful commit of a nested transaction.

static int mdb_fsize(int fd, size_t *size)

int mdb_env_set_mapsize(MDB_env *env, size_t size)

Set the size of the memory map to use for this environment.

#define COPY_PGNO(dst, src)

Copy a page number from src to dst.

int mdb_env_set_maxdbs(MDB_env *env, MDB_dbi dbs)

Set the maximum number of named databases for the environment.

#define MDB_FDATASYNC

Function for flushing the data of a file.

#define F_ISSET(w, f)

Test if the flags f are set in a flag word w.

static MDB_meta * mdb_env_pick_meta(const MDB_env *env)

Check both meta pages to see which one is newer.

#define NODEKSZ(node)

The size of a key in a node.

#define EVEN(n)

Round n up to an even number.

#define NODEDATA(node)

Address of the data for a node.

static int mdb_update_key(MDB_cursor *mc, MDB_val *key)

Replace the key for a branch node with a new key.

#define IS_LEAF2(p)

Test if a page is a LEAF2 page.

#define mdb_mutex_failed(env, mutex, rc)

int mdb_env_create(MDB_env **env)

Create an LMDB environment handle.

int mdb_env_get_maxkeysize(MDB_env *env)

Get the maximum size of keys and MDB_DUPSORT data we can write.

static int mdb_page_split(MDB_cursor *mc, MDB_val *newkey, MDB_val *newdata, pgno_t newpgno, unsigned int nflags)

Split a page and insert a new node.

static void mdb_dbis_update(MDB_txn *txn, int keep)

Export or close DBI handles opened in this txn.

#define MDB_END_SLOT

release any reader slot if MDB_NOTLS

int mdb_del(MDB_txn *txn, MDB_dbi dbi, MDB_val *key, MDB_val *data)

Delete items from a database.

#define P_INVALID

An invalid page number.

int mdb_drop(MDB_txn *txn, MDB_dbi dbi, int del)

Empty or delete+close a database.

static void mdb_assert_fail(MDB_env *env, const char *expr_txt, const char *func, const char *file, int line)

int mdb_cmp(MDB_txn *txn, MDB_dbi dbi, const MDB_val *a, const MDB_val *b)

Compare two data items according to a particular database.

MDB_ID txnid_t

A transaction ID.

#define NODEPGNO(node)

Get the page number pointed to by a branch node.

MDB_txn * mdb_cursor_txn(MDB_cursor *mc)

Return the cursor's transaction handle.

#define IS_LEAF(p)

Test if a page is a leaf page.

int mdb_dbi_open(MDB_txn *txn, const char *name, unsigned int flags, MDB_dbi *dbi)

Open a database in the environment.

static int mdb_cursor_push(MDB_cursor *mc, MDB_page *mp)

Push a page onto the top of the cursor's stack.

int mdb_env_get_flags(MDB_env *env, unsigned int *arg)

Get environment flags.

static int mdb_fname_init(const char *path, unsigned envflags, MDB_name *fname)

Set up filename + scratch area for filename suffix, for opening files.

#define IS_BRANCH(p)

Test if a page is a branch page.

static int mdb_page_search_lowest(MDB_cursor *mc)

Search for the lowest key under the current branch page.

int mdb_dcmp(MDB_txn *txn, MDB_dbi dbi, const MDB_val *a, const MDB_val *b)

Compare two data items according to a particular database.

#define mdb_fname_destroy(fname)

Destroy fname from mdb_fname_init()

static void mdb_xcursor_init0(MDB_cursor *mc)

Initial setup of a sorted-dups cursor.

static void mdb_cursor_pop(MDB_cursor *mc)

Pop a page off the top of the cursor's stack.

static void * mdb_env_copythr(void *arg)

Dedicated writer thread for compacting copy.

struct MDB_dbx MDB_dbx

Auxiliary DB info.

int mdb_set_dupsort(MDB_txn *txn, MDB_dbi dbi, MDB_cmp_func *cmp)

Set a custom data comparison function for a MDB_DUPSORT database.

#define LEAFSIZE(k, d)

Size of a node in a leaf page with a given key and data.

static int mdb_page_touch(MDB_cursor *mc)

Touch a page: make it dirty and re-insert into tree with updated pgno.

#define MAIN_DBI

Handle for the default DB.

static int mdb_env_copyfd1(MDB_env *env, int fd)

Copy environment with compaction.

static int mdb_page_get(MDB_cursor *mc, pgno_t pgno, MDB_page **mp, int *lvl)

Find the address of the page corresponding to a given page number.

static int mdb_env_cwalk(mdb_copy *my, pgno_t *pg, int flags)

Depth-first tree traversal for compacting copy.

static int mdb_env_init_meta(MDB_env *env, MDB_meta *meta)

Write the environment parameters of a freshly created DB environment.

#define OVPAGES(size, psize)

The number of overflow pages needed to store the given size.

MDB_ID pgno_t

A page number in the database.

size_t mdb_txn_id(MDB_txn *txn)

Return the transaction's ID.

int mdb_env_stat(MDB_env *env, MDB_stat *arg)

Return statistics about the LMDB environment.

#define NODEPTR(p, i)

Address of node i in page p.

#define MDB_COMMIT_PAGES

max number of pages to commit in one writev() call

static int mdb_reader_check0(MDB_env *env, int rlocked, int *dead)

As mdb_reader_check().

#define SIZELEFT(p)

The amount of space remaining in the page.

static int mdb_node_move(MDB_cursor *csrc, MDB_cursor *cdst, int fromleft)

Move a node from csrc to cdst.

#define NUM_METAS

Number of meta pages - also hardcoded elsewhere.

static int mdb_env_share_locks(MDB_env *env, int *excl)

Downgrade the exclusive lock on the region back to shared.

#define INDXSIZE(k)

Size of a node in a branch page with a given key.

struct MDB_ntxn MDB_ntxn

Nested transaction.

#define PAGEHDRSZ

Size of the page header, excluding dynamic data at the end.

MDB_dbi mdb_cursor_dbi(MDB_cursor *mc)

Return the cursor's database handle.

int mdb_env_set_maxreaders(MDB_env *env, unsigned int readers)

Set the maximum number of threads/reader slots for the environment.

char mdb_nchar_t

Character type for file names: char on Unix, wchar_t on Windows.

static int mdb_cursor_del0(MDB_cursor *mc)

Complete a delete operation started by mdb_cursor_del().

static int mdb_cursor_sibling(MDB_cursor *mc, int move_right)

Find a sibling for a page.

static void mdb_env_reader_dest(void *ptr)

Release a reader thread's slot in the reader lock table.

static int mdb_del0(MDB_txn *txn, MDB_dbi dbi, MDB_val *key, MDB_val *data, unsigned flags)

MDB_env * mdb_txn_env(MDB_txn *txn)

Returns the transaction's MDB_env.

int mdb_txn_begin(MDB_env *env, MDB_txn *parent, unsigned int flags, MDB_txn **ret)

Create a transaction for use with the environment.

int mdb_cursor_del(MDB_cursor *mc, unsigned int flags)

Delete current key/data pair.

static void mdb_cursors_close(MDB_txn *txn, unsigned merge)

Close this write txn's cursors, give parent txn's cursors back to parent.

#define MDB_GET_KEY2(node, key)

Set the node's key into key.

#define CURSOR_STACK

Enough space for 2^32 nodes with minimum of 2 keys per node.

static int mdb_env_open2(MDB_env *env)

Further setup required for opening an LMDB environment.

int mdb_env_get_path(MDB_env *env, const char **arg)

Return the path that was used in mdb_env_open().

int mdb_cursor_put(MDB_cursor *mc, MDB_val *key, MDB_val *data, unsigned int flags)

Store by cursor.

int mdb_env_set_userctx(MDB_env *env, void *ctx)

Set application information associated with the MDB_env.

struct MDB_xcursor MDB_xcursor

Context for sorted-dup records.

#define MDB_VALID

DB handle is valid, for me_dbflags.

static int mdb_page_unspill(MDB_txn *txn, MDB_page *mp, MDB_page **ret)

Pull a page off the txn's spill list, if present.

static int mdb_drop0(MDB_cursor *mc, int subs)

Add all the DB's pages to the free list.

#define MDB_NAME(str)

mdb_nchar_t[] string literal

struct MDB_db MDB_db

Information about a single database in the environment.

int mdb_cursor_count(MDB_cursor *mc, size_t *countp)

Return count of duplicates for current key.

int mdb_env_copyfd(MDB_env *env, int fd)

Copy an LMDB environment to the specified file descriptor.

static void mdb_env_init_meta0(MDB_env *env, MDB_meta *meta)

Fill in most of the zeroed MDB_meta for an empty database environment.

#define MDB_DSYNC

A flag for opening a file and requesting synchronous data writes.

@ MDB_END_FAIL_BEGINCHILD

@ MDB_O_COPY

for mdb_env_copy()

@ MDB_O_MASK

Bitmask for open() flags in enum mdb_fopen_type.

@ MDB_O_RDONLY

for RDONLY me_fd

int() MDB_msg_func(const char *msg, void *ctx)

A callback function used to print a message from the library.

unsigned int

A callback function used to compare two keys in a database.

void MDB_assert_func(MDB_env *env, const char *msg)

A callback function for most LMDB assert() failures, called before printing the message and aborting.

#define MDB_CP_COMPACT

Compacting copy: Omit free space from copy, and renumber all pages sequentially.

MDB_cursor_op

Cursor Get operations.

@ MDB_NEXT_NODUP

Position at first data item of next key.

@ MDB_PREV_NODUP

Position at last data item of previous key.

@ MDB_FIRST_DUP

Position at first data item of current key.

@ MDB_PREV_MULTIPLE

Position at previous page and return up to a page of duplicate data items.

@ MDB_LAST_DUP

Position at last data item of current key.

@ MDB_SET

Position at specified key.

@ MDB_LAST

Position at last key/data item.

@ MDB_NEXT_DUP

Position at next data item of current key.

@ MDB_GET_BOTH_RANGE

position at key, nearest data.

@ MDB_GET_BOTH

Position at key/data pair.

@ MDB_GET_MULTIPLE

Return up to a page of duplicate data items from current cursor position.

@ MDB_FIRST

Position at first key/data item.

@ MDB_NEXT

Position at next data item.

@ MDB_SET_RANGE

Position at first key greater than or equal to specified key.

@ MDB_NEXT_MULTIPLE

Return up to a page of duplicate data items from next cursor position.

@ MDB_PREV

Position at previous data item.

@ MDB_GET_CURRENT

Return key/data at current cursor position.

@ MDB_SET_KEY

Position at specified key, return key + data.

@ MDB_PREV_DUP

Position at previous data item of current key.

#define C_DEL

last op was a cursor_del

#define C_SUB

Cursor is a sub-cursor.

#define C_INITIALIZED

cursor has been initialized and is valid

#define C_UNTRACK

Un-track cursor when closing.

#define C_EOF

No more data.

#define MDB_INTEGERKEY

numeric keys in native byte order: either unsigned int or size_t.

#define MDB_DUPFIXED

with MDB_DUPSORT, sorted dup items have fixed size

#define MDB_INTEGERDUP

with MDB_DUPSORT, dups are MDB_INTEGERKEY-style integers

#define MDB_DUPSORT

use sorted duplicates

#define MDB_REVERSEKEY

use reverse string keys

#define MDB_REVERSEDUP

with MDB_DUPSORT, use reverse string dups

#define MDB_CREATE

create DB if not already existing

#define MDB_NORDAHEAD

don't do readahead (no effect on Windows)

#define MDB_FIXEDMAP

mmap at a fixed address (experimental)

#define MDB_NOMETASYNC

don't fsync metapage after commit

#define MDB_NOSYNC

don't fsync after commit

#define MDB_NOTLS

tie reader locktable slots to MDB_txn objects instead of to threads

#define MDB_WRITEMAP

use writable mmap

#define MDB_NOLOCK

don't do any locking, caller must manage their own locks

#define MDB_MAPASYNC

use asynchronous msync when MDB_WRITEMAP is used

#define MDB_NOSUBDIR

no environment directory

#define MDB_RDONLY

read only

#define MDB_NOMEMINIT

don't initialize malloc'd memory before writing to datafile

#define F_SUBDATA

data is a sub-database

#define F_DUPDATA

data has duplicates

#define NODE_ADD_FLAGS

valid flags for mdb_node_add()

#define F_BIGDATA

data put on overflow page

#define P_OVERFLOW

overflow page

#define P_KEEP

leave this page alone during spill

#define P_LOOSE

page was dirtied then freed, can be reused

#define P_SUBP

for MDB_DUPSORT sub-pages

#define P_DIRTY

dirty page, also set for P_SUBP pages

#define P_LEAF2

for MDB_DUPFIXED records

#define P_BRANCH

branch page

#define MDB_APPENDDUP

Duplicate data is being appended, don't split full pages.

#define MDB_APPEND

Data is being appended, don't split full pages.

unsigned int me_maxreaders

max reader slots in the environment

#define MDB_NOOVERWRITE

For put: Don't write if the key already exists.

size_t ms_entries

Number of data items.

size_t me_mapsize

Size of the data memory map.

size_t me_last_txnid

ID of the last committed transaction.

#define MDB_MULTIPLE

Store multiple data items in one call.

unsigned int ms_psize

Size of a database page.

#define MDB_NODUPDATA

Only for MDB_DUPSORT For put: don't write if the key and data pair already exist.

void * me_mapaddr

Address of map, if fixed.

#define MDB_CURRENT

For mdb_cursor_put: overwrite the current key/data pair.

size_t mv_size

size of the data item

void * mv_data

address of the data item

unsigned int ms_depth

Depth (height) of the B-tree.

#define MDB_RESERVE

For put: Just reserve space for data, don't copy it.

size_t ms_overflow_pages

Number of overflow pages.

size_t ms_leaf_pages

Number of leaf pages.

size_t ms_branch_pages

Number of internal (non-leaf) pages.

unsigned int me_numreaders

max reader slots used in the environment

size_t me_last_pgno

ID of the last used page.

#define MDB_TXN_WRITEMAP

copy of MDB_env flag in writers

#define MDB_TXN_SPILLS

txn or a parent has spilled pages

#define MDB_TXN_RDONLY

read-only transaction

#define MDB_TXN_FINISHED

txn is finished or never began

#define MDB_TXN_DIRTY

must write, even if dirty list is empty

#define MDB_TXN_BEGIN_FLAGS

mdb_txn_begin() flags

#define MDB_TXN_BLOCKED

most operations on the txn are currently illegal

#define MDB_TXN_ERROR

txn is unusable after an error

#define MDB_TXN_HAS_CHILD

txn has an MDB_txn.

void() MDB_rel_func(MDB_val *item, void *oldptr, void *newptr, void *relctx)

A callback function used to relocate a position-dependent data item in a fixed-address database.

struct MDB_txn MDB_txn

Opaque structure for a transaction handle.

int() MDB_cmp_func(const MDB_val *a, const MDB_val *b)

A callback function used to compare two keys in a database.

unsigned int MDB_dbi

A handle for an individual database in the DB environment.

struct MDB_cursor MDB_cursor

Opaque structure for navigating through a database.

#define DB_DUPDATA

DB is MDB_DUPSORT data.

#define DB_STALE

Named-DB record is older than txnID.

#define DB_DIRTY

DB was written in this txn.

#define DB_NEW

Named-DB handle opened in this txn.

#define DB_VALID

DB handle is valid, see also MDB_VALID.

#define DB_USRVALID

As DB_VALID, but not set for FREE_DBI.

struct MDB_rxbody MDB_rxbody

The information we store in a single slot of the reader table.

struct MDB_txninfo MDB_txninfo

The actual reader table definition.

struct MDB_reader MDB_reader

The actual reader record, with cacheline padding.

#define CACHELINE

The size of a CPU cache line in bytes.

#define MDB_LOCK_FORMAT

Lockfile format signature: version, features and field layout.

#define DEFAULT_READERS

Number of slots in the reader table.

struct MDB_txbody MDB_txbody

The header for the reader table.

where boath are integers</td > n< td ></td > n</tr > n< tr > n< td > tse</td > n< td > optional</td > n< td > String</td > n< td class=\"description\"> TSE option controls what blob is smart and slim</td> n<td> orig</td> n</tr> n<tr> n<td> last_modified</td> n<td> optional</td> n<td> Integer</td> n<td class=\"description\"> The blob last modification If provided then the exact match will be requested with n the Cassandra storage corresponding field value</td> n<td> Positive integer Not provided means that the most recent match will be selected</td> n<td></td> n</tr> n<tr> n<td> use_cache</td> n<td> optional</td> n<td> String</td> n<td class=\"description\"> The option controls if the Cassandra LMDB cache and or database should be used It n affects the seq id resolution step and the blob properties lookup step The following n options are BIOSEQ_INFO and BLOB_PROP at all

while(yy_chk[yy_base[yy_current_state]+yy_c] !=yy_current_state)

if(yy_accept[yy_current_state])

static const CS_INT unused

#define DO_PWRITE(rc, fd, ptr, size, len, pos)

#define VGMEMP_FREE(h, a)

#define MDB_ENV_TXKEY

me_txkey is set

#define DO_WRITE(rc, fd, ptr, w2, len)

#define MDB_FSYNCONLY

fdatasync is unreliable

#define mr_txnid

shorthand for mrb_txnid

#define CACHEFLUSH(addr, bytes, cache)

#define VGMEMP_DESTROY(h)

#define VGMEMP_ALLOC(h, a, s)

#define MDB_ENV_ACTIVE

Some fields are initialized.

#define VGMEMP_CREATE(h, r, z)

#define VGMEMP_DEFINED(a, s)

#define me_rmutex

Shared reader lock.

#define MDB_FATAL_ERROR

Failed to update the meta page.

#define me_wmutex

Shared writer lock.

LMDB ID List header file.

const struct ncbi::grid::netcache::search::fields::SIZE size

const struct ncbi::grid::netcache::search::fields::KEY key

int strncmp(const char *str1, const char *str2, size_t count)

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

Int4 delta(size_t dimension_, const Int4 *score_)

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

void split(std::vector< std::string > *strVec, const std::string &str_, const std::string &split_)

static SLJIT_INLINE sljit_ins st(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

static SLJIT_INLINE sljit_ins nr(sljit_gpr dst, sljit_gpr src)

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

static const sljit_gpr r2

int mdb_filehandle_t

An abstraction for a file handle.

mode_t mdb_mode_t

Unix permissions for creating files, or dummy definition for Windows.

An ID2 is an ID/pointer pair.

Cursors are used for all DB operations.

MDB_cursor * mc_backup

Backup of the original cursor if this cursor is a shadow.

MDB_txn * mc_txn

The transaction that owns this cursor.

MDB_cursor * mc_next

Next cursor on this DB in this txn.

MDB_dbi mc_dbi

The database handle this cursor operates on.

unsigned char * mc_dbflag

The Transaction DB Flags for this database.

MDB_db * mc_db

The database record for this cursor.

unsigned short mc_top

index of top page, normally mc_snum-1

unsigned int mc_flags

Cursor Flags

indx_t mc_ki[32]

stack of page indices

unsigned short mc_snum

number of pushed pages

MDB_dbx * mc_dbx

The database auxiliary record for this cursor.

MDB_page * mc_pg[32]

stack of pushed pages

struct MDB_xcursor * mc_xcursor

Context used for databases with MDB_DUPSORT, otherwise NULL.

Information about a single database in the environment.

uint32_t md_pad

also ksize for LEAF2 pages

pgno_t md_overflow_pages

number of overflow pages

pgno_t md_branch_pages

number of internal pages

uint16_t md_flags

Database Flags

uint16_t md_depth

depth of this tree

pgno_t md_root

the root page of this tree

pgno_t md_leaf_pages

number of leaf pages

size_t md_entries

number of data items

MDB_cmp_func * md_cmp

function for comparing keys

void * md_relctx

user-provided context for md_rel

MDB_rel_func * md_rel

user relocate function

MDB_cmp_func * md_dcmp

function for comparing data items

MDB_val md_name

name of the database

The database environment.

int me_mfd

For writing and syncing the meta pages.

MDB_pgstate me_pgstate

state of old pages from freeDB

void * me_pbuf

scratch area for DUPSORT put()

pid_t me_pid

process ID of this env

pthread_key_t me_txkey

thread-key for readers

MDB_dbx * me_dbxs

array of static DB info

MDB_txn * me_txn

current write transaction

MDB_ID2L me_dirty_list

ID2L of pages written during a write txn.

MDB_IDL me_free_pgs

IDL of pages that became unused in a write txn.

int me_fd

The main data file.

char * me_path

path to the DB files

char * me_map

the memory map of the data file

volatile int me_close_readers

Max MDB_txninfo.

MDB_txn * me_txn0

prealloc'd write transaction

unsigned int me_nodemax

Max size of a node on a page.

unsigned int * me_dbiseqs

array of dbi sequence numbers

uint16_t * me_dbflags

array of flags from MDB_db.md_flags

pgno_t me_maxpg

me_mapsize / me_psize

unsigned int me_maxreaders

size of the reader table

MDB_meta * me_metas[2]

pointers to the two meta pages

int me_maxfree_1pg

Max number of freelist items that can fit in a single overflow page.

int me_lfd

The lock file.

uint32_t me_flags

Environment Flags

int me_live_reader

have liveness lock in reader table

MDB_dbi me_numdbs

number of DBs opened

void * me_userctx

User-settable context.

MDB_dbi me_maxdbs

size of the DB table

off_t me_size

current file size

MDB_assert_func * me_assert_func

Callback for assertion failures.

MDB_txninfo * me_txns

the memory map of the lock file or NULL

txnid_t me_pgoldest

ID of oldest reader last time we looked.

unsigned int me_os_psize

OS page size, from GET_PAGESIZE.

MDB_page * me_dpages

list of malloc'd blocks for re-use

size_t me_mapsize

size of the data memory map

unsigned int me_psize

DB page size, inited from me_os_psize.

Information about the environment.

Filename - string of mdb_nchar_t[].

mdb_nchar_t * mn_val

Contents.

int mn_alloced

True if mn_val was malloced.

Header for a single key/data pair within a page.

unsigned short mn_ksize

key size

unsigned short mn_flags

Node Flags

unsigned short mn_lo

part of data size or pgno

char mn_data[1]

key and data are appended here

MDB_pgstate mnt_pgstate

parent transaction's saved freestate

MDB_txn mnt_txn

the transaction

Common header for all page types.

uint16_t mp_pad

key size if this is a LEAF2 page

indx_t pb_upper

upper bound of free space

union MDB_page::@1199 mp_p

union MDB_page::@1200 mp_pb

pgno_t p_pgno

page number

uint16_t mp_flags

Page Flags

uint32_t pb_pages

number of overflow pages

struct MDB_page * p_next

for in-memory list of freed pages

struct MDB_page::@1200::@1201 pb

indx_t pb_lower

lower bound of free space

indx_t mp_ptrs[1]

dynamic size

State of FreeDB old pages, stored in the MDB_env.

txnid_t mf_pglast

ID of last used record, or 0 if !mf_pghead.

pgno_t * mf_pghead

Reclaimed freeDB pages, or NULL before use.

The actual reader record, with cacheline padding.

union MDB_reader::@1196 mru

char pad[(sizeof(MDB_rxbody)+64 -1) &~(64 -1)]

cache line alignment

The information we store in a single slot of the reader table.

volatile pid_t mrb_pid

The process ID of the process owning this reader txn.

volatile pthread_t mrb_tid