/* open */
JNIEXPORT jboolean JNICALL Java_tokyocabinet_HDB_open
(JNIEnv *env, jobject self, jstring path, jint omode){
if(!path){
throwillarg(env);
return false;
}
TCHDB *hdb = (TCHDB *)(intptr_t)(*env)->GetLongField(env, self, hdb_fid_ptr);
jboolean icp;
const char *tpath = (*env)->GetStringUTFChars(env, path, &icp);
if(!tpath){
throwoutmem(env);
return false;
}
bool rv = tchdbopen(hdb, tpath, omode);
if(icp) (*env)->ReleaseStringUTFChars(env, path, tpath);
return rv;
}
/**
* delete a hash database
*/
tcDatabase CreateDB(const char *dbName)
{
int ecode;
TCHDB *hdb = tchdbnew();
if (dbName == NULL)
{
dbName = "default.hdb";
}
if (!tchdbopen(hdb, dbName, HDBOWRITER | HDBOCREAT))
{
ecode = tchdbecode(hdb);
fprintf(stderr, "open error: %s\n", tchdberrmsg(ecode));
exit(-1);
}
//printf("open successfully!\n");
return (tcDatabase)hdb;
}
/* perform count command */
static int proccount(const char *path, int omode){
TCHDB *hdb = tchdbnew();
if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
tchdbsetcodecfunc(hdb, _tc_recencode, NULL, _tc_recdecode, NULL);
if(!tchdbopen(hdb, path, HDBOREADER | omode)){
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
printf("%llu\n", (unsigned long long)tchdbrnum(hdb));
if(!tchdbclose(hdb)){
if(!err) printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
/* perform write command */
int dowrite(char *name, int rnum){
TCHDB *hdb;
int i, err, len;
char buf[RECBUFSIZ];
if(showprgr) printf("<Writing Test of Hash>\n name=%s rnum=%d\n\n", name, rnum);
/* open a database */
hdb = tchdbnew();
tchdbtune(hdb, rnum * 3, 0, 0, 0);
tchdbsetxmsiz(hdb, rnum * 48);
if(!tchdbopen(hdb, name, HDBOWRITER | HDBOCREAT | HDBOTRUNC)){
fprintf(stderr, "tchdbopen failed\n");
tchdbdel(hdb);
return 1;
}
err = FALSE;
/* loop for each record */
for(i = 1; i <= rnum; i++){
/* store a record */
len = sprintf(buf, "%08d", i);
if(!tchdbputasync(hdb, buf, len, buf, len)){
fprintf(stderr, "tchdbputasync failed\n");
err = TRUE;
break;
}
/* print progression */
if(showprgr && rnum > 250 && i % (rnum / 250) == 0){
putchar('.');
fflush(stdout);
if(i == rnum || i % (rnum / 10) == 0){
printf(" (%08d)\n", i);
fflush(stdout);
}
}
}
/* close the database */
if(!tchdbclose(hdb)){
fprintf(stderr, "tchdbclose failed\n");
tchdbdel(hdb);
return 1;
}
tchdbdel(hdb);
if(showprgr && !err) printf("ok\n\n");
return err ? 1 : 0;
}
int main (int argc, char *argv[])
{
TCHDB * const restrict hdb = tchdbnew(); /* create the object */
char *value;
const char *p;
const char *end;
struct stat st;
int fd;
const unsigned int klen = 8;
/* input stream must have keys of constant len 8 */
if (argc < 3) return -1;
/* open the database */
if(!tchdbopen(hdb, argv[1], HDBOREADER | HDBONOLCK)) {
fprintf(stderr, "open error: %s\n", tchdberrmsg(tchdbecode(hdb)));
return -1;
}
/* open input file */
if ((fd = open(argv[2], O_RDONLY, 0777)) == -1) {perror("open"); return -1;}
if (fstat(fd, &st) != 0) {perror("fstat");return -1;}
p = (const char *)mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (p == MAP_FAILED) {perror("mmap"); return -1;}
close(fd);
/* read each key from input mmap and query mcdb
* (no error checking since key might not exist) */
for (end = p+st.st_size; p < end; p += klen) {
#if 0
tchdbvsiz(hdb, p, klen); /* retrieve record value size */
#else
if ((value = tchdbget(hdb, p, klen, &fd))) /* retrieve records */
free(value);
#endif
}
if(!tchdbclose(hdb)) /* close the database */
fprintf(stderr, "close error: %s\n", tchdberrmsg(tchdbecode(hdb)));
tchdbdel(hdb); /* delete the object */
return 0;
}
/* perform inform command */
static int procinform(const char *path, int omode){
TCHDB *hdb = tchdbnew();
if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
if(!tchdbopen(hdb, path, HDBOREADER | omode)){
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
const char *npath = tchdbpath(hdb);
if(!npath) npath = "(unknown)";
printf("path: %s\n", npath);
const char *type = "(unknown)";
switch(tchdbtype(hdb)){
case HDBTHASH: type = "hash"; break;
case HDBTBTREE: type = "btree"; break;
}
printf("database type: %s\n", type);
uint8_t flags = tchdbflags(hdb);
printf("additional flags:");
if(flags & HDBFOPEN) printf(" open");
if(flags & HDBFFATAL) printf(" fatal");
printf("\n");
printf("bucket number: %llu\n", (unsigned long long)tchdbbnum(hdb));
if(hdb->cnt_writerec >= 0)
printf("used bucket number: %lld\n", (long long)tchdbbnumused(hdb));
printf("alignment: %u\n", tchdbalign(hdb));
printf("free block pool: %u\n", tchdbfbpmax(hdb));
uint8_t opts = tchdbopts(hdb);
printf("options:");
if(opts & HDBTLARGE) printf(" large");
if(opts & HDBTDEFLATE) printf(" deflate");
printf("\n");
printf("record number: %llu\n", (unsigned long long)tchdbrnum(hdb));
printf("file size: %llu\n", (unsigned long long)tchdbfsiz(hdb));
if(!tchdbclose(hdb)){
if(!err) printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
/* perform optimize command */
static int procoptimize(const char *path, int bnum, int apow, int fpow, int opts, int omode){
TCHDB *hdb = tchdbnew();
if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
if(!tchdbopen(hdb, path, HDBOWRITER | omode)){
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
if(!tchdboptimize(hdb, bnum, apow, fpow, opts)){
printerr(hdb);
err = true;
}
if(!tchdbclose(hdb)){
if(!err) printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
/* perform out command */
static int procout(const char *path, const char *kbuf, int ksiz, int omode){
TCHDB *hdb = tchdbnew();
if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
if(!tchdbopen(hdb, path, HDBOWRITER | omode)){
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
if(!tchdbout(hdb, kbuf, ksiz)){
printerr(hdb);
err = true;
}
if(!tchdbclose(hdb)){
if(!err) printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
/* perform out command */
static int procout(const char *path, const char *kbuf, int ksiz, int omode) {
TCHDB *hdb = tchdbnew();
if (!INVALIDHANDLE(g_dbgfd)) tchdbsetdbgfd(hdb, g_dbgfd);
if (!tchdbsetcodecfunc(hdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(hdb);
if (!tchdbopen(hdb, path, HDBOWRITER | omode)) {
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
if (!tchdbout(hdb, kbuf, ksiz)) {
printerr(hdb);
err = true;
}
if (!tchdbclose(hdb)) {
if (!err) printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
/* perform create command */
static int proccreate(const char *path, int bnum, int apow, int fpow, int opts){
TCHDB *hdb = tchdbnew();
if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
if(!tchdbtune(hdb, bnum, apow, fpow, opts)){
printerr(hdb);
tchdbdel(hdb);
return 1;
}
if(!tchdbopen(hdb, path, HDBOWRITER | HDBOCREAT | HDBOTRUNC)){
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
if(!tchdbclose(hdb)){
printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
/* perform create command */
static int proccreate(const char *path, int bnum, int apow, int fpow, int opts) {
TCHDB *hdb = tchdbnew();
if (!INVALIDHANDLE(g_dbgfd)) tchdbsetdbgfd(hdb, g_dbgfd);
if (!tchdbsetcodecfunc(hdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(hdb);
if (!tchdbtune(hdb, bnum, apow, fpow, opts)) {
printerr(hdb);
tchdbdel(hdb);
return 1;
}
if (!tchdbopen(hdb, path, HDBOWRITER | HDBOCREAT | HDBOTRUNC)) {
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
if (!tchdbclose(hdb)) {
printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
bool open_cabinet_db(int64_t bnum, bool optimize) {
int ecode;
if (optimize) fprintf(stdout, "Opening database optimized for %d items\n", bnum);
/* tune up the db*/
if (optimize && !tchdbtune(hdb, bnum, -1, -1, HDBTLARGE)) {
ecode = tchdbecode(hdb);
fprintf(stdout, "Failed to tune up database, error: %s\n", tchdberrmsg(ecode));
return false;
}
/* open the database */
if (!tchdbopen(hdb, tcxstrptr(db_file), HDBOWRITER | HDBOCREAT)) {
ecode = tchdbecode(hdb);
fprintf(stdout, "Failed to open database, error: %s\n", tchdberrmsg(ecode));
return false;
}
return true;
}
static int
_tc_open (mu_dbm_file_t db, int flags, int mode)
{
int f;
bool result;
mode_t save_um;
TCHDB *hdb;
switch (flags)
{
case MU_STREAM_CREAT:
f = HDBOWRITER | HDBOCREAT;
break;
case MU_STREAM_READ:
f = HDBOREADER;
break;
case MU_STREAM_RDWR:
f = HDBOREADER | HDBOWRITER;
break;
default:
return EINVAL;
}
hdb = tchdbnew ();
save_um = umask (0666 & ~mode);
result = tchdbopen (hdb, db->db_name, f);
umask (save_um);
if (!result)
{
db->db_errno.n = tchdbecode (hdb);
return MU_ERR_FAILURE;
}
db->db_descr = hdb;
return 0;
}
/* perform put command */
static int procput(const char *path, const char *kbuf, int ksiz, const char *vbuf, int vsiz,
int omode, int dmode){
TCHDB *hdb = tchdbnew();
if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
if(!tchdbopen(hdb, path, HDBOWRITER | omode)){
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
switch(dmode){
case -1:
if(!tchdbputkeep(hdb, kbuf, ksiz, vbuf, vsiz)){
printerr(hdb);
err = true;
}
break;
case 1:
if(!tchdbputcat(hdb, kbuf, ksiz, vbuf, vsiz)){
printerr(hdb);
err = true;
}
break;
default:
if(!tchdbput(hdb, kbuf, ksiz, vbuf, vsiz)){
printerr(hdb);
err = true;
}
break;
}
if(!tchdbclose(hdb)){
if(!err) printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
/* perform list command */
static int proclist(const char *path, int omode, int max, bool pv, bool px, const char *fmstr){
TCHDB *hdb = tchdbnew();
if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
if(!tchdbsetcodecfunc(hdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(hdb);
if(!tchdbopen(hdb, path, HDBOREADER | omode)){
printerr(hdb);
tchdbdel(hdb);
return 1;
}
bool err = false;
if(fmstr){
TCLIST *keys = tchdbfwmkeys2(hdb, fmstr, max);
for(int i = 0; i < tclistnum(keys); i++){
int ksiz;
const char *kbuf = tclistval(keys, i, &ksiz);
printdata(kbuf, ksiz, px);
if(pv){
int vsiz;
char *vbuf = tchdbget(hdb, kbuf, ksiz, &vsiz);
if(vbuf){
putchar('\t');
printdata(vbuf, vsiz, px);
tcfree(vbuf);
}
}
putchar('\n');
}
tclistdel(keys);
} else {
if(!tchdbiterinit(hdb)){
printerr(hdb);
err = true;
}
if(pv){
TCXSTR *key = tcxstrnew();
TCXSTR *val = tcxstrnew();
int cnt = 0;
while(tchdbiternext3(hdb, key, val)){
printdata(tcxstrptr(key), tcxstrsize(key), px);
putchar('\t');
printdata(tcxstrptr(val), tcxstrsize(val), px);
putchar('\n');
if(cnt > 0 && cnt % 100 == 0){
putc('.', stderr);
fflush(stderr);
if(cnt % 5000 == 0) fprintf(stderr, " (%08d)\n", cnt);
}
cnt++;
if(max >= 0 && cnt >= max) break;
}
fprintf(stderr, " (%08d)\n", cnt);
tcxstrdel(val);
tcxstrdel(key);
} else {
char *kbuf;
int ksiz;
int cnt = 0;
while((kbuf = tchdbiternext(hdb, &ksiz)) != NULL) {
printdata(kbuf, ksiz, px);
putchar('\n');
tcfree(kbuf);
if(max >= 0 && ++cnt >= max) break;
}
}
}
if(!tchdbclose(hdb)){
if(!err) printerr(hdb);
err = true;
}
tchdbdel(hdb);
return err ? 1 : 0;
}
bool Retsu::Column::open(int mode) {
return tchdbopen(database, path().c_str(), mode);
}
int main(int argc, char *argv[])
{
int rc;
char *val;
char str[30];
bool ret;
uint64_t id;
uint64_t re;
unsigned int num;
TCHDB *loong_info;
char username[] = "lijinxing";
// id = 1210519264165944251LL;
memset(&str, 0, sizeof(str));
id = ident_key();
snprintf(str, sizeof(str), "%llu", id);
num = strhash(str);
printf("num = %u\r\nmod = %u\r\nstr = %s\r\n", num, num % 10, str);
unlink("test.db");
loong_info = tchdbnew();
if(!tchdbopen(loong_info, "test.db", HDBOWRITER | HDBOCREAT))
{
rc = tchdbecode(loong_info);
printf("loong_info.db open error: %s\r\n", tchdberrmsg(rc));
return 0;
}
if(!tchdbput(loong_info, username, strlen(username), str, strlen(str)))
{
rc = tchdbecode(loong_info);
printf("loong_user error: %s\r\n", tchdberrmsg(rc));
}
if(!tchdbput(loong_info, (char *)&(id), sizeof(uint64_t), str, strlen(str)))
{
rc = tchdbecode(loong_info);
printf("loong_user error: %s\r\n", tchdberrmsg(rc));
}
val = tchdbget2(loong_info, username);
if(val == NULL)
{
printf("ûÕÒµ½\r\n");
}
else
{
printf("val = %s\r\n", val);
free(val);
}
if(!tchdbput(loong_info, username, strlen(username), "Àî½õÐÇ", strlen("Àî½õÐÇ")))
{
rc = tchdbecode(loong_info);
printf("loong_user error: %s\r\n", tchdberrmsg(rc));
}
val = tchdbget2(loong_info, username);
if(val == NULL)
{
printf("ûÕÒµ½\r\n");
}
else
{
printf("val = %s\r\n", val);
free(val);
}
/*
ret = tchdbout(loong_info, (char *)&(id), sizeof(uint64_t));
if(ret)
{
printf("uint64_tɾ³ý³É¹¦\r\n");
}
else
{
printf("uint64_tɾ³ýʧ°Ü\r\n");
}
val = tchdbget(loong_info, (char *)&(id), sizeof(uint64_t), &rc);
if(val == NULL)
{
printf("id ûÕÒµ½\r\n");
}
else
{
printf("id val = %s\r\n", val);
free(val);
}
ret = tchdbout(loong_info, username, strlen(username));
if(ret)
{
printf("stringɾ³ý³É¹¦\r\n");
}
else
{
printf("stringɾ³ýʧ°Ü\r\n");
}
val = tchdbget2(loong_info, username);
if(val == NULL)
{
printf("ûÕÒµ½\r\n");
}
else
{
printf("val = %s\r\n", val);
free(val);
}
*/
tchdbclose(loong_info);
tchdbdel(loong_info);
Test_out();
// fetch_user_info("1220582278313757000");
return 0;
}
bool db_obj_local::dbopen(int c)
{
return tchdbopen(_hdb,_name.c_str(),c);
}
