tcamgr.c

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

  }
  if(!name) usage();
  int rv = procoptimize(name, params);
  return rv;
}


/* parse arguments of misc command */
static int runmisc(int argc, char **argv){
  char *name = NULL;
  char *func = NULL;
  TCLIST *args = tcmpoollistnew(tcmpoolglobal());
  bool sx = false;
  int sep = -1;
  bool px = false;
  for(int i = 2; i < argc; i++){
    if(!name && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-sx")){
        sx = true;
      } else if(!strcmp(argv[i], "-sep")){
        if(++i >= argc) usage();
        sep = sepstrtochr(argv[i]);
      } else if(!strcmp(argv[i], "-px")){
        px = true;
      } else {
        usage();
      }
    } else if(!name){
      name = argv[i];
    } else if(!func){
      func = argv[i];
    } else {
      if(sx){
        int size;
        char *buf = tchexdecode(argv[i], &size);
        tclistpush(args, buf, size);
        tcfree(buf);
      } else if(sep > 0){
        int size;
        char *buf = strtozsv(argv[i], sep, &size);
        tclistpush(args, buf, size);
        tcfree(buf);
      } else {
        tclistpush2(args, argv[i]);
      }
    }
  }
  if(!name || !func) usage();
  int rv = procmisc(name, func, args, sep, px);
  return rv;
}


/* parse arguments of map command */
static int runmap(int argc, char **argv){
  char *name = NULL;
  char *dest = NULL;
  char *fmstr = NULL;
  for(int i = 2; i < argc; i++){
    if(!name && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-fm")){
        if(++i >= argc) usage();
        fmstr = argv[i];
      } else {
        usage();
      }
    } else if(!name){
      name = argv[i];
    } else if(!dest){
      dest = argv[i];
    } else {
      usage();
    }
  }
  if(!name || !dest) usage();
  name = tcsprintf("%s#mode=r", name);
  int rv = procmap(name, dest, fmstr);
  tcfree(name);
  return rv;
}


/* parse arguments of version command */
static int runversion(int argc, char **argv){
  int rv = procversion();
  return rv;
}


