home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / myisam / mi_test1.c < prev    next >
C/C++ Source or Header  |  2000-08-31  |  17KB  |  641 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17. /* Testing of the basic functions of a MyISAM table */
  18.  
  19. #include "myisam.h"
  20. #include <getopt.h>
  21. #include <m_ctype.h>
  22.  
  23.  
  24. #define MAX_REC_LENGTH 1024
  25.  
  26. static int rec_pointer_size=0,verbose=0,flags[50];
  27. static int key_field=FIELD_SKIPP_PRESPACE,extra_field=FIELD_SKIPP_ENDSPACE;
  28. static int key_type=HA_KEYTYPE_NUM;
  29. static int create_flag=0;
  30.  
  31. static uint insert_count= 1000,update_count=1000,remove_count=1000;
  32. static uint pack_keys=0,pack_seg=0,null_fields=0,key_length=6,skip_update=0;
  33. static uint unique_key=HA_NOSAME,key_cacheing=0,opt_unique=0;
  34. static uint silent;
  35. static MI_COLUMNDEF recinfo[4];
  36. static MI_KEYDEF keyinfo[10];
  37. static MI_KEYSEG keyseg[10];
  38. static MI_KEYSEG uniqueseg[10];
  39.  
  40. static int run_test(const char *filename);
  41. static void get_options(int argc, char *argv[]);
  42. static void create_key(char *key,uint rownr);
  43. static void create_record(char *record,uint rownr);
  44. static void update_record(char *record);
  45.  
  46. int main(int argc,char *argv[])
  47. {
  48.   MY_INIT(argv[0]);
  49.   my_init();
  50.   if (key_cacheing)
  51.     init_key_cache(IO_SIZE*16,(uint) IO_SIZE*4*10);
  52.   get_options(argc,argv);
  53.  
  54.   exit(run_test("test1"));
  55. }
  56.  
  57.  
  58. int run_test(const char *filename)
  59. {
  60.   MI_INFO *file;
  61.   int i,j,error,deleted,rec_length,uniques=0;
  62.   ha_rows found,row_count;
  63.   my_off_t pos;
  64.   char record[MAX_REC_LENGTH],key[MAX_REC_LENGTH],read_record[MAX_REC_LENGTH];
  65.   MI_UNIQUEDEF uniquedef;
  66.   MI_CREATE_INFO create_info;
  67.  
  68.   bzero((char*) recinfo,sizeof(recinfo));
  69.  
  70.   /* First define 2 columns */
  71.   recinfo[0].type=FIELD_NORMAL; recinfo[0].length=1; /* For NULL bits */
  72.   recinfo[1].type=key_field;
  73.   recinfo[1].length= (key_field == FIELD_BLOB ? 4+mi_portable_sizeof_char_ptr :
  74.               key_length);
  75.   if (key_field == FIELD_VARCHAR)
  76.     recinfo[1].length+=2;
  77.   recinfo[2].type=extra_field;
  78.   recinfo[2].length= (extra_field == FIELD_BLOB ? 4 + mi_portable_sizeof_char_ptr : 24);
  79.   if (extra_field == FIELD_VARCHAR)
  80.     recinfo[2].length+=2;
  81.   if (opt_unique)
  82.   {
  83.     recinfo[3].type=FIELD_CHECK;
  84.     recinfo[3].length=MI_UNIQUE_HASH_LENGTH;
  85.   }
  86.   rec_length=recinfo[0].length+recinfo[1].length+recinfo[2].length+
  87.     recinfo[3].length;
  88.  
  89.  
  90.   /* Define a key over the first column */
  91.   keyinfo[0].seg=keyseg;
  92.   keyinfo[0].keysegs=1;
  93.   keyinfo[0].seg[0].type= key_type;
  94.   keyinfo[0].seg[0].flag= pack_seg;
  95.   keyinfo[0].seg[0].start=1;
  96.   keyinfo[0].seg[0].length=key_length;
  97.   keyinfo[0].seg[0].null_bit= null_fields ? 2 : 0;
  98.   keyinfo[0].seg[0].null_pos=0;
  99.   keyinfo[0].seg[0].language=MY_CHARSET_CURRENT;
  100.   if (pack_seg & HA_BLOB_PART)
  101.   {
  102.     keyinfo[0].seg[0].bit_start=4;        /* Length of blob length */
  103.   }
  104.   keyinfo[0].flag = (uint8) (pack_keys | unique_key);
  105.  
  106.   bzero((byte*) flags,sizeof(flags));
  107.   if (opt_unique)
  108.   {
  109.     uint start;
  110.     uniques=1;
  111.     bzero((char*) &uniquedef,sizeof(uniquedef));
  112.     bzero((char*) uniqueseg,sizeof(uniqueseg));
  113.     uniquedef.seg=uniqueseg;
  114.     uniquedef.keysegs=2;
  115.  
  116.     /* Make a unique over all columns (except first NULL fields) */
  117.     for (i=0, start=1 ; i < 2 ; i++)
  118.     {
  119.       uniqueseg[i].start=start;
  120.       start+=recinfo[i+1].length;
  121.       uniqueseg[i].length=recinfo[i+1].length;
  122.       uniqueseg[i].language=MY_CHARSET_CURRENT;
  123.     }
  124.     uniqueseg[0].type= key_type;
  125.     uniqueseg[0].null_bit= null_fields ? 2 : 0;
  126.     uniqueseg[1].type= HA_KEYTYPE_TEXT;
  127.     if (extra_field == FIELD_BLOB)
  128.     {
  129.       uniqueseg[1].length=0;            /* The whole blob */
  130.       uniqueseg[1].bit_start=4;            /* long blob */
  131.       uniqueseg[1].flag|= HA_BLOB_PART;
  132.     }
  133.     else if (extra_field == FIELD_VARCHAR)
  134.       uniqueseg[1].flag|= HA_VAR_LENGTH;
  135.   }
  136.   else
  137.     uniques=0;
  138.  
  139.   if (!silent)
  140.     printf("- Creating isam-file\n");
  141.   bzero((char*) &create_info,sizeof(create_info));
  142.   create_info.max_rows=(ulong) (rec_pointer_size ?
  143.                 (1L << (rec_pointer_size*8))/40 :
  144.                 0);
  145.   if (mi_create(filename,1,keyinfo,3+opt_unique,recinfo,
  146.         uniques, &uniquedef, &create_info,
  147.         create_flag))
  148.     goto err;
  149.   if (!(file=mi_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
  150.     goto err;
  151.   if (!silent)
  152.     printf("- Writing key:s\n");
  153.  
  154.   my_errno=0;
  155.   row_count=deleted=0;
  156.   for (i=49 ; i>=1 ; i-=2 )
  157.   {
  158.     if (insert_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
  159.     j=i%25 +1;
  160.     create_record(record,j);
  161.     error=mi_write(file,record);
  162.     if (!error)
  163.       row_count++;
  164.     flags[j]=1;
  165.     if (verbose || error)
  166.       printf("J= %2d  mi_write: %d  errno: %d\n", j,error,my_errno);
  167.   }
  168.  
  169.   /* Insert 2 rows with null values */
  170.   if (null_fields)
  171.   {
  172.     create_record(record,0);
  173.     error=mi_write(file,record);
  174.     if (!error)
  175.       row_count++;
  176.     if (verbose || error)
  177.       printf("J= NULL  mi_write: %d  errno: %d\n", error,my_errno);
  178.     error=mi_write(file,record);
  179.     if (!error)
  180.       row_count++;
  181.     if (verbose || error)
  182.       printf("J= NULL  mi_write: %d  errno: %d\n", error,my_errno);
  183.     flags[0]=2;
  184.   }
  185.  
  186.   if (!skip_update)
  187.   {
  188.     if (opt_unique)
  189.     {
  190.       if (!silent)
  191.     printf("- Checking unique constraint\n");
  192.       create_record(record,j);
  193.       if (!mi_write(file,record) || my_errno != HA_ERR_FOUND_DUPP_UNIQUE)
  194.       {
  195.     printf("unique check failed\n");
  196.       }
  197.     }
  198.     if (!silent)
  199.       printf("- Updating rows\n");
  200.  
  201.     /* Update first last row to force extend of file */
  202.     if (mi_rsame(file,read_record,-1))
  203.     {
  204.       printf("Can't find last row with mi_rsame\n");
  205.     }
  206.     else
  207.     {
  208.       memcpy(record,read_record,rec_length);
  209.       update_record(record);
  210.       if (mi_update(file,read_record,record))
  211.       {
  212.     printf("Can't update last row: %.*s\n",
  213.            keyinfo[0].seg[0].length,read_record+1);
  214.       }
  215.     }
  216.  
  217.     /* Read through all rows and update them */
  218.     pos=(my_off_t) 0;
  219.     found=0;
  220.     while ((error=mi_rrnd(file,read_record,pos)) == 0)
  221.     {
  222.       if (update_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
  223.       memcpy(record,read_record,rec_length);
  224.       update_record(record);
  225.       if (mi_update(file,read_record,record))
  226.       {
  227.     printf("Can't update row: %.*s, error: %d\n",
  228.            keyinfo[0].seg[0].length,record+1,my_errno);
  229.       }
  230.       found++;
  231.       pos=HA_OFFSET_ERROR;
  232.     }
  233.     if (found != row_count)
  234.       printf("Found %ld of %ld rows\n", found,row_count);
  235.   }
  236.  
  237.   if (!silent)
  238.     printf("- Reopening file\n");
  239.   if (mi_close(file)) goto err;
  240.   if (!(file=mi_open(filename,2,HA_OPEN_ABORT_IF_LOCKED))) goto err;
  241.   if (!skip_update)
  242.   {
  243.     if (!silent)
  244.       printf("- Removing keys\n");
  245.  
  246.     for (i=0 ; i <= 10 ; i++)
  247.     {
  248.       /* testing */
  249.       if (remove_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
  250.       j=i*2;
  251.       if (!flags[j])
  252.     continue;
  253.       create_key(key,j);
  254.       my_errno=0;
  255.       if ((error = mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT)))
  256.       {
  257.     if (verbose || (flags[j] >= 1 ||
  258.             (error && my_errno != HA_ERR_KEY_NOT_FOUND)))
  259.       printf("key: '%.*s'  mi_rkey:  %3d  errno: %3d\n",
  260.          (int) key_length,key+test(null_fields),error,my_errno);
  261.       }
  262.       else
  263.       {
  264.     error=mi_delete(file,read_record);
  265.     if (verbose || error)
  266.       printf("key: '%.*s'  mi_delete: %3d  errno: %3d\n",
  267.          (int) key_length, key+test(null_fields), error, my_errno);
  268.     if (! error)
  269.     {
  270.       deleted++;
  271.       flags[j]--;
  272.     }
  273.       }
  274.     }
  275.   }
  276.   if (!silent)
  277.     printf("- Reading rows with key\n");
  278.   for (i=0 ; i <= 25 ; i++)
  279.   {
  280.     create_key(key,i);
  281.     my_errno=0;
  282.     error=mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT);
  283.     if (verbose ||
  284.     (error == 0 && flags[i] == 0 && unique_key) ||
  285.     (error && (flags[i] != 0 || my_errno != HA_ERR_KEY_NOT_FOUND)))
  286.     {
  287.       printf("key: '%.*s'  mi_rkey: %3d  errno: %3d  record: %s\n",
  288.          (int) key_length,key+test(null_fields),error,my_errno,record+1);
  289.     }
  290.   }
  291.  
  292.   if (!silent)
  293.     printf("- Reading rows with position\n");
  294.   for (i=1,found=0 ; i <= 30 ; i++)
  295.   {
  296.     my_errno=0;
  297.     if ((error=mi_rrnd(file,read_record,i == 1 ? 0L : HA_OFFSET_ERROR)) == -1)
  298.     {
  299.       if (found != row_count-deleted)
  300.     printf("Found only %ld of %ld rows\n",found,row_count-deleted);
  301.       break;
  302.     }
  303.     if (!error)
  304.       found++;
  305.     if (verbose || (error != 0 && error != HA_ERR_RECORD_DELETED &&
  306.             error != HA_ERR_END_OF_FILE))
  307.     {
  308.       printf("pos: %2d  mi_rrnd: %3d  errno: %3d  record: %s\n",
  309.          i-1,error,my_errno,read_record+1);
  310.     }
  311.   }
  312.   if (mi_close(file)) goto err;
  313.   my_end(MY_CHECK_ERROR);
  314.  
  315.   return (0);
  316. err:
  317.   printf("got error: %3d when using myisam-database\n",my_errno);
  318.   return 1;            /* skipp warning */
  319. }
  320.  
  321.  
  322. static void create_key_part(char *key,uint rownr)
  323. {
  324.   if (!unique_key)
  325.     rownr&=7;                    /* Some identical keys */
  326.   if (keyinfo[0].seg[0].type == HA_KEYTYPE_NUM)
  327.   {
  328.     sprintf(key,"%*d",keyinfo[0].seg[0].length,rownr);
  329.   }
  330.   else if (keyinfo[0].seg[0].type == HA_KEYTYPE_VARTEXT)
  331.   {                        /* Alpha record */
  332.     /* Create a key that may be easily packed */
  333.     bfill(key,keyinfo[0].seg[0].length,rownr < 10 ? 'A' : 'B');
  334.     sprintf(key+keyinfo[0].seg[0].length-2,"%-2d",rownr);
  335.     if ((rownr & 7) == 0)
  336.     {
  337.       /* Change the key to force a unpack of the next key */
  338.       bfill(key+3,keyinfo[0].seg[0].length-4,rownr < 10 ? 'a' : 'b');
  339.     }
  340.   }
  341.   else
  342.   {                        /* Alpha record */
  343.     if (keyinfo[0].seg[0].flag & HA_SPACE_PACK)
  344.       sprintf(key,"%-*d",keyinfo[0].seg[0].length,rownr);
  345.     else
  346.     {
  347.       /* Create a key that may be easily packed */
  348.       bfill(key,keyinfo[0].seg[0].length,rownr < 10 ? 'A' : 'B');
  349.       sprintf(key+keyinfo[0].seg[0].length-2,"%-2d",rownr);
  350.       if ((rownr & 7) == 0)
  351.       {
  352.     /* Change the key to force a unpack of the next key */
  353.     key[1]= (rownr < 10 ? 'a' : 'b');
  354.       }
  355.     }
  356.   }
  357. }
  358.  
  359.  
  360. static void create_key(char *key,uint rownr)
  361. {
  362.   if (keyinfo[0].seg[0].null_bit)
  363.   {
  364.     if (rownr == 0)
  365.     {
  366.       key[0]=1;                    /* null key */
  367.       key[1]=0;                    /* Fore easy print of key */
  368.       return;
  369.     }
  370.     *key++=0;
  371.   }
  372.   if (keyinfo[0].seg[0].flag & (HA_BLOB_PART | HA_VAR_LENGTH))
  373.   {
  374.     uint tmp;
  375.     create_key_part(key+2,rownr);
  376.     tmp=strlen(key+2);
  377.     int2store(key,tmp);
  378.   }
  379.   else
  380.     create_key_part(key,rownr);
  381. }
  382.  
  383.  
  384. static char blob_key[MAX_REC_LENGTH];
  385. static char blob_record[MAX_REC_LENGTH+20*20];
  386.  
  387.  
  388. static void create_record(char *record,uint rownr)
  389. {
  390.   char *pos;
  391.   bzero((char*) record,MAX_REC_LENGTH);
  392.   record[0]=1;                    /* delete marker */
  393.   if (rownr == 0 && keyinfo[0].seg[0].null_bit)
  394.     record[0]|=keyinfo[0].seg[0].null_bit;    /* Null key */
  395.  
  396.   pos=record+1;
  397.   if (recinfo[1].type == FIELD_BLOB)
  398.   {
  399.     uint tmp;
  400.     char *ptr;
  401.     create_key_part(blob_key,rownr);
  402.     tmp=strlen(blob_key);
  403.     int4store(pos,tmp);
  404.     ptr=blob_key;
  405.     memcpy_fixed(pos+4,&ptr,sizeof(char*));
  406.     pos+=recinfo[1].length;
  407.   }
  408.   else if (recinfo[1].type == FIELD_VARCHAR)
  409.   {
  410.     uint tmp;
  411.     create_key_part(pos+2,rownr);
  412.     tmp=strlen(pos+2);
  413.     int2store(pos,tmp);
  414.     pos+=recinfo[1].length;
  415.   }
  416.   else
  417.   {
  418.     create_key_part(pos,rownr);
  419.     pos+=recinfo[1].length;
  420.   }
  421.   if (recinfo[2].type == FIELD_BLOB)
  422.   {
  423.     uint tmp;
  424.     char *ptr;;
  425.     sprintf(blob_record,"... row: %d", rownr);
  426.     strappend(blob_record,max(MAX_REC_LENGTH-rownr,10),' ');
  427.     tmp=strlen(blob_record);
  428.     int4store(pos,tmp);
  429.     ptr=blob_record;
  430.     memcpy_fixed(pos+4,&ptr,sizeof(char*));
  431.   }
  432.   else if (recinfo[2].type == FIELD_VARCHAR)
  433.   {
  434.     uint tmp;
  435.     sprintf(pos+2,"... row: %d", rownr);
  436.     tmp=strlen(pos+2);
  437.     int2store(pos,tmp);
  438.   }
  439.   else
  440.   {
  441.     sprintf(pos,"... row: %d", rownr);
  442.     strappend(pos,recinfo[2].length,' ');
  443.   }
  444. }
  445.  
  446. /* change row to test re-packing of rows and reallocation of keys */
  447.  
  448. static void update_record(char *record)
  449. {
  450.   char *pos=record+1;
  451.   if (recinfo[1].type == FIELD_BLOB)
  452.   {
  453.     char *column,*ptr;
  454.     int length;
  455.     length=uint4korr(pos);            /* Long blob */
  456.     memcpy_fixed(&column,pos+4,sizeof(char*));
  457.     memcpy(blob_key,column,length);        /* Move old key */
  458.     ptr=blob_key;
  459.     memcpy_fixed(pos+4,&ptr,sizeof(char*));    /* Store pointer to new key */
  460.     if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
  461.       casedn(blob_key,length);
  462.     pos+=recinfo[1].length;
  463.   }
  464.   else if (recinfo[1].type == FIELD_VARCHAR)
  465.   {
  466.     uint length=uint2korr(pos);
  467.     casedn(pos+2,length);
  468.     pos+=recinfo[1].length;
  469.   }
  470.   else
  471.   {
  472.     if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
  473.       casedn(pos,keyinfo[0].seg[0].length);
  474.     pos+=recinfo[1].length;
  475.   }
  476.  
  477.   if (recinfo[2].type == FIELD_BLOB)
  478.   {
  479.     char *column;
  480.     int length;
  481.     length=uint4korr(pos);
  482.     memcpy_fixed(&column,pos+4,sizeof(char*));
  483.     memcpy(blob_record,column,length);
  484.     bfill(blob_record+length,20,'.');    /* Make it larger */
  485.     length+=20;
  486.     int4store(pos,length);
  487.     column=blob_record;
  488.     memcpy_fixed(pos+4,&column,sizeof(char*));
  489.   }
  490.   else if (recinfo[2].type == FIELD_VARCHAR)
  491.   {
  492.     /* Second field is longer than 10 characters */
  493.     uint length=uint2korr(pos);
  494.     bfill(pos+2+length,recinfo[2].length-length-2,'.');
  495.     length=recinfo[2].length-2;
  496.     int2store(pos,length);
  497.   }
  498.   else
  499.   {
  500.     bfill(pos+recinfo[2].length-10,10,'.');
  501.   }
  502. }
  503.  
  504.  
  505. static struct option long_options[] =
  506. {
  507.   {"checksum",        no_argument,        0, 'c'},
  508. #ifndef DBUG_OFF
  509.   {"debug",        required_argument,    0, '#'},
  510. #endif
  511.   {"delete_rows",    required_argument,    0, 'd'},
  512.   {"help",        no_argument,        0, '?'},
  513.   {"insert_rows",    required_argument,    0, 'i'},
  514.   {"key_alpha",        no_argument,        0, 'a'},
  515.   {"key_binary_pack",    no_argument,        0, 'B'},
  516.   {"key_blob",        required_argument,    0, 'b'},
  517.   {"key_cache",        no_argument,        0, 'K'},
  518.   {"key_length",    required_argument,    0, 'k'},
  519.   {"key_multiple",    no_argument,        0, 'm'},
  520.   {"key_prefix_pack",    no_argument,        0, 'P'},
  521.   {"key_space_pack",    no_argument,        0, 'p'},
  522.   {"key_varchar",    no_argument,        0, 'w'},
  523.   {"null_fields",    no_argument,        0, 'N'},
  524.   {"row_fixed_size",    no_argument,        0, 'S'},
  525.   {"row_pointer_size",    required_argument,    0, 'R'},
  526.   {"silent",        no_argument,        0, 's'},
  527.   {"skip_update",    no_argument,        0, 'U'},
  528.   {"unique",        no_argument,        0, 'C'},
  529.   {"update_rows",    required_argument,    0, 'u'},
  530.   {"verbose",        no_argument,        0, 'v'},
  531.   {"version",        no_argument,        0, 'V'},
  532.   {0, 0, 0, 0}
  533. };
  534.  
  535.  
  536. /* Read options */
  537.  
  538. static void get_options(int argc,char *argv[])
  539. {
  540.   int c,option_index=0;
  541.  
  542.   while ((c=getopt_long(argc,argv,"abBcCd:i:k:KmPR:SspNu:UvVw#:",
  543.             long_options, &option_index)) != EOF)
  544.   {
  545.     switch(c) {
  546.     case 'a':
  547.       key_type= HA_KEYTYPE_TEXT;
  548.       break;
  549.     case 'c':
  550.       create_flag|= HA_CREATE_CHECKSUM;
  551.       break;
  552.     case 'C':
  553.       opt_unique=1;
  554.       break;
  555.     case 'R':                /* Length of record pointer */
  556.       rec_pointer_size=atoi(optarg);
  557.       if (rec_pointer_size > 3)
  558.     rec_pointer_size=0;
  559.       break;
  560.     case 'P':
  561.       pack_keys= HA_PACK_KEY;        /* Use prefix compression */
  562.       break;
  563.     case 'B':
  564.       pack_keys= HA_BINARY_PACK_KEY;    /* Use binary compression */
  565.       break;
  566.     case 'S':
  567.       if (key_field == FIELD_VARCHAR)
  568.       {
  569.     create_flag=0;            /* Static sized varchar */
  570.       }
  571.       else if (key_field != FIELD_BLOB)
  572.       {
  573.     key_field=FIELD_NORMAL;        /* static-size record */
  574.     extra_field=FIELD_NORMAL;
  575.       }
  576.       break;
  577.     case 'p':
  578.       pack_keys=HA_PACK_KEY;        /* Use prefix + space packing */
  579.       pack_seg=HA_SPACE_PACK;
  580.       key_type=HA_KEYTYPE_TEXT;
  581.       break;
  582.     case 'N':
  583.       null_fields=1;            /* First key part may be null */
  584.       break;
  585.     case 'v':                /* verbose */
  586.       verbose=1;
  587.       break;
  588.     case 'd':
  589.       remove_count=atoi(optarg);
  590.       break;
  591.     case 'i':
  592.       insert_count=atoi(optarg);
  593.       break;
  594.     case 'u':
  595.       update_count=atoi(optarg);
  596.       break;
  597.     case 'U':
  598.       skip_update=1;
  599.       break;
  600.     case 'm':
  601.       unique_key=0;
  602.       break;
  603.     case 'b':
  604.       key_field=FIELD_BLOB;            /* blob key */
  605.       extra_field= FIELD_BLOB;
  606.       pack_seg|= HA_BLOB_PART;
  607.       key_type= HA_KEYTYPE_VARTEXT;
  608.       break;
  609.     case 'k':
  610.       key_length=atoi(optarg);
  611.       if (key_length < 4 || key_length > MI_MAX_KEY_LENGTH)
  612.       {
  613.     fprintf(stderr,"Wrong key length\n");
  614.     exit(1);
  615.       }
  616.       break;
  617.     case 's':
  618.       silent=1;
  619.       break;
  620.     case 'w':
  621.       key_field=FIELD_VARCHAR;            /* varchar keys */
  622.       extra_field= FIELD_VARCHAR;
  623.       key_type= HA_KEYTYPE_VARTEXT;
  624.       pack_seg|= HA_VAR_LENGTH;
  625.       create_flag|= HA_PACK_RECORD;
  626.       break;
  627.     case 'K':                /* Use key cacheing */
  628.       key_cacheing=1;
  629.       break;
  630.     case 'V':
  631.       printf("test1 Ver 1.0 \n");
  632.       exit(0);
  633.     case '#':
  634.       DEBUGGER_ON;
  635.       DBUG_PUSH (optarg);
  636.       break;
  637.     }
  638.   }
  639.   return;
  640. } /* get options */
  641.