tcadb.c

高性能嵌入式数据库在高并发的环境下使用最好是64位系统比较好

/* 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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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);
      }
    }
    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);
      }
    }
    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;
  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;
  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;
  default:
    err = true;
    break;
  }
  return !err;
}


/* 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;
  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;
  default:
    rv = 0;
    break;
  }
  return rv;
}



// END OF FILE