/* perform create command */
static int proccreate(const char *name){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  if(!tcadbclose(adb)){
    printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform inform command */
static int procinform(const char *name){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  const char *path = tcadbpath(adb);
  if(!path) path = "(unknown)";
  printf("path: %s\n", path);
  const char *type = "(unknown)";
  switch(tcadbomode(adb)){
  case ADBOVOID: type = "not opened"; break;
  case ADBOMDB: type = "on-memory hash database"; break;
  case ADBONDB: type = "on-memory tree database"; break;
  case ADBOHDB: type = "hash database"; break;
  case ADBOBDB: type = "B+ tree database"; break;
  case ADBOFDB: type = "fixed-length database"; break;
  case ADBOTDB: type = "table database"; break;
  }
  printf("database type: %s\n", type);
  printf("record number: %llu\n", (unsigned long long)tcadbrnum(adb));
  printf("size: %llu\n", (unsigned long long)tcadbsize(adb));
  if(!tcadbclose(adb)){
    printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform put command */
static int procput(const char *name, const char *kbuf, int ksiz, const char *vbuf, int vsiz,
                   int dmode){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  switch(dmode){
  case -1:
    if(!tcadbputkeep(adb, kbuf, ksiz, vbuf, vsiz)){
      printerr(adb);
      err = true;
    }
    break;
  case 1:
    if(!tcadbputcat(adb, kbuf, ksiz, vbuf, vsiz)){
      printerr(adb);
      err = true;
    }
    break;
  case 10:
    if(tcadbaddint(adb, kbuf, ksiz, tcatoi(vbuf)) == INT_MIN){
      printerr(adb);
      err = true;
    }
    break;
  case 11:
    if(isnan(tcadbadddouble(adb, kbuf, ksiz, tcatof(vbuf)))){
      printerr(adb);
      err = true;
    }
    break;
  default:
    if(!tcadbput(adb, kbuf, ksiz, vbuf, vsiz)){
      printerr(adb);
      err = true;
    }
    break;
  }
  if(!tcadbclose(adb)){
    if(!err) printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform out command */
static int procout(const char *name, const char *kbuf, int ksiz){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  if(!tcadbout(adb, kbuf, ksiz)){
    printerr(adb);
    err = true;
  }
  if(!tcadbclose(adb)){
    if(!err) printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform get command */
static int procget(const char *name, const char *kbuf, int ksiz, int sep, bool px, bool pz){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  int vsiz;
  char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
  if(vbuf){
    printdata(vbuf, vsiz, px, sep);
    if(!pz) putchar('\n');
    tcfree(vbuf);
  } else {
    printerr(adb);
    err = true;
  }
  if(!tcadbclose(adb)){
    if(!err) printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform list command */
static int proclist(const char *name, int sep, int max, bool pv, bool px, const char *fmstr){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  if(fmstr){
    TCLIST *keys = tcadbfwmkeys2(adb, fmstr, max);
    for(int i = 0; i < tclistnum(keys); i++){
      int ksiz;
      const char *kbuf = tclistval(keys, i, &ksiz);
      printdata(kbuf, ksiz, px, sep);
      if(pv){
        int vsiz;
        char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
        if(vbuf){
          putchar('\t');
          printdata(vbuf, vsiz, px, sep);
          tcfree(vbuf);
        }
      }
      putchar('\n');
    }
    tclistdel(keys);
  } else {
    if(!tcadbiterinit(adb)){
      printerr(adb);
      err = true;
    }
    int ksiz;
    char *kbuf;
    int cnt = 0;
    while((kbuf = tcadbiternext(adb, &ksiz)) != NULL){
      printdata(kbuf, ksiz, px, sep);
      if(pv){
        int vsiz;
        char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
        if(vbuf){
          putchar('\t');
          printdata(vbuf, vsiz, px, sep);
          tcfree(vbuf);
        }
      }
      putchar('\n');
      tcfree(kbuf);
      if(max >= 0 && ++cnt >= max) break;
    }
  }
  if(!tcadbclose(adb)){
    if(!err) printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform optimize command */
static int procoptimize(const char *name, const char *params){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  if(!tcadboptimize(adb, params)){
    printerr(adb);
    err = true;
  }
  if(!tcadbclose(adb)){
    if(!err) printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform misc command */
static int procmisc(const char *name, const char *func, const TCLIST *args, int sep, bool px){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  TCLIST *res = tcadbmisc(adb, func, args);
  if(res){
    for(int i = 0; i < tclistnum(res); i++){
      int rsiz;
      const char *rbuf = tclistval(res, i, &rsiz);
      printdata(rbuf, rsiz, px, sep);
      printf("\n");
    }
    tclistdel(res);
  } else {
    printerr(adb);
    err = true;
  }
  if(!tcadbclose(adb)){
    if(!err) printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform map command */
static int procmap(const char *name, const char *dest, const char *fmstr){
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    printerr(adb);
    tcadbdel(adb);
    return 1;
  }
  bool err = false;
  TCBDB *bdb = tcbdbnew();
  if(!tcbdbopen(bdb, dest, BDBOWRITER | BDBOCREAT | BDBOTRUNC)){
    printerr(adb);
    tcbdbdel(bdb);
    tcadbdel(adb);
    return 1;
  }
  if(fmstr){
    TCLIST *keys = tcadbfwmkeys2(adb, fmstr, -1);
    if(!tcadbmapbdb(adb, keys, bdb, mapbdbproc, NULL, -1)){
      printerr(adb);
      err = true;
    }
    tclistdel(keys);
  } else {
    if(!tcadbmapbdb(adb, NULL, bdb, mapbdbproc, NULL, -1)){
      printerr(adb);
      err = true;
    }
  }
  if(!tcbdbclose(bdb)){
    printerr(adb);
    err = true;
  }
  tcbdbdel(bdb);
  if(!tcadbclose(adb)){
    printerr(adb);
    err = true;
  }
  tcadbdel(adb);
  return err ? 1 : 0;
}


/* perform version command */
static int procversion(void){
  printf("Tokyo Cabinet version %s (%d:%s) for %s\n",
         tcversion, _TC_LIBVER, _TC_FORMATVER, TCSYSNAME);
  printf("Copyright (C) 2006-2009 Mikio Hirabayashi\n");
  return 0;
}



// END OF FILE