static int bdb_dump(WT_CURSOR *wtcursor, WT_SESSION *session, const char *tag) { CURSOR_SOURCE *cursor; DB *db; DBC *dbc; DBT *key, *value; WT_EXTENSION_API *wt_api; int ret = 0; cursor = (CURSOR_SOURCE *)wtcursor; wt_api = cursor->wt_api; db = cursor->db; key = &cursor->key; value = &cursor->value; if ((ret = db->cursor(db, NULL, &dbc, 0)) != 0) ERET(wt_api, session, WT_ERROR, "Db.cursor: %s", db_strerror(ret)); printf("==> %s\n", tag); while ((ret = dbc->get(dbc, key, value, DB_NEXT)) == 0) if (cursor->config_recno) printf("\t%llu/%.*s\n", (unsigned long long)*(db_recno_t *)key->data, (int)value->size, (char *)value->data); else printf("\t%.*s/%.*s\n", (int)key->size, (char *)key->data, (int)value->size, (char *)value->data); if (ret != DB_NOTFOUND) ERET(wt_api, session, WT_ERROR, "DbCursor.get: %s", db_strerror(ret)); return (0); }
static int kvs_cursor_close(WT_CURSOR *wtcursor) { CURSOR_SOURCE *cursor; DATA_SOURCE *ds; DB *db; DBC *dbc; WT_EXTENSION_API *wt_api; WT_SESSION *session; int ret = 0; session = wtcursor->session; cursor = (CURSOR_SOURCE *)wtcursor; ds = cursor->ds; wt_api = cursor->wt_api; dbc = cursor->dbc; cursor->dbc = NULL; if (dbc != NULL && (ret = dbc->close(dbc)) != 0) ERET(wt_api, session, WT_ERROR, "DbCursor.close: %s", db_strerror(ret)); db = cursor->db; cursor->db = NULL; if (db != NULL && (ret = db->close(db, 0)) != 0) ERET(wt_api, session, WT_ERROR, "Db.close: %s", db_strerror(ret)); free(wtcursor); if ((ret = writelock(wt_api, session, &ds->rwlock)) != 0) return (ret); --ds->open_cursors; if ((ret = unlock(wt_api, session, &ds->rwlock)) != 0) return (ret); return (0); }
static int kvs_session_create(WT_DATA_SOURCE *wtds, WT_SESSION *session, const char *uri, WT_CONFIG_ARG *config) { DATA_SOURCE *ds; DB *db; DBTYPE type; WT_CONFIG_ITEM v; WT_EXTENSION_API *wt_api; int ret = 0; const char *name; ds = (DATA_SOURCE *)wtds; wt_api = ds->wt_api; /* Get the object name */ if ((ret = uri2name(wt_api, session, uri, &name)) != 0) return (ret); /* Check key/value formats */ if ((ret = wt_api->config_get(wt_api, session, config, "key_format", &v)) != 0) ERET(wt_api, session, ret, "key_format configuration: %s", wt_api->strerror(wt_api, session, ret)); type = v.len == 1 && v.str[0] == 'r' ? DB_RECNO : DB_BTREE; /* Create the Berkeley DB table */ if ((ret = db_create(&db, ds->dbenv, 0)) != 0) ERET(wt_api, session, WT_ERROR, "db_create: %s", db_strerror(ret)); if ((ret = db->open(db, NULL, name, NULL, type, DB_CREATE, 0)) != 0) ERET(wt_api, session, WT_ERROR, "Db.open: %s", uri, db_strerror(ret)); if ((ret = db->close(db, 0)) != 0) ERET(wt_api, session, WT_ERROR, "Db.close", db_strerror(ret)); return (0); }
static int db3stat(dbiIndex dbi, unsigned int flags) { DB * db = dbi->dbi_db; #if (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3) DB_TXN * txnid = NULL; #endif int rc = 0; assert(db != NULL); #if defined(DB_FAST_STAT) if (flags) flags = DB_FAST_STAT; else #endif flags = 0; dbi->dbi_stats = _free(dbi->dbi_stats); #if (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3) rc = db->stat(db, txnid, &dbi->dbi_stats, flags); #else rc = db->stat(db, &dbi->dbi_stats, flags); #endif rc = cvtdberr(dbi, "db->stat", rc, _debug); return rc; }
static int databaseRemove(const char* file, const char* database, int flags) { #ifdef TRACE_FUNC_CALLS LOG_TRACE_IN; #endif DB* localDbHandle; int ret; // Removing the database file db_create(&localDbHandle, NULL, 0); ret = localDbHandle->remove(localDbHandle, file, database, flags); #ifdef TRACE_FUNC_CALLS LOG_TRACE_OUT; #endif return ret; }
/* opening the MindMap Database */ static int ooMindMap_open(struct ooMindMap *self, const char *dbpath) { int ret; DB *dbp = self->_storage; if (!dbp) return oo_FAIL; /* open the database */ if ((ret = dbp->open(dbp, /* DB structure pointer */ NULL, /* Transaction pointer */ dbpath, /* On-disk file that holds the database. */ NULL, /* Optional logical database name */ DB_BTREE, /* Database access method */ DB_CREATE, /* Open flags */ 0664)) /* File mode (using defaults) */ != oo_OK) { dbp->err(dbp, ret, "%s: open", dbpath); (void)dbp->close(dbp, 0); return oo_FAIL; } return 0; }
/* {{{ rberkeley_db_compact */ SEXP rberkeley_db_compact (SEXP _dbp, SEXP _txnid, SEXP _start, SEXP _stop, SEXP _c_data, SEXP _flags) { DB *dbp; DB_TXN *txnid; DBT start, stop, end; /*DB_COMPACT c_data;*/ u_int32_t flags; int ret; if(isNull(_txnid)) { txnid = R_ExternalPtrAddr(_txnid); } else { txnid = NULL; } if(!isNull(_start)) { memset(&start, 0, sizeof(DBT)); start.data = (unsigned char *)RAW(_start); start.size = length(_start); } if(!isNull(_stop)) { memset(&stop, 0, sizeof(DBT)); stop.data = (unsigned char *)RAW(_stop); stop.size = length(_stop); } flags = (u_int32_t)INTEGER(_flags)[0]; /*memset(&end, 0, sizeof(end));*/ dbp = R_ExternalPtrAddr(_dbp); if(R_ExternalPtrTag(_dbp) != RBerkeley_DB || dbp == NULL) error("invalid 'db' handle"); ret = dbp->compact(dbp, txnid, &start, &stop, NULL, flags, &end); return ScalarInteger(ret); }
void var_register(const QString& id,unsigned short* p,bool persist) { //产生内存变量 struct varUShort t; unsigned short val= 0; //id是str t.id = id; t.p = p; //persist false普通变量 true 保持变量 if(persist) { //在sql中查找是否有变量,如果没有则产生条目,否者将变量值读入到内存变量 if(mydb.GetValue(id,val)) { *p = val; t.sqlval = val; } else { printf("newval\n"); mydb.NewId(id,*p,""); t.sqlval = *p; } } else { t.sqlval = *p; } //内存列表 varUShortlist.append(t); }
/*@ * Walk through the database and return the highest iid we have seen. * If this is a RECNO database this can probably be done more cheaply * but for now we will make this usable regardless of the index impl */ iid_t storage_get_max_iid(struct storage * s) { int ret; DB *dbp = s->db; DBC *dbcp; DBT key, data; iid_t max_iid = 0; /* Acquire a cursor for the database. */ if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) != 0) { dbp->err(dbp, ret, "DB->cursor"); return (1); } /* Re-initialize the key/data pair. */ memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); /* Walk through the database and print out the key/data pairs. */ while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) { assert(data.size = sizeof(iid_t)); max_iid = *(iid_t *)key.data; } if (ret != DB_NOTFOUND) { dbp->err(dbp, ret, "DBcursor->get"); return 0; } /* Close the cursor. */ if ((ret = dbcp->c_close(dbcp)) != 0) { dbp->err(dbp, ret, "DBcursor->close"); } return (max_iid); }
static void cleanup(pam_handle_t *pamh, void *data, int err) { DB* db; if (NULL != data) { abl_context *context = data; log_debug(context->args, "In cleanup, err is %08x", err); if (err && (err & PAM_DATA_REPLACE) == 0) { log_debug(context->args, "record returned %d",record_attempt(context)); } config_free(context->args); free(context->args); db = context->info->utdb; db->close(db,0); db = context->info->usdb; db->close(db,0); db = context->info->htdb; db->close(db,0); db = context->info->hsdb; db->close(db,0); free(context->info); free(context); } }
int main() { DB *db; DB *uiddb; int ret; db_create(&db, NULL, 0); db->open(db, NULL, NULL, "data", DB_BTREE, DB_CREATE, 0); db_create(&uiddb, NULL, 0); uiddb->open(uiddb, NULL, NULL, "byuid", DB_BTREE, DB_CREATE, 0); ret = db->associate(db, NULL, uiddb, byuid_callback, 0); printf("associate: %d\n", ret); user_t u; strcpy(u.user, "jls"); u.uid = 1000; strcpy(u.path, "/home/jls"); DBT key, value; memset(&key, 0, sizeof(DBT)); memset(&value, 0, sizeof(DBT)); key.data = u.user; key.size = strlen(u.user); value.data = &u; value.size = sizeof(u); ret = db->put(db, NULL, &key, &value, 0); printf("put: %d\n", ret); memset(&value, 0, sizeof(value)); ret = db->get(db, NULL, &key, &value, 0); printf("put: %d\n", ret); printf("Uid: %d\n", ((user_t*)value.data)->uid); memset(&value, 0, sizeof(value)); int uid = 1000; key.data = &uid; key.size = sizeof(int); uiddb->get(uiddb, NULL, &key, &value, 0); printf("Secondary lookup: user=%s\n", ((user_t*)value.data)->user); return 0; }
static char * map_db_get_entry(void *hdl, char *key, size_t *len) { int ret; DBT dbk; DBT dbv; DB *db = hdl; char *result = NULL; dbk.data = key; dbk.size = strlen(dbk.data) + 1; if ((ret = db->get(db, &dbk, &dbv, 0)) != 0) return NULL; result = calloc(dbv.size, 1); if (result == NULL) fatal("calloc"); (void)strlcpy(result, dbv.data, dbv.size); *len = dbv.size; return result; }
QString UtenteBasic::userSearch(DB &d) const { int contautenti=1; QString risposta=""; for (std::map<QString,Utente*>::iterator it=d.begin(); it!=d.end(); ++it) { if (it->first==un.login) continue; if (rete->is_in(it->second->un.login)) { risposta+="\n\nutente amico, puoi vedere il profilo intero anche se sei basic: "+it->second->un.login+ "\n"; contautenti++; risposta+=it->second->info->visualizza(); risposta+=it->second->rete->get_rete(); } else { risposta+="\n\nutente: "+QString::number(contautenti)+ "\n"; contautenti++; risposta+=("Nome: " +(it->second->info->Nome)+"\n"); risposta+=("Cognome: "+(it->second->info->Cognome)+"\n"); } } if (risposta=="") return "Spiacente, nessun risultato :("; return risposta; }
/* {{{ rberkeley_db_set_msgfile */ SEXP rberkeley_db_set_msgfile (SEXP _dbp, SEXP _msgfile) { DB *dbp; FILE *msgfile = NULL; dbp = R_ExternalPtrAddr(_dbp); if(R_ExternalPtrTag(_dbp) != RBerkeley_DB || dbp == NULL) error("invalid 'db' handle"); if(!isNull(_msgfile)) { msgfile = fopen(CHAR(STRING_ELT(_msgfile,0)),"w"); if(msgfile == NULL) error("open failed!\n"); } else msgfile = NULL; dbp->set_msgfile(dbp, msgfile); if(msgfile == NULL) { return R_NilValue; } else { SEXP ptr = R_MakeExternalPtr(msgfile, install("msgfile"), ScalarLogical(TRUE)); R_RegisterCFinalizer(ptr, (R_CFinalizer_t) rberkeley_fclose); return ptr; } }
int put (void **db, void *key, int key_len, void *value, int value_len) { int ret; DBT db_key, db_data; DB *dbp = *db; memset(&db_key, 0, sizeof(db_key)); memset(&db_data, 0, sizeof(db_data)); db_key.data = key; db_key.size = key_len; db_data.data = value; db_data.size = value_len; if ((ret = dbp->put(dbp, NULL, &db_key, &db_data, 0)) == 0) printf("db: %s: key stored.\n", (char *)db_key.data); else { dbp->err(dbp, ret, "DB->put"); exit(1); } return ES_OK; }
static krb5_error_code ctx_unlock(krb5_context context, krb5_db2_context *dbc) { krb5_error_code retval; DB *db; retval = osa_adb_release_lock(dbc->policy_db); if (retval) return retval; if (!dbc->db_locks_held) /* lock already unlocked */ return KRB5_KDB_NOTLOCKED; db = dbc->db; if (--(dbc->db_locks_held) == 0) { db->close(db); dbc->db = NULL; dbc->db_lock_mode = 0; retval = krb5_lock_file(context, dbc->db_lf_file, KRB5_LOCKMODE_UNLOCK); } return retval; }
int main() { DB *dbp; DB_ENV *dbenv; DB_TXN *xid; DBT key, data; const unsigned int INSERT_NUM = 100; char value[22]; /* should be log INSERT_NUM */ int ret, i, t_ret; env_dir_create(); env_open(&dbenv); if ((ret = db_create(&dbp, dbenv, 0)) != 0) { fprintf(stderr, "db_create: %s\n", db_strerror(ret)); exit (1); } dbenv->txn_begin(dbenv, NULL, &xid, 0); if ((ret = dbp->open(dbp, xid, DATABASE, NULL, DB_BTREE, DB_CREATE, 0664)) != 0) { dbp->err(dbp, ret, "%s", DATABASE); goto err; } memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); key.size = sizeof(int); key.data = malloc(sizeof(int)); data.data = value; for( i = 0; i < INSERT_NUM; i++ ) { *((int*)key.data) = i; data.size = sizeof(char)*strlen(data.data); sprintf(value, "value: %u\n", i); dbp->put(dbp, xid, &key, &data, 0); } xid->commit(xid, 0); dbenv->txn_begin(dbenv, NULL, &xid, 0); for( i = 0; i < INSERT_NUM; i++ ) { *((int*)key.data) = i; dbp->get(dbp, xid, &key, &data, 0); printf("db: %u: key retrieved: data was %s.\n", *((int*)key.data), (char *)data.data); } xid->abort(xid); err: if ((t_ret = dbp->close(dbp, 0)) != 0 && ret == 0) ret = t_ret; return 0; }
static int db3cget(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data, unsigned int flags) { DB * db = dbi->dbi_db; int _printit; int rc; assert(db != NULL); if (dbcursor == NULL) { /* XXX duplicates require cursors. */ rc = db->get(db, dbi->dbi_txnid, key, data, 0); /* XXX DB_NOTFOUND can be returned */ _printit = (rc == DB_NOTFOUND ? 0 : _debug); rc = cvtdberr(dbi, "db->get", rc, _printit); } else { /* XXX db3 does DB_FIRST on uninitialized cursor */ rc = dbcursor->c_get(dbcursor, key, data, flags); /* XXX DB_NOTFOUND can be returned */ _printit = (rc == DB_NOTFOUND ? 0 : _debug); rc = cvtdberr(dbi, "dbcursor->c_get", rc, _printit); } return rc; }
int uriindex_delete (char uri[], char subname[]) { DB dbpArray; DB *dbp = NULL; DBT key; int ret; int forreturn = 1; struct uriindexFormat uriindex; if (!uriindex_open(&dbp,subname, DB_CREATE)) { fprintf(stderr,"can't open uriindex\n"); return 0; } //resetter minne memset(&key, 0, sizeof(DBT)); //legger inn datane i bdb strukturen key.data = uri; key.size = strlen(uri); if ((ret = dbp->del(dbp, NULL, &key, 0)) == 0) { forreturn = 1; } else { dbp->err(dbp, ret, "DBcursor->get"); forreturn = 0; } uriindex_close(&dbp); return forreturn; }
// Celest int guild_getexp(struct map_session_data *sd,int exp) { struct guild *g; struct guild_expcache *c; nullpo_retr(0, sd); if (sd->status.guild_id == 0 || (g = guild_search(sd->status.guild_id)) == NULL) return 0; c = guild_expcache_db->ensure(guild_expcache_db, i2key(sd->status.char_id), create_expcache, sd); if (c->exp > UINT_MAX - exp) c->exp = UINT_MAX; else c->exp += exp; return exp; }
int b_curalloc(int argc, char *argv[]) { extern char *optarg; extern int optind, __db_getopt_reset; DB *dbp; DBC *curp; int ch, i, count; count = 100000; __db_getopt_reset = 1; while ((ch = getopt(argc, argv, "c:")) != EOF) switch (ch) { case 'c': count = atoi(optarg); break; case '?': default: return (b_curalloc_usage()); } argc -= optind; argv += optind; if (argc != 0) return (b_curalloc_usage()); /* Create the database. */ DB_BENCH_ASSERT(db_create(&dbp, NULL, 0) == 0); dbp->set_errfile(dbp, stderr); #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 1) DB_BENCH_ASSERT(dbp->open( dbp, NULL, TESTFILE, NULL, DB_BTREE, DB_CREATE, 0666) == 0); #else DB_BENCH_ASSERT( dbp->open(dbp, TESTFILE, NULL, DB_BTREE, DB_CREATE, 0666) == 0); #endif /* Allocate a cursor count times. */ TIMER_START; for (i = 0; i < count; ++i) { DB_BENCH_ASSERT(dbp->cursor(dbp, NULL, &curp, 0) == 0); DB_BENCH_ASSERT(curp->c_close(curp) == 0); } TIMER_STOP; printf("# %d cursor allocations\n", count); TIMER_DISPLAY(count); DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0); return (0); }
int TestPartNumber(CuTest *ct) { DB_ENV *dbenv; DB *dbp; DBT *keys; u_int32_t i; dbenv = NULL; dbp = NULL; keys = NULL; nparts = 1000000; CuAssertTrue(ct, (keys = malloc((nparts - 1) * sizeof(DBT))) != NULL); memset(keys, 0, (nparts - 1) * sizeof(DBT)); /* Assign data to the keys. */ for (i = 0 ; i < (nparts - 1); i++) { CuAssertTrue(ct, (keys[i].data = malloc(sizeof(u_int32_t))) != NULL); memcpy(keys[i].data, &i, sizeof(u_int32_t)); keys[i].size = sizeof(u_int32_t); } /* Partition number is less than 2. */ CuAssertTrue(ct, create_db(&dbenv, &dbp, 1, ct) == 0); CuAssertTrue(ct, dbp->set_partition(dbp, 1, keys, NULL) != 0); /* Partition number is bigger than the limit 1000000. */ CuAssertTrue(ct, dbp->set_partition(dbp, nparts + 1, keys, NULL) == EINVAL); /* Partition number is equal to the limit 1000000. */ CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0); /* Partition keys do not fix into a single database page. */ CuAssertTrue(ct, dbp->set_pagesize(dbp, 512) == 0); CuAssertTrue(ct, dbp->set_partition(dbp, 800, keys, NULL) == 0); CuAssertTrue(ct, dbp->open(dbp, NULL, "test.db", NULL, DB_BTREE, DB_CREATE, 0644) == 0); CuAssertTrue(ct, put_data(dbp) == 0); CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0); for (i = 0 ; i < (nparts - 1); i++) free(keys[i].data); free(keys); return (0); }
int smf_lookup_db4_update(const char *database, const char *key, const char *value) { DB *dbp; DBT db_key, db_data; int ret; /* Initialize the structure. This database is not opened in an environment, * so the environment pointer is NULL. */ if ((ret = db_create(&dbp, NULL, 0)) != 0) { TRACE(TRACE_ERR, "db_create: %s\n", db_strerror(ret)); return -1; } /* set page- and cachesize */ if ((ret = dbp->set_pagesize(dbp, 1024)) != 0) { printf("db->open: %s\n", db_strerror(ret)); return(-1); } if ((ret = dbp->set_cachesize(dbp, 0, 32 * 1024, 0)) != 0) { printf("db->open: %s\n", db_strerror(ret)); return(-1); } /* open the database */ ret = dbp->open(dbp, NULL, database, NULL, DB_HASH, DB_CREATE, 0); if (ret != 0) { TRACE(TRACE_ERR,"DB: %s",db_strerror(ret)); return -1; } memset(&db_key, 0, sizeof(DBT)); db_key.data = (char*)key; db_key.size = strlen(key) + 1; memset(&db_data, 0, sizeof(DBT)); db_data.data = (char*)value; db_data.size = strlen(value) + 1; ret = dbp->put(dbp, NULL, &db_key, &db_data, 0); if (ret == 0) { TRACE(TRACE_DEBUG, "[%p] update was successful [%s: %s]", dbp, key, value); } else { TRACE(TRACE_ERR, "[%p] failed to update database [%s: %s]: %s", dbp, key, value, db_strerror(ret)); } if (dbp != NULL) dbp->close(dbp, 0); return (ret == 0) ? ret : -1; }
static int ooMindMap_keys(struct ooMindMap *self, mindmap_size_t **ids, mindmap_size_t batch_size, mindmap_size_t batch_start) { DBT key, data; DB *dbp; DBC *dbcp; int ret; dbp = self->_storage; /* initialize the key/data pair */ memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); /* acquire a cursor for the database */ if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) != 0) { dbp->err(dbp, ret, "DB->cursor"); goto error; } /* TODO: batching */ /* walk through the database and print out the key/data pairs. */ while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) printf("%.*s : %.*s\n", (int)key.size, (char *)key.data, (int)data.size, (char *)data.data); if (ret != DB_NOTFOUND) { dbp->err(dbp, ret, "DBcursor->get"); goto error; } /* close everything down */ if ((ret = dbcp->c_close(dbcp)) != 0) { dbp->err(dbp, ret, "DBcursor->close"); goto error; } return oo_OK; error: (void)dbp->close(dbp, 0); return oo_FAIL; }
int MovieDB::InsertMovie(Movie clsMovie) { DB db; db.Connect(); CString csSQL; CStringArray csaMaxID; db.Select("select top 1 MovieID from MovieTable order by MovieID desc",csaMaxID); db.CloseRecordset(); csSQL.Format("insert into MovieTable values(,%d,%d,%d,%d,'%s','%s','%s','%s')",atoi(csaMaxID.GetAt(0))+1, clsMovie.iTimeLength,clsMovie.iLength,clsMovie.iWidth,clsMovie.CStrYear,clsMovie.CStrMovieType,clsMovie.CStrPath,clsMovie.CStrFileName); if(db.Execute(csSQL)==FALSE) { return 0; } db.DisConnect(); return 1; }
int open_db(DB** pDb, const char* pcszDBName, int nClear, int nDuplicate){ DB* db; int nRet; *pDb = NULL; opendb: /* Initialize BDB handle */ if ( db_create(&db, NULL, 0) ){ write_log(LT_BOTH, "Error: Can't init BDB," "when open database %s!\n", pcszDBName ) ; return 0; } /* if need clear table */ if ( nClear == 1 ){ db->remove(db, pcszDBName, NULL, 0); nClear = 0; goto opendb; } /* set up error handling for this database */ db->set_errcall(db, db_err_handler); db->set_errpfx(db, "jau_db"); if ( nDuplicate == 1 ) db->set_flags(db, DB_DUPSORT); /* Now open the database */ nRet = db->open(db, NULL, pcszDBName, NULL, DB_BTREE, DB_CREATE, 0); if (nRet != 0) { write_log(LT_BOTH, "Error: Can't open database %s!\n", pcszDBName); db->close(db, 0); return 0; } *pDb = db; return 1; }
int dbfe_opendb (DB_ENV *dbe, DB **dbp, str filename, int flags, int mode = 0664, bool dups = false) { int r (-1); r = db_create (dbp, dbe, 0); if (r) return r; DB *db = *dbp; db->set_pagesize (db, 16 * 1024); /* Secondary databases, for example, require duplicates */ if (dups && (r = db->set_flags (db, DB_DUPSORT)) != 0) { (void)db->close(db, 0); dbe->err (dbe, r, "db->set_flags: DB_DUP"); return r; } /* the below seems to cause the db to grow much larger. */ // db->set_bt_minkey(db, 60); #if ((DB_VERSION_MAJOR < 4) || ((DB_VERSION_MAJOR == 4) && (DB_VERSION_MINOR < 1))) r = db->open (db, filename.cstr (), NULL, DB_BTREE, flags, mode); #else if (!dbe) { r = db->open (db, NULL, filename.cstr (), NULL, DB_BTREE, flags, mode); } else { // Sleepycat 4.1 and greater force us to open the DB inside a // transaction the open suceeds in either case, but if the open // isn't surrounded by a transaction, later calls that use a // transaction will fail DB_TXN *t = NULL; r = dbe->txn_begin (dbe, NULL, &t, 0); if (r || !t) return r; r = db->open (db, t, filename.cstr (), NULL, DB_BTREE, flags, mode); r = t->commit (t, 0); #endif } return r; }
static int db_servent(void *retval, void *mdata, va_list ap) { char buf[BUFSIZ]; DBT key, data, *result; DB *db; struct db_state *st; int rv; int stayopen; enum nss_lookup_type how; char *name; char *proto; int port; struct servent *serv; char *buffer; size_t bufsize; int *errnop; name = NULL; proto = NULL; how = (enum nss_lookup_type)mdata; switch (how) { case nss_lt_name: name = va_arg(ap, char *); proto = va_arg(ap, char *); break; case nss_lt_id: port = va_arg(ap, int); proto = va_arg(ap, char *); break; case nss_lt_all: break; default: return NS_NOTFOUND; }; serv = va_arg(ap, struct servent *); buffer = va_arg(ap, char *); bufsize = va_arg(ap, size_t); errnop = va_arg(ap,int *); *errnop = db_getstate(&st); if (*errnop != 0) return (NS_UNAVAIL); if (how == nss_lt_all && st->keynum < 0) return (NS_NOTFOUND); if (st->db == NULL) { st->db = dbopen(_PATH_SERVICES_DB, O_RDONLY, 0, DB_HASH, NULL); if (st->db == NULL) { *errnop = errno; return (NS_UNAVAIL); } } stayopen = (how == nss_lt_all) ? 1 : st->stayopen; db = st->db; do { switch (how) { case nss_lt_name: key.data = buf; if (proto == NULL) key.size = snprintf(buf, sizeof(buf), "\376%s", name); else key.size = snprintf(buf, sizeof(buf), "\376%s/%s", name, proto); key.size++; if (db->get(db, &key, &data, 0) != 0 || db->get(db, &data, &key, 0) != 0) { rv = NS_NOTFOUND; goto db_fin; } result = &key; break; case nss_lt_id: key.data = buf; port = htons(port); if (proto == NULL) key.size = snprintf(buf, sizeof(buf), "\377%d", port); else key.size = snprintf(buf, sizeof(buf), "\377%d/%s", port, proto); key.size++; if (db->get(db, &key, &data, 0) != 0 || db->get(db, &data, &key, 0) != 0) { rv = NS_NOTFOUND; goto db_fin; } result = &key; break; case nss_lt_all: key.data = buf; key.size = snprintf(buf, sizeof(buf), "%d", st->keynum++); key.size++; if (db->get(db, &key, &data, 0) != 0) { st->keynum = -1; rv = NS_NOTFOUND; goto db_fin; } result = &data; break; } rv = parse_result(serv, buffer, bufsize, result->data, result->size - 1, errnop); } while (!(rv & NS_TERMINATE) && how == nss_lt_all); db_fin: if (!stayopen && st->db != NULL) { db->close(db); st->db = NULL; } if (rv == NS_SUCCESS && retval != NULL) *(struct servent **)retval = serv; return (rv); }
/* * csv_secondary_open -- * Open any secondary indices. */ int csv_secondary_open() { DB *sdb; DbField *f; int ret, (*fcmp)(DB *, const DBT *, const DBT *); /* * Create secondary database handles. */ for (f = fieldlist; f->name != NULL; ++f) { if (f->indx == 0) continue; if ((ret = db_create(&sdb, dbenv, 0)) != 0) { dbenv->err(dbenv, ret, "db_create"); return (1); } sdb->app_private = f; /* Keys are small, use a relatively small page size. */ if ((ret = sdb->set_pagesize(sdb, 8 * 1024)) != 0) { dbenv->err(dbenv, ret, "DB->set_pagesize"); return (1); } /* * Sort the database based on the underlying type. Skip * strings, Berkeley DB defaults to lexicographic sort. */ switch (f->type) { case DOUBLE: fcmp = compare_double; break; case ULONG: fcmp = compare_ulong; break; case NOTSET: case STRING: default: fcmp = NULL; break; } if (fcmp != NULL && (ret = sdb->set_bt_compare(sdb, fcmp)) != 0) { dbenv->err(dbenv, ret, "DB->set_bt_compare"); return (1); } /* Always configure secondaries for sorted duplicates. */ if ((ret = sdb->set_flags(sdb, DB_DUPSORT)) != 0) { dbenv->err(dbenv, ret, "DB->set_flags"); return (1); } if ((ret = sdb->set_dup_compare(sdb, compare_ulong)) != 0) { dbenv->err(dbenv, ret, "DB->set_dup_compare"); return (1); } if ((ret = sdb->open( sdb, NULL, f->name, NULL, DB_BTREE, DB_CREATE, 0)) != 0) { dbenv->err(dbenv, ret, "DB->open: %s", f->name); return (1); } if ((ret = sdb->associate( db, NULL, sdb, secondary_callback, DB_CREATE)) != 0) { dbenv->err(dbenv, ret, "DB->set_associate"); return (1); } f->secondary = sdb; } return (0); }
int b_load(int argc, char *argv[]) { extern char *optarg; extern int optind, __db_getopt_reset; DB *dbp; DBTYPE type; DBT key, data; #if DB_VERSION_MAJOR > 5 || (DB_VERSION_MAJOR == 5 && DB_VERSION_MINOR >= 2) DB_HEAP_RID rid; #endif db_recno_t recno; u_int32_t cachesize; int ch, i, count, duplicate; char *ts, buf[32]; type = DB_BTREE; cachesize = MEGABYTE; count = 100000; duplicate = 0; ts = "Btree"; __db_getopt_reset = 1; while ((ch = getopt(argc, argv, "C:c:dt:")) != EOF) switch (ch) { case 'C': cachesize = (u_int32_t)atoi(optarg); break; case 'c': count = atoi(optarg); break; case 'd': duplicate = 1; break; case 't': switch (optarg[0]) { case 'B': case 'b': ts = "Btree"; type = DB_BTREE; break; case 'H': case 'h': if (optarg[1] == 'E' || optarg[1] == 'e') { #if DB_VERSION_MAJOR > 5 || (DB_VERSION_MAJOR == 5 && DB_VERSION_MINOR >= 2) if (b_util_have_heap()) return (0); ts = "Heap"; type = DB_HEAP; #else fprintf(stderr, "b_curwalk: Heap is not supported! \n"); return (EXIT_SUCCESS); #endif } else { if (b_util_have_hash()) return (0); ts = "Hash"; type = DB_HASH; } break; case 'Q': case 'q': if (b_util_have_queue()) return (0); ts = "Queue"; type = DB_QUEUE; break; case 'R': case 'r': ts = "Recno"; type = DB_RECNO; break; default: return (b_load_usage()); } break; case '?': default: return (b_load_usage()); } argc -= optind; argv += optind; if (argc != 0) return (b_load_usage()); /* Usage. */ #if DB_VERSION_MAJOR > 5 || (DB_VERSION_MAJOR == 5 && DB_VERSION_MINOR >= 2) if (duplicate && (type == DB_QUEUE || type == DB_RECNO || type == DB_HEAP)) { fprintf(stderr, "b_load: Queue, Recno and Heap don't support duplicates\n"); return (b_load_usage()); } #else if (duplicate && (type == DB_QUEUE || type == DB_RECNO)) { fprintf(stderr, "b_load: Queue an Recno don't support duplicates\n"); return (b_load_usage()); } #endif #if DB_VERSION_MAJOR < 3 || DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR < 1 /* * DB versions prior to 3.1.17 didn't have off-page duplicates, so * this test can run forever. */ if (duplicate) return (0); #endif /* Create the database. */ DB_BENCH_ASSERT(db_create(&dbp, NULL, 0) == 0); DB_BENCH_ASSERT(dbp->set_cachesize(dbp, 0, cachesize, 0) == 0); if (duplicate) DB_BENCH_ASSERT(dbp->set_flags(dbp, DB_DUP) == 0); dbp->set_errfile(dbp, stderr); /* Set record length for Queue. */ if (type == DB_QUEUE) DB_BENCH_ASSERT(dbp->set_re_len(dbp, 20) == 0); #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 1) DB_BENCH_ASSERT( dbp->open(dbp, NULL, TESTFILE, NULL, type, DB_CREATE, 0666) == 0); #else DB_BENCH_ASSERT( dbp->open(dbp, TESTFILE, NULL, type, DB_CREATE, 0666) == 0); #endif /* Initialize the data. */ memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); /* Insert count in-order key/data pairs. */ TIMER_START; if (duplicate) { key.size = 10; key.data = "01234567890123456789"; data.data = buf; data.size = 20; for (i = 0; i < count; ++i) { (void)snprintf(buf, sizeof(buf), "%020d", i); DB_BENCH_ASSERT( dbp->put(dbp, NULL, &key, &data, 0) == 0); } } else { data.data = buf; data.size = 20; if (type == DB_BTREE || type == DB_HASH) { key.size = 10; key.data = buf; for (i = 0; i < count; ++i) { (void)snprintf(buf, sizeof(buf), "%010d", i); DB_BENCH_ASSERT( dbp->put(dbp, NULL, &key, &data, 0) == 0); } #if DB_VERSION_MAJOR > 5 || (DB_VERSION_MAJOR == 5 && DB_VERSION_MINOR >= 2) } else if (type == DB_HEAP) { key.data = &rid; key.size = sizeof(rid); for (i = 0; i < count; ++i) DB_BENCH_ASSERT(dbp->put(dbp, NULL, &key, &data, DB_APPEND) == 0); #endif } else { key.data = &recno; key.size = sizeof(recno); for (i = 0, recno = 1; i < count; ++i, ++recno) DB_BENCH_ASSERT( dbp->put(dbp, NULL, &key, &data, 0) == 0); } } TIMER_STOP; printf("# %d %s database in-order put of 10/20 byte key/data %sitems\n", count, ts, duplicate ? "duplicate " : ""); TIMER_DISPLAY(count); DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0); return (0); }