32 ((DB_VERSION_MAJOR << 16) | (DB_VERSION_MINOR << 8) | (DB_VERSION_PATCH)) 37 #define USE_DB_THREAD 1 39 #define DT_DB_CHECKPOINT 3 MINUTES 40 #define DT_DB_COMPRESS 6 HOURS 46 static size_t db_db_cache_size = 16 * 1024 * 1024;
48 static size_t db_env_cache_size = 16 * 1024 * 1024;
49 static int db_lk_max_locks = 0x8000;
50 static int db_lk_max_lockers = 1000;
51 static int db_lk_max_objects = 0x8000;
57 size_t old = db_db_cache_size;
59 db_db_cache_size = size;
72 old = db_lk_max_locks;
73 db_lk_max_locks = value;
76 old = db_lk_max_lockers;
77 db_lk_max_lockers = value;
80 old = db_lk_max_objects;
81 db_lk_max_objects = value;
84 old = db_env_cache_size;
85 db_env_cache_size = value;
88 old = db_db_cache_size;
89 db_db_cache_size = value;
96 zeDb_DefaultsFromEnv()
101 if ((env = getenv(
"DB_DB_CACHE_SIZE")) != NULL) {
107 db_db_cache_size = v;
109 if ((env = getenv(
"DB_ENV_CACHE_SIZE")) != NULL) {
115 db_env_cache_size = v;
117 if ((env = getenv(
"DB_LK_MAX_LOCKS")) != NULL) {
125 if ((env = getenv(
"DB_LK_MAX_OBJECTS")) != NULL) {
131 db_lk_max_objects = v;
133 if ((env = getenv(
"DB_LK_MAX_LOCKERS")) != NULL) {
139 db_lk_max_lockers = v;
151 int major, minor, patch;
154 major = minor = patch = 0;
155 if ((dbv = db_version(&major, &minor, &patch)) == NULL) {
160 if ((major != DB_VERSION_MAJOR) ||
161 (minor != DB_VERSION_MINOR) || (patch != DB_VERSION_PATCH)) {
163 "Application compiled against Berkeley DB version %d.%d.%d " 164 "but runtime version is %d.%d.%d", DB_VERSION_MAJOR,
165 DB_VERSION_MINOR, DB_VERSION_PATCH, major, minor, patch);
183 zeDb_PeriodicTasks(arg)
187 int nerra = 0, nerrb = 0;
189 time_t ti_check, ti_compress;
195 dbenv = (DB_ENV *) arg;
197 ti_check = ti_compress = time(NULL);
211 if ((ret = dbenv->txn_checkpoint(dbenv, 0, 0, 0)) != 0) {
212 ZE_LogMsgError(0,
"Database checkpoint error : %s", db_strerror(ret));
221 for (i = 0; i <
DIMDB; i++) {
225 memset(&compact, 0,
sizeof (compact));
227 if ((ret = rwdb[i].dbh->compact(rwdb[i].dbh, NULL, NULL, NULL, NULL,
228 DB_FREE_SPACE, NULL)) != 0) {
230 rwdb[i].database, db_strerror(ret));
251 DB_ENV *dbenv = NULL;
253 zeDb_DefaultsFromEnv();
258 if ((ret = db_env_create(&dbenv, 0)) != 0) {
259 ZE_LogMsgError(0,
"Error creating environment : %s", db_strerror(ret));
268 size_t gbytes, bytes;
270 bytes = db_env_cache_size % (1024 * 1024 * 1024);
271 gbytes = (db_env_cache_size - bytes) / (1024 * 1024 * 1024);
273 if ((ret = dbenv->set_cachesize(dbenv, gbytes, bytes, 1)) != 0) {
284 #if BDB_VERSION >= 0x40700 285 if ((ret = dbenv->log_set_config(dbenv, DB_LOG_AUTO_REMOVE,
TRUE)) != 0)
287 if ((ret = dbenv->set_flags(dbenv, DB_LOG_AUTOREMOVE,
TRUE)) != 0)
294 #if _FFR_LOG_IN_MEMORY 295 #if BDB_VERSION >= 0x50000 296 if ((ret = dbenv->log_set_config(dbenv, DB_LOG_IN_MEMORY,
TRUE)) != 0) {
319 flags |= DB_REGISTER | DB_RECOVER;
335 ret = dbenv->set_lk_max_locks(dbenv, db_lk_max_locks);
338 home, db_strerror(ret));
340 ret = dbenv->set_lk_max_objects(dbenv, db_lk_max_objects);
342 ZE_LogMsgError(0,
"Error setting max lock objects environment : %s %s",
343 home, db_strerror(ret));
345 if ((ret = dbenv->open(dbenv, home, flags, 0)) != 0) {
352 u_int32_t locks, objs, lockers, gbytes, bytes;
355 locks = objs = lockers = 0;
356 (void) dbenv->get_lk_max_locks(dbenv, &locks);
357 (void) dbenv->get_lk_max_lockers(dbenv, &lockers);
358 (void) dbenv->get_lk_max_objects(dbenv, &objs);
359 ZE_MessageInfo(10,
"DB Environment : max locks=%d objs=%d lockers=%d",
360 locks, objs, lockers);
361 (void) dbenv->get_cachesize(dbenv, &gbytes, &bytes, &partitions);
362 ZE_MessageInfo(10,
"DB Environment : cache size=%ld partitions=%ld",
363 gbytes
GBYTES + bytes, partitions);
369 if (dt_chkpoint > 0 ||
TRUE) {
374 pthread_create(&ptid, NULL, zeDb_PeriodicTasks, (
void *) dbenv)) != 0)
383 if (getenv(
"LOG_DB_ERRORS") != NULL) {
385 char *fname =
"db_errors.txt";
388 env = getenv(
"LOG_DB_ERRORS");
390 if ((ferr = fopen(fname,
"a")) != NULL) {
392 static char pfx[256];
394 (void) dbenv->get_home(dbenv, (
const char **) &home);
395 snprintf(pfx,
sizeof (pfx),
"ze-filter (%s) ",
STRNULL(home,
"???"));
396 (void) dbenv->set_errpfx(dbenv, pfx);
397 (void) dbenv->set_errfile(dbenv, ferr);
404 (void) dbenv->close(dbenv, 0);
423 if ((ret = dbenv->close(dbenv, 0)) != 0) {
424 ZE_LogMsgError(0,
"Error closing environment : %s", db_strerror(ret));
443 bt_compare_fcn(h, a, b)
448 if ((a == NULL) || (a->data == NULL) || (b == NULL) || (b->data == NULL))
451 return strcasecmp(a->data, b->data);
462 zeDb_Open(h, dbenv, database, mode, rdonly, dbtype, dbcache)
494 ret = h->
err = db_create(&dbp, dbenv, 0);
508 int32_t sz_cache = 0;
510 gbytes = bytes = ncache = 0;
511 #if (BDB_VERSION >= 0x40200) 512 h->
err = res = dbp->get_cachesize(dbp, &gbytes, &bytes, &ncache);
514 ZE_LogMsgError(0,
"Error getting %s database cache : %s", database,
518 ZE_MessageInfo(12,
"CACHE OLD : %ld %ld %ld", gbytes, bytes, ncache);
521 sz_cache = db_db_cache_size;
523 if (dbcache > sz_cache)
526 if (sz_cache > bytes) {
528 ZE_MessageInfo(10,
"DB Database %-12s : cache size=%ld partitions=%ld",
530 h->
err = res = dbp->set_cachesize(dbp, gbytes, bytes, ncache);
532 ZE_LogMsgError(0,
"Error setting %s database cache : %s", database,
539 dbp->set_bt_compare(dbp, bt_compare_fcn);
543 #ifndef DB_HASH_NELEM 544 #define DB_HASH_NELEM (64*1024) 551 ret = dbp->set_h_nelem(dbp, DB_HASH_NELEM);
554 "Error setting hash nelem estimate on database %s : %d %s",
555 database, ret, db_strerror(ret));
566 flags |= DB_AUTO_COMMIT;
579 lname = strdup(database);
588 dbenv->get_home(dbenv, (
const char **) &home);
591 "Opening database %s inside environment %s - flags = %08x",
592 database,
STRNULL(home,
"(NULL)"), flags);
595 #if (DB_VERSION >= 0x040100) 597 dbp->open(dbp, NULL, database, NULL, (dbtype ? DB_BTREE : DB_HASH), flags,
600 h->
err = ret = dbp->open(dbp, database, NULL, (dbtype ? DB_BTREE : DB_HASH),
605 ZE_LogMsgError(0,
"Error opening database %s : %d %s", database, ret,
610 if ((h->
database = strdup(database)) == NULL)
622 for (i = 0; i <
DIMDB; i++) {
674 if ((h->dbc != NULL) && (h->dbc->c_close != NULL))
675 h->dbc->c_close(h->dbc);
677 if ((h->dbh != NULL) && (h->dbh->close != NULL))
678 h->dbh->close(h->dbh, 0);
706 if ((h->
err = ret = h->dbh->truncate(h->dbh, NULL, &count, 0)) == 0) {
731 if ((h->
err = ret = h->dbh->sync(h->dbh, 0)) == 0) {
760 memset(&key, 0,
sizeof (key));
761 memset(&data, 0,
sizeof (data));
764 key.size = strlen(k) + 1;
765 key.ulen = strlen(k) + 1;
766 key.flags = DB_DBT_USERMEM;
770 data.flags = DB_DBT_USERMEM;
772 if ((h->
err = ret = h->dbh->put(h->dbh, NULL, &key, &data, 0)) == 0) {
813 memset(&key, 0,
sizeof (key));
814 memset(&data, 0,
sizeof (data));
816 if ((buf = malloc(szd)) == NULL) {
823 key.size = strlen(k) + 1;
824 key.ulen = strlen(k) + 1;
825 key.flags = DB_DBT_USERMEM;
829 data.flags = DB_DBT_USERMEM;
831 if ((h->
err = ret = h->dbh->get(h->dbh, NULL, &key, &data, 0)) == 0) {
836 memcpy(d, data.data,
MIN(szd - 1, data.size));
838 if (szd >= data.size)
840 memcpy(d, data.data, szd);
843 if (ret != DB_NOTFOUND)
871 memset(&key, 0,
sizeof (key));
874 key.size = strlen(k) + 1;
876 if ((h->
err = ret = h->dbh->del(h->dbh, NULL, &key, 0)) == 0) {
900 return (pthread_mutex_lock(&h->
dbmutex) == 0);
911 return (pthread_mutex_unlock(&h->
dbmutex) == 0);
941 DB_ENV *dbenv = NULL;
947 if (h->dbc == NULL) {
954 if (!h->rdonly && !rdonly && dbenv != NULL) {
959 ret = dbenv->txn_begin(dbenv, NULL, &h->dbtxn, 0);
970 if ((h->
err = ret = h->dbh->cursor(h->dbh, h->dbtxn, &dbcp, 0)) != 0) {
980 return (h->dbc != NULL);
1003 if (h->dbc != NULL) {
1004 ret = h->dbc->c_close(h->dbc);
1010 if (h->dbtxn != NULL && h->dbenv != NULL) {
1012 ret = h->dbtxn->commit(h->dbtxn, 0);
1014 ZE_LogMsgError(0,
"Error commiting transaction on %s database : %s",
1018 h->dbtxn->abort(h->dbtxn);
1058 memset(&key, 0,
sizeof (key));
1059 memset(&data, 0,
sizeof (data));
1061 if ((buf = malloc(szd)) == NULL) {
1067 key.size = strlen(k) + 1;
1069 key.flags = DB_DBT_USERMEM;
1073 data.flags = DB_DBT_USERMEM;
1075 flags = (key.size > 0 ? DB_SET_RANGE : DB_FIRST);
1077 if ((h->
err = ret = h->dbc->c_get(h->dbc, &key, &data, flags)) == 0) {
1082 if (szk >= key.size)
1084 memcpy(k, key.data, szk);
1089 memcpy(d, data.data,
MIN(szd - 1, data.size));
1091 if (szd >= data.size)
1093 memcpy(d, data.data, szd);
1096 if (ret != DB_NOTFOUND)
1133 memset(&key, 0,
sizeof (key));
1134 memset(&data, 0,
sizeof (data));
1135 if ((buf = malloc(szd)) == NULL) {
1142 key.size = strlen(k) + 1;
1144 key.flags = DB_DBT_USERMEM;
1147 data.ulen = data.size;
1148 data.flags = DB_DBT_USERMEM;
1152 if ((h->
err = ret = h->dbc->c_get(h->dbc, &key, &data, flags)) == 0) {
1156 if (szk >= key.size)
1158 memcpy(k, key.data, szk);
1162 memcpy(d, data.data,
MIN(szd - 1, data.size));
1164 if (szd >= data.size)
1166 memcpy(d, data.data, szd);
1169 if (ret != DB_NOTFOUND)
1170 ZE_LogMsgError(0,
"Error getting next record (%s) from %s DB : %s",
1198 if ((h->
err = ret = h->dbc->c_del(h->dbc, 0)) != 0) {
1199 if (ret != DB_NOTFOUND)
1272 if (h->dbh->stat_print(h->dbh, 0) == 0)
1275 if (h->dbh->stat(h->dbh, NULL, (
void *) st, 0) == 0)
1311 if (fstat(h->dbfd, &st) == 0) {
1312 if (h->mtime != 0) {
1316 if (st.st_mtime > h->mtime) {
1322 if ((dbp != NULL) && (dbp->close != NULL))
1324 if ((h->dbc != NULL) && (h->dbc->c_close != NULL))
1325 h->dbc->c_close(h->dbc);
1327 #if (DB_VERSION >= 0x040100) 1328 if ((h->
err = ret = dbp->open(dbp, NULL, h->
database, NULL,
1329 (h->dbtype ? DB_BTREE : DB_HASH),
1330 h->rdonly ? DB_RDONLY : DB_CREATE,
1333 if ((h->
err = ret = dbp->open(dbp, h->
database, NULL,
1334 (h->dbtype ? DB_BTREE : DB_HASH),
1335 h->rdonly ? DB_RDONLY : DB_CREATE,
1344 dbp->set_bt_compare(dbp, bt_compare_fcn);
1347 h->mtime = st.st_mtime;
1350 h->mtime = st.st_mtime;
bool zeDb_Unlock(ZEDB_T *h)
Database unlock.
bool zeDb_Stat(ZEDB_T *h, ZEDB_STAT_T **st)
bool zeDb_AddRec(ZEDB_T *h, char *k, void *d, size_t sz)
#define MUTEX_UNLOCK(mutex)
bool zeDb_Empty(ZEDB_T *h)
#define MUTEX_LOCK(mutex)
#define ZE_LogMsgError(level,...)
bool zeDb_CursorGetFirst(ZEDB_T *h, char *k, size_t szk, void *d, size_t szd)
bool zeDb_DelRec(ZEDB_T *h, char *k)
#define DB_ENV_CACHE_SIZE
bool zeDb_Open(ZEDB_T *h, ZEDB_ENV_T *dbenv, char *database, int mode, bool rdonly, bool dbtype, size_t dbcache)
size_t zeStr2size(char *s, int *error, size_t dval)
bool zeDb_Close(ZEDB_T *h)
size_t zeDb_SetDefaultCacheSize(size_t size)
ZEDB_ENV_T * zeDb_EnvOpen(char *home, bool rdonly, int dt_chkpoint)
bool zeDb_EnvClose(ZEDB_ENV_T *dbenv)
#define ZE_MessageInfo(level,...)
bool zeDb_GetRec(ZEDB_T *h, char *k, void *d, size_t szd)
#define ZE_LogSysError(...)
#define DB_LK_MAX_LOCKERS
#define ZE_MessageError(level,...)
size_t zeDb_SetDefaults(int which, size_t value)
bool zeDb_CursorOpen(ZEDB_T *h, bool rdonly)
int zeDb_errno(ZEDB_T *h)
bool zeDb_cursor_get(ZEDB_T *h, char *k, void *d, size_t sz, u_int32_t where)
bool zeDb_CheckLastMTime(ZEDB_T *)
bool zeDb_CursorDel(ZEDB_T *h)
bool zeDb_CursorClose(ZEDB_T *h)
#define STRCASEEQUAL(a, b)
unsigned long zeStr2ulong(char *s, int *error, unsigned long dval)
#define DB_LK_MAX_OBJECTS
bool zeDb_CursorSetRange(ZEDB_T *h, char *k, void *d, size_t sz, u_int32_t where)
bool zeDb_CursorGetNext(ZEDB_T *h, char *k, size_t szk, void *d, size_t szd)
bool zeDb_Flush(ZEDB_T *h)
bool zeDb_Lock(ZEDB_T *h)
Database lock.