tcadb.c

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

  case ADBONDB:
    tcndbputcat(adb->ndb, kbuf, ksiz, vbuf, vsiz);
    if(adb->capnum > 0 || adb->capsiz > 0){
      adb->capcnt++;
      if((adb->capcnt & 0xff) == 0){
        if(adb->capnum > 0 && tcndbrnum(adb->ndb) > adb->capnum)
          tcndbcutfringe(adb->ndb, 0x100);
        if(adb->capsiz > 0 && tcndbmsiz(adb->ndb) > adb->capsiz)
          tcndbcutfringe(adb->ndb, 0x200);
      }
    }
    break;
  case ADBOHDB:
    if(!tchdbputcat(adb->hdb, kbuf, ksiz, vbuf, vsiz)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbputcat(adb->bdb, kbuf, ksiz, vbuf, vsiz)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdbputcat2(adb->fdb, kbuf, ksiz, vbuf, vsiz)) err = true;
    break;
  case ADBOTDB:
    if(ksiz < 1){
      ksiz = sprintf(numbuf, "%lld", (long long)tctdbgenuid(adb->tdb));
      kbuf = numbuf;
    }
    if(!tctdbputcat2(adb->tdb, kbuf, ksiz, vbuf, vsiz)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Concatenate a string value at the end of the existing record in an abstract database object. */
bool tcadbputcat2(TCADB *adb, const char *kstr, const char *vstr){
  assert(adb && kstr && vstr);
  return tcadbputcat(adb, kstr, strlen(kstr), vstr, strlen(vstr));
}


/* Remove a record of an abstract database object. */
bool tcadbout(TCADB *adb, const void *kbuf, int ksiz){
  assert(adb && kbuf && ksiz >= 0);
  bool err = false;
  switch(adb->omode){
  case ADBOMDB:
    if(!tcmdbout(adb->mdb, kbuf, ksiz)) err = true;
    break;
  case ADBONDB:
    if(!tcndbout(adb->ndb, kbuf, ksiz)) err = true;
    break;
  case ADBOHDB:
    if(!tchdbout(adb->hdb, kbuf, ksiz)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbout(adb->bdb, kbuf, ksiz)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdbout2(adb->fdb, kbuf, ksiz)) err = true;
    break;
  case ADBOTDB:
    if(!tctdbout(adb->tdb, kbuf, ksiz)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Remove a string record of an abstract database object. */
bool tcadbout2(TCADB *adb, const char *kstr){
  assert(adb && kstr);
  return tcadbout(adb, kstr, strlen(kstr));
}


/* Retrieve a record in an abstract database object. */
void *tcadbget(TCADB *adb, const void *kbuf, int ksiz, int *sp){
  assert(adb && kbuf && ksiz >= 0 && sp);
  char *rv;
  switch(adb->omode){
  case ADBOMDB:
    rv = tcmdbget(adb->mdb, kbuf, ksiz, sp);
    break;
  case ADBONDB:
    rv = tcndbget(adb->ndb, kbuf, ksiz, sp);
    break;
  case ADBOHDB:
    rv = tchdbget(adb->hdb, kbuf, ksiz, sp);
    break;
  case ADBOBDB:
    rv = tcbdbget(adb->bdb, kbuf, ksiz, sp);
    break;
  case ADBOFDB:
    rv = tcfdbget2(adb->fdb, kbuf, ksiz, sp);
    break;
  case ADBOTDB:
    rv = tctdbget2(adb->tdb, kbuf, ksiz, sp);
    break;
  default:
    rv = NULL;
    break;
  }
  return rv;
}


/* Retrieve a string record in an abstract database object. */
char *tcadbget2(TCADB *adb, const char *kstr){
  assert(adb && kstr);
  int vsiz;
  return tcadbget(adb, kstr, strlen(kstr), &vsiz);
}


/* Get the size of the value of a record in an abstract database object. */
int tcadbvsiz(TCADB *adb, const void *kbuf, int ksiz){
  assert(adb && kbuf && ksiz >= 0);
  int rv;
  switch(adb->omode){
  case ADBOMDB:
    rv = tcmdbvsiz(adb->mdb, kbuf, ksiz);
    break;
  case ADBONDB:
    rv = tcndbvsiz(adb->ndb, kbuf, ksiz);
    break;
  case ADBOHDB:
    rv = tchdbvsiz(adb->hdb, kbuf, ksiz);
    break;
  case ADBOBDB:
    rv = tcbdbvsiz(adb->bdb, kbuf, ksiz);
    break;
  case ADBOFDB:
    rv = tcfdbvsiz2(adb->fdb, kbuf, ksiz);
    break;
  case ADBOTDB:
    rv = tctdbvsiz(adb->tdb, kbuf, ksiz);
    break;
  default:
    rv = -1;
    break;
  }
  return rv;
}


/* Get the size of the value of a string record in an abstract database object. */
int tcadbvsiz2(TCADB *adb, const char *kstr){
  assert(adb && kstr);
  return tcadbvsiz(adb, kstr, strlen(kstr));
}


/* Initialize the iterator of an abstract database object. */
bool tcadbiterinit(TCADB *adb){
  assert(adb);
  bool err = false;
  switch(adb->omode){
  case ADBOMDB:
    tcmdbiterinit(adb->mdb);
    break;
  case ADBONDB:
    tcndbiterinit(adb->ndb);
    break;
  case ADBOHDB:
    if(!tchdbiterinit(adb->hdb)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbcurfirst(adb->cur)){
      int ecode = tcbdbecode(adb->bdb);
      if(ecode != TCESUCCESS && ecode != TCEINVALID && ecode != TCEKEEP && ecode != TCENOREC)
        err = true;
    }
    break;
  case ADBOFDB:
    if(!tcfdbiterinit(adb->fdb)) err = true;
    break;
  case ADBOTDB:
    if(!tctdbiterinit(adb->tdb)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Get the next key of the iterator of an abstract database object. */
void *tcadbiternext(TCADB *adb, int *sp){
  assert(adb && sp);
  char *rv;
  switch(adb->omode){
  case ADBOMDB:
    rv = tcmdbiternext(adb->mdb, sp);
    break;
  case ADBONDB:
    rv = tcndbiternext(adb->ndb, sp);
    break;
  case ADBOHDB:
    rv = tchdbiternext(adb->hdb, sp);
    break;
  case ADBOBDB:
    rv = tcbdbcurkey(adb->cur, sp);
    tcbdbcurnext(adb->cur);
    break;
  case ADBOFDB:
    rv = tcfdbiternext2(adb->fdb, sp);
    break;
  case ADBOTDB:
    rv = tctdbiternext(adb->tdb, sp);
    break;
  default:
    rv = NULL;
    break;
  }
  return rv;
}


/* Get the next key string of the iterator of an abstract database object. */
char *tcadbiternext2(TCADB *adb){
  assert(adb);
  int vsiz;
  return tcadbiternext(adb, &vsiz);
}


/* Get forward matching keys in an abstract database object. */
TCLIST *tcadbfwmkeys(TCADB *adb, const void *pbuf, int psiz, int max){
  assert(adb && pbuf && psiz >= 0);
  TCLIST *rv;
  switch(adb->omode){
  case ADBOMDB:
    rv = tcmdbfwmkeys(adb->mdb, pbuf, psiz, max);
    break;
  case ADBONDB:
    rv = tcndbfwmkeys(adb->ndb, pbuf, psiz, max);
    break;
  case ADBOHDB:
    rv = tchdbfwmkeys(adb->hdb, pbuf, psiz, max);
    break;
  case ADBOBDB:
    rv = tcbdbfwmkeys(adb->bdb, pbuf, psiz, max);
    break;
  case ADBOFDB:
    rv = tcfdbrange4(adb->fdb, pbuf, psiz, max);
    break;
  case ADBOTDB:
    rv = tctdbfwmkeys(adb->tdb, pbuf, psiz, max);
    break;
  default:
    rv = tclistnew();
    break;
  }
  return rv;
}


/* Get forward matching string keys in an abstract database object. */
TCLIST *tcadbfwmkeys2(TCADB *adb, const char *pstr, int max){
  assert(adb && pstr);
  return tcadbfwmkeys(adb, pstr, strlen(pstr), max);
}


/* Add an integer to a record in an abstract database object. */
int tcadbaddint(TCADB *adb, const void *kbuf, int ksiz, int num){
  assert(adb && kbuf && ksiz >= 0);
  int rv;
  char numbuf[TCNUMBUFSIZ];
  switch(adb->omode){
  case ADBOMDB:
    rv = tcmdbaddint(adb->mdb, kbuf, ksiz, num);
    if(adb->capnum > 0 || adb->capsiz > 0){
      adb->capcnt++;
      if((adb->capcnt & 0xff) == 0){
        if(adb->capnum > 0 && tcmdbrnum(adb->mdb) > adb->capnum)
          tcmdbcutfront(adb->mdb, 0x100);
        if(adb->capsiz > 0 && tcmdbmsiz(adb->mdb) > adb->capsiz)
          tcmdbcutfront(adb->mdb, 0x200);
      }
    }
    break;
  case ADBONDB:
    rv = tcndbaddint(adb->ndb, kbuf, ksiz, num);
    if(adb->capnum > 0 || adb->capsiz > 0){
      adb->capcnt++;
      if((adb->capcnt & 0xff) == 0){
        if(adb->capnum > 0 && tcndbrnum(adb->ndb) > adb->capnum)
          tcndbcutfringe(adb->ndb, 0x100);
        if(adb->capsiz > 0 && tcndbmsiz(adb->ndb) > adb->capsiz)
          tcndbcutfringe(adb->ndb, 0x200);
      }
    }
    break;
  case ADBOHDB:
    rv = tchdbaddint(adb->hdb, kbuf, ksiz, num);
    break;
  case ADBOBDB:
    rv = tcbdbaddint(adb->bdb, kbuf, ksiz, num);
    break;
  case ADBOFDB:
    rv = tcfdbaddint(adb->fdb, tcfdbkeytoid(kbuf, ksiz), num);
    break;
  case ADBOTDB:
    if(ksiz < 1){
      ksiz = sprintf(numbuf, "%lld", (long long)tctdbgenuid(adb->tdb));
      kbuf = numbuf;
    }
    rv = tctdbaddint(adb->tdb, kbuf, ksiz, num);
    break;
  default:
    rv = INT_MIN;
    break;
  }
  return rv;
}


/* Add a real number to a record in an abstract database object. */
double tcadbadddouble(TCADB *adb, const void *kbuf, int ksiz, double num){
  assert(adb && kbuf && ksiz >= 0);
  double rv;
  char numbuf[TCNUMBUFSIZ];
  switch(adb->omode){
  case ADBOMDB:
    rv = tcmdbadddouble(adb->mdb, kbuf, ksiz, num);
    if(adb->capnum > 0 || adb->capsiz > 0){
      adb->capcnt++;
      if((adb->capcnt & 0xff) == 0){
        if(adb->capnum > 0 && tcmdbrnum(adb->mdb) > adb->capnum)
          tcmdbcutfront(adb->mdb, 0x100);
        if(adb->capsiz > 0 && tcmdbmsiz(adb->mdb) > adb->capsiz)
          tcmdbcutfront(adb->mdb, 0x200);
      }
    }
    break;
  case ADBONDB:
    rv = tcndbadddouble(adb->ndb, kbuf, ksiz, num);
    if(adb->capnum > 0 || adb->capsiz > 0){
      adb->capcnt++;
      if((adb->capcnt & 0xff) == 0){
        if(adb->capnum > 0 && tcndbrnum(adb->ndb) > adb->capnum)
          tcndbcutfringe(adb->ndb, 0x100);
        if(adb->capsiz > 0 && tcndbmsiz(adb->ndb) > adb->capsiz)
          tcndbcutfringe(adb->ndb, 0x200);
      }
    }
    break;
  case ADBOHDB:
    rv = tchdbadddouble(adb->hdb, kbuf, ksiz, num);
    break;
  case ADBOBDB:
    rv = tcbdbadddouble(adb->bdb, kbuf, ksiz, num);
    break;
  case ADBOFDB:
    rv = tcfdbadddouble(adb->fdb, tcfdbkeytoid(kbuf, ksiz), num);
    break;
  case ADBOTDB:
    if(ksiz < 1){
      ksiz = sprintf(numbuf, "%lld", (long long)tctdbgenuid(adb->tdb));
      kbuf = numbuf;
    }
    rv = tctdbadddouble(adb->tdb, kbuf, ksiz, num);
    break;
  default:
    rv = nan("");
    break;
  }
  return rv;
}


/* Synchronize updated contents of an abstract database object with the file and the device. */
bool tcadbsync(TCADB *adb){
  assert(adb);
  bool err = false;
  switch(adb->omode){
  case ADBOMDB:
    if(adb->capnum > 0){
      while(tcmdbrnum(adb->mdb) > adb->capnum){
        tcmdbcutfront(adb->mdb, 1);
      }
    }
    if(adb->capsiz > 0){
      while(tcmdbmsiz(adb->mdb) > adb->capsiz && tcmdbrnum(adb->mdb) > 0){
        tcmdbcutfront(adb->mdb, 1);
      }
    }
    adb->capcnt = 0;
    break;
  case ADBONDB:
    if(adb->capnum > 0 && tcndbrnum(adb->ndb) > adb->capnum)
      tcndbcutfringe(adb->ndb, tcndbrnum(adb->ndb) - adb->capnum);
    if(adb->capsiz > 0){
      while(tcndbmsiz(adb->ndb) > adb->capsiz && tcndbrnum(adb->ndb) > 0){
        tcndbcutfringe(adb->ndb, 0x100);
      }
    }
    adb->capcnt = 0;
    break;
  case ADBOHDB:
    if(!tchdbsync(adb->hdb)) err = true;
    break;
  case ADBOBDB:
    if(!tcbdbsync(adb->bdb)) err = true;
    break;
  case ADBOFDB:
    if(!tcfdbsync(adb->fdb)) err = true;
    break;
  case ADBOTDB:
    if(!tctdbsync(adb->tdb)) err = true;
    break;
  default:
    err = true;
    break;
  }
  return !err;
}


/* Optimize the storage of an abstract database object. */
bool tcadboptimize(TCADB *adb, const char *params){
  assert(adb);
  TCLIST *elems = params ? tcstrsplit(params, "#") : tclistnew();
  int64_t bnum = -1;
  int64_t capnum = -1;
  int64_t capsiz = -1;
  int8_t apow = -1;
  int8_t fpow = -1;
  bool tdefault = true;
  bool tlmode = false;
  bool tdmode = false;
  bool tbmode = false;
  bool ttmode = false;
  int32_t lmemb = -1;
  int32_t nmemb = -1;
  int32_t width = -1;
  int64_t limsiz = -1;
  int ln = TCLISTNUM(elems);
  for(int i = 0; i < ln; i++){
    const char *elem = TCLISTVALPTR(elems, i);
    char *pv = strchr(elem, '=');
    if(!pv) continue;
    *(pv++) = '\0';
    if(!tcstricmp(elem, "bnum")){
      bnum = tcatoix(pv);
    } else if(!tcstricmp(elem, "capnum")){
      capnum = tcatoix(pv);
    } else if(!tcstricmp(elem, "capsiz")){
      capsiz = tcatoix(pv);
    } else if(!tcstricmp(elem, "apow")){
      apow = tcatoix(pv);
    } else if(!tcstricmp(elem, "fpow")){
      fpow = tcatoix(pv);
    } else if(!tcstricmp(elem, "opts")){
      tdefault = false;
      if(strchr(pv, 'l') || strchr(pv, 'L')) tlmode = true;
      if(strchr(pv, 'd') || strchr(pv, 'D')) tdmode = true;
      if(strchr(pv, 'b') || strchr(pv, 'B')) tbmode = true;
      if(strchr(pv, 't') || strchr(pv, 'T')) ttmode = true;
    } else if(!tcstricmp(elem, "lmemb")){
      lmemb = tcatoix(pv);
    } else if(!tcstricmp(elem, "nmemb")){
      nmemb = tcatoix(pv);
    } else if(!tcstricmp(elem, "width")){
      width = tcatoix(pv);
    } else if(!tcstricmp(elem, "limsiz")){
      limsiz = tcatoix(pv);
    }
  }
  tclistdel(elems);
  bool err = false;