tcadb.c

Tokyo Cabinet的Tokyo Cabinet 是一个DBM的实现。这里的数据库由一系列key-value对的记录构成。key和value都可以是任意长度的字节序列,既可以是二进制也可以是字符

  int opts;
  switch(adb->omode){
  case ADBOMDB:
    adb->capnum = capnum;
    adb->capsiz = capsiz;
    tcadbsync(adb);
    break;
  case ADBONDB:
    adb->capnum = capnum;
    adb->capsiz = capsiz;
    tcadbsync(adb);
    break;
  case ADBOHDB:
    opts = 0;
    if(tdefault){
      opts = UINT8_MAX;
    } else {
      if(tlmode) opts |= HDBTLARGE;
      if(tdmode) opts |= HDBTDEFLATE;
      if(tbmode) opts |= HDBTBZIP;
      if(ttmode) opts |= HDBTTCBS;
    }
    if(!tchdboptimize(adb->hdb, bnum, apow, fpow, opts)) err = true;
    break;
  case ADBOBDB:
    opts = 0;
    if(tdefault){
      opts = UINT8_MAX;
    } else {
      if(tlmode) opts |= BDBTLARGE;
      if(tdmode) opts |= BDBTDEFLATE;
      if(tbmode) opts |= BDBTBZIP;
      if(ttmode) opts |= BDBTTCBS;
    }
    if(!tcbdboptimize(adb->bdb, lmemb, nmemb, bnum, apow, fpow, opts)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdboptimize(adb->fdb, width, limsiz)) err = true;
    break;
  case ADBOTDB:
    opts = 0;
    if(tdefault){
      opts = UINT8_MAX;
    } else {
      if(tlmode) opts |= TDBTLARGE;
      if(tdmode) opts |= TDBTDEFLATE;
      if(tbmode) opts |= TDBTBZIP;
      if(ttmode) opts |= TDBTTCBS;
    }
    if(!tctdboptimize(adb->tdb, bnum, apow, fpow, opts)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Remove all records of an abstract database object. */
bool tcadbvanish(TCADB *adb){
  assert(adb);
  bool err = false;
  switch(adb->omode){
  case ADBOMDB:
    tcmdbvanish(adb->mdb);
    break;
  case ADBONDB:
    tcndbvanish(adb->ndb);
    break;
  case ADBOHDB:
    if(!tchdbvanish(adb->hdb)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbvanish(adb->bdb)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdbvanish(adb->fdb)) err = true;
    break;
  case ADBOTDB:
    if(!tctdbvanish(adb->tdb)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Copy the database file of an abstract database object. */
bool tcadbcopy(TCADB *adb, const char *path){
  assert(adb && path);
  bool err = false;
  switch(adb->omode){
  case ADBOMDB:
  case ADBONDB:
    if(*path == '@'){
      char tsbuf[TCNUMBUFSIZ];
      sprintf(tsbuf, "%llu", (unsigned long long)(tctime() * 1000000));
      const char *args[3];
      args[0] = path + 1;
      args[1] = adb->name;
      args[2] = tsbuf;
      if(tcsystem(args, sizeof(args) / sizeof(*args)) != 0) err = true;
    } else {
      TCADB *tadb = tcadbnew();
      if(tcadbopen(tadb, path)){
        tcadbiterinit(adb);
        char *kbuf;
        int ksiz;
        while((kbuf = tcadbiternext(adb, &ksiz)) != NULL){
          int vsiz;
          char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
          if(vbuf){
            if(!tcadbput(tadb, kbuf, ksiz, vbuf, vsiz)) err = true;
            TCFREE(vbuf);
          }
          TCFREE(kbuf);
        }
        if(!tcadbclose(tadb)) err = true;
      } else {
        err = true;
      }
      tcadbdel(tadb);
    }
    break;
  case ADBOHDB:
    if(!tchdbcopy(adb->hdb, path)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbcopy(adb->bdb, path)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdbcopy(adb->fdb, path)) err = true;
    break;
  case ADBOTDB:
    if(!tctdbcopy(adb->tdb, path)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Begin the transaction of an abstract database object. */
bool tcadbtranbegin(TCADB *adb){
  assert(adb);
  bool err = false;
  switch(adb->omode){
  case ADBOMDB:
    err = true;
    break;
  case ADBONDB:
    err = true;
    break;
  case ADBOHDB:
    if(!tchdbtranbegin(adb->hdb)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbtranbegin(adb->bdb)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdbtranbegin(adb->fdb)) err = true;
    break;
  case ADBOTDB:
    if(!tctdbtranbegin(adb->tdb)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Commit the transaction of an abstract database object. */
bool tcadbtrancommit(TCADB *adb){
  assert(adb);
  bool err = false;
  switch(adb->omode){
  case ADBOMDB:
    err = true;
    break;
  case ADBONDB:
    err = true;
    break;
  case ADBOHDB:
    if(!tchdbtrancommit(adb->hdb)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbtrancommit(adb->bdb)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdbtrancommit(adb->fdb)) err = true;
    break;
  case ADBOTDB:
    if(!tctdbtrancommit(adb->tdb)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Abort the transaction of an abstract database object. */
bool tcadbtranabort(TCADB *adb){
  assert(adb);
  bool err = false;
  switch(adb->omode){
  case ADBOMDB:
    err = true;
    break;
  case ADBONDB:
    err = true;
    break;
  case ADBOHDB:
    if(!tchdbtranabort(adb->hdb)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbtranabort(adb->bdb)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdbtranabort(adb->fdb)) err = true;
    break;
  case ADBOTDB:
    if(!tctdbtranabort(adb->tdb)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Get the file path of an abstract database object. */
const char *tcadbpath(TCADB *adb){
  assert(adb);
  const char *rv;
  switch(adb->omode){
  case ADBOMDB:
    rv = "*";
    break;
  case ADBONDB:
    rv = "+";
    break;
  case ADBOHDB:
    rv = tchdbpath(adb->hdb);
    break;
  case ADBOBDB:
    rv = tcbdbpath(adb->bdb);
    break;
  case ADBOFDB:
    rv = tcfdbpath(adb->fdb);
    break;
  case ADBOTDB:
    rv = tctdbpath(adb->tdb);
    break;
  default:
    rv = NULL;
    break;
  }
  return rv;
}


/* Get the number of records of an abstract database object. */
uint64_t tcadbrnum(TCADB *adb){
  assert(adb);
  uint64_t rv;
  switch(adb->omode){
  case ADBOMDB:
    rv = tcmdbrnum(adb->mdb);
    break;
  case ADBONDB:
    rv = tcndbrnum(adb->ndb);
    break;
  case ADBOHDB:
    rv = tchdbrnum(adb->hdb);
    break;
  case ADBOBDB:
    rv = tcbdbrnum(adb->bdb);
    break;
  case ADBOFDB:
    rv = tcfdbrnum(adb->fdb);
    break;
  case ADBOTDB:
    rv = tctdbrnum(adb->tdb);
    break;
  default:
    rv = 0;
    break;
  }
  return rv;
}


/* Get the size of the database of an abstract database object. */
uint64_t tcadbsize(TCADB *adb){
  assert(adb);
  uint64_t rv;
  switch(adb->omode){
  case ADBOMDB:
    rv = tcmdbmsiz(adb->mdb);
    break;
  case ADBONDB:
    rv = tcndbmsiz(adb->ndb);
    break;
  case ADBOHDB:
    rv = tchdbfsiz(adb->hdb);
    break;
  case ADBOBDB:
    rv = tcbdbfsiz(adb->bdb);
    break;
  case ADBOFDB:
    rv = tcfdbfsiz(adb->fdb);
    break;
  case ADBOTDB:
    rv = tctdbfsiz(adb->tdb);
    break;
  default:
    rv = 0;
    break;
  }
  return rv;
}


/* Call a versatile function for miscellaneous operations of an abstract database object. */
TCLIST *tcadbmisc(TCADB *adb, const char *name, const TCLIST *args){
  assert(adb && name && args);
  int argc = TCLISTNUM(args);
  TCLIST *rv;
  switch(adb->omode){
  case ADBOMDB:
    if(!strcmp(name, "put") || !strcmp(name, "putkeep") || !strcmp(name, "putcat")){
      if(argc > 1){
        rv = tclistnew2(1);
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, 0, ksiz);
        const char *vbuf;
        int vsiz;
        TCLISTVAL(vbuf, args, 1, vsiz);
        bool err = false;
        if(!strcmp(name, "put")){
          tcmdbput(adb->mdb, kbuf, ksiz, vbuf, vsiz);
        } else if(!strcmp(name, "putkeep")){
          if(!tcmdbputkeep(adb->mdb, kbuf, ksiz, vbuf, vsiz)) err = true;
        } else if(!strcmp(name, "putcat")){
          tcmdbputcat(adb->mdb, kbuf, ksiz, vbuf, vsiz);
        }
        if(err){
          tclistdel(rv);
          rv = NULL;
        }
      } else {
        rv = NULL;
      }
    } else if(!strcmp(name, "out")){
      if(argc > 0){
        rv = tclistnew2(1);
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, 0, ksiz);
        if(!tcmdbout(adb->mdb, kbuf, ksiz)){
          tclistdel(rv);
          rv = NULL;
        }
      } else {
        rv = NULL;
      }
    } else if(!strcmp(name, "get")){
      if(argc > 0){
        rv = tclistnew2(1);
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, 0, ksiz);
        int vsiz;
        char *vbuf = tcmdbget(adb->mdb, kbuf, ksiz, &vsiz);
        if(vbuf){
          TCLISTPUSH(rv, vbuf, vsiz);
          TCFREE(vbuf);
        } else {
          tclistdel(rv);
          rv = NULL;
        }
      } else {
        rv = NULL;
      }
    } else if(!strcmp(name, "putlist")){
      rv = tclistnew2(1);
      argc--;
      for(int i = 0; i < argc; i += 2){
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, i, ksiz);
        int vsiz;
        const char *vbuf = tclistval(args, i + 1, &vsiz);
        tcmdbput(adb->mdb, kbuf, ksiz, vbuf, vsiz);
      }
    } else if(!strcmp(name, "outlist")){
      rv = tclistnew2(1);
      for(int i = 0; i < argc; i++){
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, i, ksiz);
        tcmdbout(adb->mdb, kbuf, ksiz);
      }
    } else if(!strcmp(name, "getlist")){
      rv = tclistnew2(argc);
      for(int i = 0; i < argc; i++){
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, i, ksiz);
        int vsiz;
        char *vbuf = tcmdbget(adb->mdb, kbuf, ksiz, &vsiz);
        if(vbuf){
          TCLISTPUSH(rv, kbuf, ksiz);
          TCLISTPUSH(rv, vbuf, vsiz);
          TCFREE(vbuf);
        }
      }
    } else {
      rv = NULL;
    }
    break;
  case ADBONDB:
    if(!strcmp(name, "put") || !strcmp(name, "putkeep") || !strcmp(name, "putcat")){
      if(argc > 1){
        rv = tclistnew2(1);
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, 0, ksiz);
        const char *vbuf;
        int vsiz;
        TCLISTVAL(vbuf, args, 1, vsiz);
        bool err = false;
        if(!strcmp(name, "put")){
          tcndbput(adb->ndb, kbuf, ksiz, vbuf, vsiz);
        } else if(!strcmp(name, "putkeep")){
          if(!tcndbputkeep(adb->ndb, kbuf, ksiz, vbuf, vsiz)) err = true;
        } else if(!strcmp(name, "putcat")){
          tcndbputcat(adb->ndb, kbuf, ksiz, vbuf, vsiz);
        }
        if(err){
          tclistdel(rv);
          rv = NULL;
        }
      } else {
        rv = NULL;
      }
    } else if(!strcmp(name, "out")){
      if(argc > 0){
        rv = tclistnew2(1);
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, 0, ksiz);
        if(!tcndbout(adb->ndb, kbuf, ksiz)){
          tclistdel(rv);
          rv = NULL;
        }
      } else {
        rv = NULL;
      }
    } else if(!strcmp(name, "get")){
      if(argc > 0){
        rv = tclistnew2(1);
        const char *kbuf;
        int ksiz;
        TCLISTVAL(kbuf, args, 0, ksiz);
        int vsiz;
        char *vbuf = tcndbget(adb->ndb, kbuf, ksiz, &vsiz);
        if(vbuf){