lib/libc/db/test/btree.tests/main.c

   1 /*-
   2  * Copyright (c) 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Mike Olson.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * @(#)main.c   8.1 (Berkeley) 6/4/93
  33  * $DragonFly: src/lib/libc/db/test/btree.tests/main.c,v 1.8 2008/07/10 18:29:51 swildner Exp $
  34  */
  35
  36 #include <sys/param.h>
  37 #include <fcntl.h>
  38 #include <db.h>
  39 #include <errno.h>
  40 #include <stdio.h>
  41 #include <ctype.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include "btree.h"
  45
  46 typedef struct cmd_table {
  47         char *cmd;
  48         int nargs;
  49         int rconv;
  50         void (*func) (DB *, char **);
  51         char *usage, *descrip;
  52 } cmd_table;
  53
  54 int stopstop;
  55 DB *globaldb;
  56
  57 void append     (DB *, char **);
  58 void bstat      (DB *, char **);
  59 void cursor     (DB *, char **);
  60 void delcur     (DB *, char **);
  61 void delete     (DB *, char **);
  62 void dump       (DB *, char **);
  63 void first      (DB *, char **);
  64 void get        (DB *, char **);
  65 void help       (DB *, char **);
  66 void iafter     (DB *, char **);
  67 void ibefore    (DB *, char **);
  68 void icursor    (DB *, char **);
  69 void insert     (DB *, char **);
  70 void keydata    (DBT *, DBT *);
  71 void last       (DB *, char **);
  72 void list       (DB *, char **);
  73 void load       (DB *, char **);
  74 void mstat      (DB *, char **);
  75 void next       (DB *, char **);
  76 int  parse      (char *, char **, int);
  77 void previous   (DB *, char **);
  78 void show       (DB *, char **);
  79 void usage      (void);
  80 void user       (DB *);
  81
  82 cmd_table commands[] = {
  83         "?",    0, 0, help, "help", NULL,
  84         "a",    2, 1, append, "append key def", "append key with data def",
  85         "b",    0, 0, bstat, "bstat", "stat btree",
  86         "c",    1, 1, cursor,  "cursor word", "move cursor to word",
  87         "delc", 0, 0, delcur, "delcur", "delete key the cursor references",
  88         "dele", 1, 1, delete, "delete word", "delete word",
  89         "d",    0, 0, dump, "dump", "dump database",
  90         "f",    0, 0, first, "first", "move cursor to first record",
  91         "g",    1, 1, get, "get key", "locate key",
  92         "h",    0, 0, help, "help", "print command summary",
  93         "ia",   2, 1, iafter, "iafter key data", "insert data after key",
  94         "ib",   2, 1, ibefore, "ibefore key data", "insert data before key",
  95         "ic",   2, 1, icursor, "icursor key data", "replace cursor",
  96         "in",   2, 1, insert, "insert key def", "insert key with data def",
  97         "la",   0, 0, last, "last", "move cursor to last record",
  98         "li",   1, 1, list, "list file", "list to a file",
  99         "loa",  1, 0, load, "load file", NULL,
 100         "loc",  1, 1, get, "get key", NULL,
 101         "m",    0, 0, mstat, "mstat", "stat memory pool",
 102         "n",    0, 0, next, "next", "move cursor forward one record",
 103         "p",    0, 0, previous, "previous", "move cursor back one record",
 104         "q",    0, 0, NULL, "quit", "quit",
 105         "sh",   1, 0, show, "show page", "dump a page",
 106         { NULL },
 107 };
 108
 109 int recno;                                      /* use record numbers */
 110 char *dict = "words";                           /* default dictionary */
 111 char *progname;
 112
 113 int
 114 main(int argc, char **argv)
 115 {
 116         int c;
 117         DB *db;
 118         BTREEINFO b;
 119
 120         progname = *argv;
 121
 122         b.flags = 0;
 123         b.cachesize = 0;
 124         b.maxkeypage = 0;
 125         b.minkeypage = 0;
 126         b.psize = 0;
 127         b.compare = NULL;
 128         b.prefix = NULL;
 129         b.lorder = 0;
 130
 131         while ((c = getopt(argc, argv, "bc:di:lp:ru")) != -1) {
 132                 switch (c) {
 133                 case 'b':
 134                         b.lorder = BIG_ENDIAN;
 135                         break;
 136                 case 'c':
 137                         b.cachesize = atoi(optarg);
 138                         break;
 139                 case 'd':
 140                         b.flags |= R_DUP;
 141                         break;
 142                 case 'i':
 143                         dict = optarg;
 144                         break;
 145                 case 'l':
 146                         b.lorder = LITTLE_ENDIAN;
 147                         break;
 148                 case 'p':
 149                         b.psize = atoi(optarg);
 150                         break;
 151                 case 'r':
 152                         recno = 1;
 153                         break;
 154                 case 'u':
 155                         b.flags = 0;
 156                         break;
 157                 default:
 158                         usage();
 159                 }
 160         }
 161         argc -= optind;
 162         argv += optind;
 163
 164         if (recno)
 165                 db = dbopen(*argv == NULL ? NULL : *argv, O_RDWR,
 166                     0, DB_RECNO, NULL);
 167         else
 168                 db = dbopen(*argv == NULL ? NULL : *argv, O_CREAT|O_RDWR,
 169                     0600, DB_BTREE, &b);
 170
 171         if (db == NULL) {
 172                 fprintf(stderr, "dbopen: %s\n", strerror(errno));
 173                 exit(1);
 174         }
 175         globaldb = db;
 176         user(db);
 177         exit(0);
 178         /* NOTREACHED */
 179 }
 180
 181 void
 182 user(DB *db)
 183 {
 184         FILE *ifp;
 185         int argc, i, last;
 186         char *lbuf, *argv[4], buf[512];
 187
 188         if ((ifp = fopen("/dev/tty", "r")) == NULL) {
 189                 fprintf(stderr,
 190                     "/dev/tty: %s\n", strerror(errno));
 191                 exit(1);
 192         }
 193         for (last = 0;;) {
 194                 printf("> ");
 195                 fflush(stdout);
 196                 if ((lbuf = fgets(&buf[0], 512, ifp)) == NULL)
 197                         break;
 198                 if (lbuf[0] == '\n') {
 199                         i = last;
 200                         goto uselast;
 201                 }
 202                 lbuf[strlen(lbuf) - 1] = '\0';
 203
 204                 if (lbuf[0] == 'q')
 205                         break;
 206
 207                 argc = parse(lbuf, &argv[0], 3);
 208                 if (argc == 0)
 209                         continue;
 210
 211                 for (i = 0; commands[i].cmd != NULL; i++)
 212                         if (strncmp(commands[i].cmd, argv[0],
 213                             strlen(commands[i].cmd)) == 0)
 214                                 break;
 215
 216                 if (commands[i].cmd == NULL) {
 217                         fprintf(stderr,
 218                             "%s: command unknown ('help' for help)\n", lbuf);
 219                         continue;
 220                 }
 221
 222                 if (commands[i].nargs != argc - 1) {
 223                         fprintf(stderr, "usage: %s\n", commands[i].usage);
 224                         continue;
 225                 }
 226
 227                 if (recno && commands[i].rconv) {
 228                         static recno_t nlong;
 229                         nlong = atoi(argv[1]);
 230                         argv[1] = (char *)&nlong;
 231                 }
 232 uselast:        last = i;
 233                 (*commands[i].func)(db, argv);
 234         }
 235         if ((db->sync)(db) == RET_ERROR)
 236                 perror("dbsync");
 237         else if ((db->close)(db) == RET_ERROR)
 238                 perror("dbclose");
 239 }
 240
 241 int
 242 parse(char *lbuf, char **argv, int maxargc)
 243 {
 244         int argc = 0;
 245         char *c;
 246
 247         c = lbuf;
 248         while (isspace(*c))
 249                 c++;
 250         while (*c != '\0' && argc < maxargc) {
 251                 *argv++ = c;
 252                 argc++;
 253                 while (!isspace(*c) && *c != '\0') {
 254                         c++;
 255                 }
 256                 while (isspace(*c))
 257                         *c++ = '\0';
 258         }
 259         return (argc);
 260 }
 261
 262 void
 263 append(DB *db, char **argv)
 264 {
 265         DBT key, data;
 266         int status;
 267
 268         if (!recno) {
 269                 fprintf(stderr,
 270                     "append only available for recno db's.\n");
 271                 return;
 272         }
 273         key.data = argv[1];
 274         key.size = sizeof(recno_t);
 275         data.data = argv[2];
 276         data.size = strlen(data.data);
 277         status = (db->put)(db, &key, &data, R_APPEND);
 278         switch (status) {
 279         case RET_ERROR:
 280                 perror("append/put");
 281                 break;
 282         case RET_SPECIAL:
 283                 printf("%s (duplicate key)\n", argv[1]);
 284                 break;
 285         case RET_SUCCESS:
 286                 break;
 287         }
 288 }
 289
 290 void
 291 cursor(DB *db, char **argv)
 292 {
 293         DBT data, key;
 294         int status;
 295
 296         key.data = argv[1];
 297         if (recno)
 298                 key.size = sizeof(recno_t);
 299         else
 300                 key.size = strlen(argv[1]) + 1;
 301         status = (*db->seq)(db, &key, &data, R_CURSOR);
 302         switch (status) {
 303         case RET_ERROR:
 304                 perror("cursor/seq");
 305                 break;
 306         case RET_SPECIAL:
 307                 printf("key not found\n");
 308                 break;
 309         case RET_SUCCESS:
 310                 keydata(&key, &data);
 311                 break;
 312         }
 313 }
 314
 315 void
 316 delcur(DB *db, char **argv)
 317 {
 318         int status;
 319
 320         status = (*db->del)(db, NULL, R_CURSOR);
 321
 322         if (status == RET_ERROR)
 323                 perror("delcur/del");
 324 }
 325
 326 void
 327 delete(DB *db, char **argv)
 328 {
 329         DBT key;
 330         int status;
 331
 332         key.data = argv[1];
 333         if (recno)
 334                 key.size = sizeof(recno_t);
 335         else
 336                 key.size = strlen(argv[1]) + 1;
 337
 338         status = (*db->del)(db, &key, 0);
 339         switch (status) {
 340         case RET_ERROR:
 341                 perror("delete/del");
 342                 break;
 343         case RET_SPECIAL:
 344                 printf("key not found\n");
 345                 break;
 346         case RET_SUCCESS:
 347                 break;
 348         }
 349 }
 350
 351 void
 352 dump(DB *db, char **argv)
 353 {
 354         __bt_dump(db);
 355 }
 356
 357 void
 358 first(DB *db, char **argv)
 359 {
 360         DBT data, key;
 361         int status;
 362
 363         status = (*db->seq)(db, &key, &data, R_FIRST);
 364
 365         switch (status) {
 366         case RET_ERROR:
 367                 perror("first/seq");
 368                 break;
 369         case RET_SPECIAL:
 370                 printf("no more keys\n");
 371                 break;
 372         case RET_SUCCESS:
 373                 keydata(&key, &data);
 374                 break;
 375         }
 376 }
 377
 378 void
 379 get(DB *db, char **argv)
 380 {
 381         DBT data, key;
 382         int status;
 383
 384         key.data = argv[1];
 385         if (recno)
 386                 key.size = sizeof(recno_t);
 387         else
 388                 key.size = strlen(argv[1]) + 1;
 389
 390         status = (*db->get)(db, &key, &data, 0);
 391
 392         switch (status) {
 393         case RET_ERROR:
 394                 perror("get/get");
 395                 break;
 396         case RET_SPECIAL:
 397                 printf("key not found\n");
 398                 break;
 399         case RET_SUCCESS:
 400                 keydata(&key, &data);
 401                 break;
 402         }
 403 }
 404
 405 void
 406 help(DB *db, char **argv)
 407 {
 408         int i;
 409
 410         for (i = 0; commands[i].cmd; i++)
 411                 if (commands[i].descrip)
 412                         printf("%s: %s\n",
 413                             commands[i].usage, commands[i].descrip);
 414 }
 415
 416 void
 417 iafter(DB *db, char **argv)
 418 {
 419         DBT key, data;
 420         int status;
 421
 422         if (!recno) {
 423                 fprintf(stderr,
 424                     "iafter only available for recno db's.\n");
 425                 return;
 426         }
 427         key.data = argv[1];
 428         key.size = sizeof(recno_t);
 429         data.data = argv[2];
 430         data.size = strlen(data.data);
 431         status = (db->put)(db, &key, &data, R_IAFTER);
 432         switch (status) {
 433         case RET_ERROR:
 434                 perror("iafter/put");
 435                 break;
 436         case RET_SPECIAL:
 437                 printf("%s (duplicate key)\n", argv[1]);
 438                 break;
 439         case RET_SUCCESS:
 440                 break;
 441         }
 442 }
 443
 444 void
 445 ibefore(DB *db, char **argv)
 446 {
 447         DBT key, data;
 448         int status;
 449
 450         if (!recno) {
 451                 fprintf(stderr,
 452                     "ibefore only available for recno db's.\n");
 453                 return;
 454         }
 455         key.data = argv[1];
 456         key.size = sizeof(recno_t);
 457         data.data = argv[2];
 458         data.size = strlen(data.data);
 459         status = (db->put)(db, &key, &data, R_IBEFORE);
 460         switch (status) {
 461         case RET_ERROR:
 462                 perror("ibefore/put");
 463                 break;
 464         case RET_SPECIAL:
 465                 printf("%s (duplicate key)\n", argv[1]);
 466                 break;
 467         case RET_SUCCESS:
 468                 break;
 469         }
 470 }
 471
 472 void
 473 icursor(DB *db, char **argv)
 474 {
 475         int status;
 476         DBT data, key;
 477
 478         key.data = argv[1];
 479         if (recno)
 480                 key.size = sizeof(recno_t);
 481         else
 482                 key.size = strlen(argv[1]) + 1;
 483         data.data = argv[2];
 484         data.size = strlen(argv[2]) + 1;
 485
 486         status = (*db->put)(db, &key, &data, R_CURSOR);
 487         switch (status) {
 488         case RET_ERROR:
 489                 perror("icursor/put");
 490                 break;
 491         case RET_SPECIAL:
 492                 printf("%s (duplicate key)\n", argv[1]);
 493                 break;
 494         case RET_SUCCESS:
 495                 break;
 496         }
 497 }
 498
 499 void
 500 insert(DB *db, char **argv)
 501 {
 502         int status;
 503         DBT data, key;
 504
 505         key.data = argv[1];
 506         if (recno)
 507                 key.size = sizeof(recno_t);
 508         else
 509                 key.size = strlen(argv[1]) + 1;
 510         data.data = argv[2];
 511         data.size = strlen(argv[2]) + 1;
 512
 513         status = (*db->put)(db, &key, &data, R_NOOVERWRITE);
 514         switch (status) {
 515         case RET_ERROR:
 516                 perror("insert/put");
 517                 break;
 518         case RET_SPECIAL:
 519                 printf("%s (duplicate key)\n", argv[1]);
 520                 break;
 521         case RET_SUCCESS:
 522                 break;
 523         }
 524 }
 525
 526 void
 527 last(DB *db, char **argv)
 528 {
 529         DBT data, key;
 530         int status;
 531
 532         status = (*db->seq)(db, &key, &data, R_LAST);
 533
 534         switch (status) {
 535         case RET_ERROR:
 536                 perror("last/seq");
 537                 break;
 538         case RET_SPECIAL:
 539                 printf("no more keys\n");
 540                 break;
 541         case RET_SUCCESS:
 542                 keydata(&key, &data);
 543                 break;
 544         }
 545 }
 546
 547 void
 548 list(DB *db, char **argv)
 549 {
 550         DBT data, key;
 551         FILE *fp;
 552         int status;
 553
 554         if ((fp = fopen(argv[1], "w")) == NULL) {
 555                 fprintf(stderr, "%s: %s\n", argv[1], strerror(errno));
 556                 return;
 557         }
 558         status = (*db->seq)(db, &key, &data, R_FIRST);
 559         while (status == RET_SUCCESS) {
 560                 fprintf(fp, "%s\n", key.data);
 561                 status = (*db->seq)(db, &key, &data, R_NEXT);
 562         }
 563         if (status == RET_ERROR)
 564                 perror("list/seq");
 565 }
 566
 567 DB *BUGdb;
 568 void
 569 load(DB *db, char **argv)
 570 {
 571         char *p, *t;
 572         FILE *fp;
 573         DBT data, key;
 574         recno_t cnt;
 575         size_t len;
 576         int status;
 577         char *lp, buf[16 * 1024];
 578
 579         BUGdb = db;
 580         if ((fp = fopen(argv[1], "r")) == NULL) {
 581                 fprintf(stderr, "%s: %s\n", argv[1], strerror(errno));
 582                 return;
 583         }
 584         printf("loading %s...\n", argv[1]);
 585
 586         for (cnt = 1; (lp = fgetline(fp, &len)) != NULL; ++cnt) {
 587                 if (recno) {
 588                         key.data = &cnt;
 589                         key.size = sizeof(recno_t);
 590                         data.data = lp;
 591                         data.size = len + 1;
 592                 } else {
 593                         key.data = lp;
 594                         key.size = len + 1;
 595                         for (p = lp + len - 1, t = buf; p >= lp; *t++ = *p--);
 596                         *t = '\0';
 597                         data.data = buf;
 598                         data.size = len + 1;
 599                 }
 600
 601                 status = (*db->put)(db, &key, &data, R_NOOVERWRITE);
 602                 switch (status) {
 603                 case RET_ERROR:
 604                         perror("load/put");
 605                         exit(1);
 606                 case RET_SPECIAL:
 607                         if (recno)
 608                                 fprintf(stderr,
 609                                     "duplicate: %ld {%s}\n", cnt, data.data);
 610                         else
 611                                 fprintf(stderr,
 612                                     "duplicate: %ld {%s}\n", cnt, key.data);
 613                         exit(1);
 614                 case RET_SUCCESS:
 615                         break;
 616                 }
 617         }
 618         fclose(fp);
 619 }
 620
 621 void
 622 next(DB *db, char **argv)
 623 {
 624         DBT data, key;
 625         int status;
 626
 627         status = (*db->seq)(db, &key, &data, R_NEXT);
 628
 629         switch (status) {
 630         case RET_ERROR:
 631                 perror("next/seq");
 632                 break;
 633         case RET_SPECIAL:
 634                 printf("no more keys\n");
 635                 break;
 636         case RET_SUCCESS:
 637                 keydata(&key, &data);
 638                 break;
 639         }
 640 }
 641
 642 void
 643 previous(DB *db, char **argv)
 644 {
 645         DBT data, key;
 646         int status;
 647
 648         status = (*db->seq)(db, &key, &data, R_PREV);
 649
 650         switch (status) {
 651         case RET_ERROR:
 652                 perror("previous/seq");
 653                 break;
 654         case RET_SPECIAL:
 655                 printf("no more keys\n");
 656                 break;
 657         case RET_SUCCESS:
 658                 keydata(&key, &data);
 659                 break;
 660         }
 661 }
 662
 663 void
 664 show(DB *db, char **argv)
 665 {
 666         BTREE *t;
 667         PAGE *h;
 668         pgno_t pg;
 669
 670         pg = atoi(argv[1]);
 671         t = db->internal;
 672         if ((h = mpool_get(t->bt_mp, pg, 0)) == NULL) {
 673                 printf("getpage of %ld failed\n", pg);
 674                 return;
 675         }
 676         if (pg == 0)
 677                 __bt_dmpage(h);
 678         else
 679                 __bt_dpage(h);
 680         mpool_put(t->bt_mp, h, 0);
 681 }
 682
 683 void
 684 bstat(DB *db, char **argv)
 685 {
 686         printf("BTREE\n");
 687         __bt_stat(db);
 688 }
 689
 690 void
 691 mstat(DB *db, char **argv)
 692 {
 693         printf("MPOOL\n");
 694         mpool_stat(((BTREE *)db->internal)->bt_mp);
 695 }
 696
 697 void
 698 keydata(DBT *key, DBT *data)
 699 {
 700         if (!recno && key->size > 0)
 701                 printf("%s/", key->data);
 702         if (data->size > 0)
 703                 printf("%s", data->data);
 704         printf("\n");
 705 }
 706
 707 void
 708 usage(void)
 709 {
 710         fprintf(stderr,
 711             "usage: %s [-bdlu] [-c cache] [-i file] [-p page] [file]\n",
 712             progname);
 713         exit (1);
 714 }