开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mi_test1.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：18k
源码类别：

MySQL数据库

开发平台：

Visual C++

mi_test1.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  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.
  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.
  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 */
  17. /* Testing of the basic functions of a MyISAM table */
  19. #include "myisam.h"
  20. #include <my_getopt.h>
  21. #include <m_string.h>
  23. #define MAX_REC_LENGTH 1024
  25. static void usage();
  27. static int rec_pointer_size=0, flags[50];
  28. static int key_field=FIELD_SKIP_PRESPACE,extra_field=FIELD_SKIP_ENDSPACE;
  29. static int key_type=HA_KEYTYPE_NUM;
  30. static int create_flag=0;
  32. static uint insert_count, update_count, remove_count;
  33. static uint pack_keys=0, pack_seg=0, key_length;
  34. static uint unique_key=HA_NOSAME;
  35. static my_bool key_cacheing, null_fields, silent, skip_update, opt_unique,
  36.                verbose;
  37. static MI_COLUMNDEF recinfo[4];
  38. static MI_KEYDEF keyinfo[10];
  39. static HA_KEYSEG keyseg[10];
  40. static HA_KEYSEG uniqueseg[10];
  42. static int run_test(const char *filename);
  43. static void get_options(int argc, char *argv[]);
  44. static void create_key(char *key,uint rownr);
  45. static void create_record(char *record,uint rownr);
  46. static void update_record(char *record);
  48. int main(int argc,char *argv[])
  49. {
  50.   MY_INIT(argv[0]);
  51.   my_init();
  52.   if (key_cacheing)
  53.     init_key_cache(dflt_key_cache,KEY_CACHE_BLOCK_SIZE,IO_SIZE*16,0,0);
  54.   get_options(argc,argv);
  56.   exit(run_test("test1"));
  57. }
  60. static int run_test(const char *filename)
  61. {
  62.   MI_INFO *file;
  63.   int i,j,error,deleted,rec_length,uniques=0;
  64.   ha_rows found,row_count;
  65.   my_off_t pos;
  66.   char record[MAX_REC_LENGTH],key[MAX_REC_LENGTH],read_record[MAX_REC_LENGTH];
  67.   MI_UNIQUEDEF uniquedef;
  68.   MI_CREATE_INFO create_info;
  70.   bzero((char*) recinfo,sizeof(recinfo));
  72.   /* First define 2 columns */
  73.   recinfo[0].type=FIELD_NORMAL; recinfo[0].length=1; /* For NULL bits */
  74.   recinfo[1].type=key_field;
  75.   recinfo[1].length= (key_field == FIELD_BLOB ? 4+mi_portable_sizeof_char_ptr :
  76.       key_length);
  77.   if (key_field == FIELD_VARCHAR)
  78.     recinfo[1].length+=2;
  79.   recinfo[2].type=extra_field;
  80.   recinfo[2].length= (extra_field == FIELD_BLOB ? 4 + mi_portable_sizeof_char_ptr : 24);
  81.   if (extra_field == FIELD_VARCHAR)
  82.     recinfo[2].length+=2;
  83.   if (opt_unique)
  84.   {
  85.     recinfo[3].type=FIELD_CHECK;
  86.     recinfo[3].length=MI_UNIQUE_HASH_LENGTH;
  87.   }
  88.   rec_length=recinfo[0].length+recinfo[1].length+recinfo[2].length+
  89.     recinfo[3].length;
  92.   /* Define a key over the first column */
  93.   keyinfo[0].seg=keyseg;
  94.   keyinfo[0].keysegs=1;
  95.   keyinfo[0].key_alg=HA_KEY_ALG_BTREE;
  96.   keyinfo[0].seg[0].type= key_type;
  97.   keyinfo[0].seg[0].flag= pack_seg;
  98.   keyinfo[0].seg[0].start=1;
  99.   keyinfo[0].seg[0].length=key_length;
  100.   keyinfo[0].seg[0].null_bit= null_fields ? 2 : 0;
  101.   keyinfo[0].seg[0].null_pos=0;
  102.   keyinfo[0].seg[0].language= default_charset_info->number;
  103.   if (pack_seg & HA_BLOB_PART)
  104.   {
  105.     keyinfo[0].seg[0].bit_start=4; /* Length of blob length */
  106.   }
  107.   keyinfo[0].flag = (uint8) (pack_keys | unique_key);
  109.   bzero((byte*) flags,sizeof(flags));
  110.   if (opt_unique)
  111.   {
  112.     uint start;
  113.     uniques=1;
  114.     bzero((char*) &uniquedef,sizeof(uniquedef));
  115.     bzero((char*) uniqueseg,sizeof(uniqueseg));
  116.     uniquedef.seg=uniqueseg;
  117.     uniquedef.keysegs=2;
  119.     /* Make a unique over all columns (except first NULL fields) */
  120.     for (i=0, start=1 ; i < 2 ; i++)
  121.     {
  122.       uniqueseg[i].start=start;
  123.       start+=recinfo[i+1].length;
  124.       uniqueseg[i].length=recinfo[i+1].length;
  125.       uniqueseg[i].language= default_charset_info->number;
  126.     }
  127.     uniqueseg[0].type= key_type;
  128.     uniqueseg[0].null_bit= null_fields ? 2 : 0;
  129.     uniqueseg[1].type= HA_KEYTYPE_TEXT;
  130.     if (extra_field == FIELD_BLOB)
  131.     {
  132.       uniqueseg[1].length=0; /* The whole blob */
  133.       uniqueseg[1].bit_start=4; /* long blob */
  134.       uniqueseg[1].flag|= HA_BLOB_PART;
  135.     }
  136.     else if (extra_field == FIELD_VARCHAR)
  137.       uniqueseg[1].flag|= HA_VAR_LENGTH;
  138.   }
  139.   else
  140.     uniques=0;
  142.   if (!silent)
  143.     printf("- Creating isam-filen");
  144.   bzero((char*) &create_info,sizeof(create_info));
  145.   create_info.max_rows=(ulong) (rec_pointer_size ?
  146. (1L << (rec_pointer_size*8))/40 :
  147. 0);
  148.   if (mi_create(filename,1,keyinfo,3+opt_unique,recinfo,
  149. uniques, &uniquedef, &create_info,
  150. create_flag))
  151.     goto err;
  152.   if (!(file=mi_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
  153.     goto err;
  154.   if (!silent)
  155.     printf("- Writing key:sn");
  157.   my_errno=0;
  158.   row_count=deleted=0;
  159.   for (i=49 ; i>=1 ; i-=2 )
  160.   {
  161.     if (insert_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
  162.     j=i%25 +1;
  163.     create_record(record,j);
  164.     error=mi_write(file,record);
  165.     if (!error)
  166.       row_count++;
  167.     flags[j]=1;
  168.     if (verbose || error)
  169.       printf("J= %2d  mi_write: %d  errno: %dn", j,error,my_errno);
  170.   }
  172.   /* Insert 2 rows with null values */
  173.   if (null_fields)
  174.   {
  175.     create_record(record,0);
  176.     error=mi_write(file,record);
  177.     if (!error)
  178.       row_count++;
  179.     if (verbose || error)
  180.       printf("J= NULL  mi_write: %d  errno: %dn", error,my_errno);
  181.     error=mi_write(file,record);
  182.     if (!error)
  183.       row_count++;
  184.     if (verbose || error)
  185.       printf("J= NULL  mi_write: %d  errno: %dn", error,my_errno);
  186.     flags[0]=2;
  187.   }
  189.   if (!skip_update)
  190.   {
  191.     if (opt_unique)
  192.     {
  193.       if (!silent)
  194. printf("- Checking unique constraintn");
  195.       create_record(record,j);
  196.       if (!mi_write(file,record) || my_errno != HA_ERR_FOUND_DUPP_UNIQUE)
  197.       {
  198. printf("unique check failedn");
  199.       }
  200.     }
  201.     if (!silent)
  202.       printf("- Updating rowsn");
  204.     /* Update first last row to force extend of file */
  205.     if (mi_rsame(file,read_record,-1))
  206.     {
  207.       printf("Can't find last row with mi_rsamen");
  208.     }
  209.     else
  210.     {
  211.       memcpy(record,read_record,rec_length);
  212.       update_record(record);
  213.       if (mi_update(file,read_record,record))
  214.       {
  215. printf("Can't update last row: %.*sn",
  216.        keyinfo[0].seg[0].length,read_record+1);
  217.       }
  218.     }
  220.     /* Read through all rows and update them */
  221.     pos=(my_off_t) 0;
  222.     found=0;
  223.     while ((error=mi_rrnd(file,read_record,pos)) == 0)
  224.     {
  225.       if (update_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
  226.       memcpy(record,read_record,rec_length);
  227.       update_record(record);
  228.       if (mi_update(file,read_record,record))
  229.       {
  230. printf("Can't update row: %.*s, error: %dn",
  231.        keyinfo[0].seg[0].length,record+1,my_errno);
  232.       }
  233.       found++;
  234.       pos=HA_OFFSET_ERROR;
  235.     }
  236.     if (found != row_count)
  237.       printf("Found %ld of %ld rowsn", found,row_count);
  238.   }
  240.   if (!silent)
  241.     printf("- Reopening filen");
  242.   if (mi_close(file)) goto err;
  243.   if (!(file=mi_open(filename,2,HA_OPEN_ABORT_IF_LOCKED))) goto err;
  244.   if (!skip_update)
  245.   {
  246.     if (!silent)
  247.       printf("- Removing keysn");
  249.     for (i=0 ; i <= 10 ; i++)
  250.     {
  251.       /* testing */
  252.       if (remove_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
  253.       j=i*2;
  254.       if (!flags[j])
  255. continue;
  256.       create_key(key,j);
  257.       my_errno=0;
  258.       if ((error = mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT)))
  259.       {
  260. if (verbose || (flags[j] >= 1 ||
  261. (error && my_errno != HA_ERR_KEY_NOT_FOUND)))
  262.   printf("key: '%.*s'  mi_rkey:  %3d  errno: %3dn",
  263.  (int) key_length,key+test(null_fields),error,my_errno);
  264.       }
  265.       else
  266.       {
  267. error=mi_delete(file,read_record);
  268. if (verbose || error)
  269.   printf("key: '%.*s'  mi_delete: %3d  errno: %3dn",
  270.  (int) key_length, key+test(null_fields), error, my_errno);
  271. if (! error)
  272. {
  273.   deleted++;
  274.   flags[j]--;
  275. }
  276.       }
  277.     }
  278.   }
  279.   if (!silent)
  280.     printf("- Reading rows with keyn");
  281.   for (i=0 ; i <= 25 ; i++)
  282.   {
  283.     create_key(key,i);
  284.     my_errno=0;
  285.     error=mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT);
  286.     if (verbose ||
  287. (error == 0 && flags[i] == 0 && unique_key) ||
  288. (error && (flags[i] != 0 || my_errno != HA_ERR_KEY_NOT_FOUND)))
  289.     {
  290.       printf("key: '%.*s'  mi_rkey: %3d  errno: %3d  record: %sn",
  291.      (int) key_length,key+test(null_fields),error,my_errno,record+1);
  292.     }
  293.   }
  295.   if (!silent)
  296.     printf("- Reading rows with positionn");
  297.   for (i=1,found=0 ; i <= 30 ; i++)
  298.   {
  299.     my_errno=0;
  300.     if ((error=mi_rrnd(file,read_record,i == 1 ? 0L : HA_OFFSET_ERROR)) == -1)
  301.     {
  302.       if (found != row_count-deleted)
  303. printf("Found only %ld of %ld rowsn",found,row_count-deleted);
  304.       break;
  305.     }
  306.     if (!error)
  307.       found++;
  308.     if (verbose || (error != 0 && error != HA_ERR_RECORD_DELETED &&
  309.     error != HA_ERR_END_OF_FILE))
  310.     {
  311.       printf("pos: %2d  mi_rrnd: %3d  errno: %3d  record: %sn",
  312.      i-1,error,my_errno,read_record+1);
  313.     }
  314.   }
  315.   if (mi_close(file)) goto err;
  316.   my_end(MY_CHECK_ERROR);
  318.   return (0);
  319. err:
  320.   printf("got error: %3d when using myisam-databasen",my_errno);
  321.   return 1; /* skip warning */
  322. }
  325. static void create_key_part(char *key,uint rownr)
  326. {
  327.   if (!unique_key)
  328.     rownr&=7; /* Some identical keys */
  329.   if (keyinfo[0].seg[0].type == HA_KEYTYPE_NUM)
  330.   {
  331.     sprintf(key,"%*d",keyinfo[0].seg[0].length,rownr);
  332.   }
  333.   else if (keyinfo[0].seg[0].type == HA_KEYTYPE_VARTEXT)
  334.   { /* Alpha record */
  335.     /* Create a key that may be easily packed */
  336.     bfill(key,keyinfo[0].seg[0].length,rownr < 10 ? 'A' : 'B');
  337.     sprintf(key+keyinfo[0].seg[0].length-2,"%-2d",rownr);
  338.     if ((rownr & 7) == 0)
  339.     {
  340.       /* Change the key to force a unpack of the next key */
  341.       bfill(key+3,keyinfo[0].seg[0].length-4,rownr < 10 ? 'a' : 'b');
  342.     }
  343.   }
  344.   else
  345.   { /* Alpha record */
  346.     if (keyinfo[0].seg[0].flag & HA_SPACE_PACK)
  347.       sprintf(key,"%-*d",keyinfo[0].seg[0].length,rownr);
  348.     else
  349.     {
  350.       /* Create a key that may be easily packed */
  351.       bfill(key,keyinfo[0].seg[0].length,rownr < 10 ? 'A' : 'B');
  352.       sprintf(key+keyinfo[0].seg[0].length-2,"%-2d",rownr);
  353.       if ((rownr & 7) == 0)
  354.       {
  355. /* Change the key to force a unpack of the next key */
  356. key[1]= (rownr < 10 ? 'a' : 'b');
  357.       }
  358.     }
  359.   }
  360. }
  363. static void create_key(char *key,uint rownr)
  364. {
  365.   if (keyinfo[0].seg[0].null_bit)
  366.   {
  367.     if (rownr == 0)
  368.     {
  369.       key[0]=1; /* null key */
  370.       key[1]=0; /* Fore easy print of key */
  371.       return;
  372.     }
  373.     *key++=0;
  374.   }
  375.   if (keyinfo[0].seg[0].flag & (HA_BLOB_PART | HA_VAR_LENGTH))
  376.   {
  377.     uint tmp;
  378.     create_key_part(key+2,rownr);
  379.     tmp=strlen(key+2);
  380.     int2store(key,tmp);
  381.   }
  382.   else
  383.     create_key_part(key,rownr);
  384. }
  387. static char blob_key[MAX_REC_LENGTH];
  388. static char blob_record[MAX_REC_LENGTH+20*20];
  391. static void create_record(char *record,uint rownr)
  392. {
  393.   char *pos;
  394.   bzero((char*) record,MAX_REC_LENGTH);
  395.   record[0]=1; /* delete marker */
  396.   if (rownr == 0 && keyinfo[0].seg[0].null_bit)
  397.     record[0]|=keyinfo[0].seg[0].null_bit; /* Null key */
  399.   pos=record+1;
  400.   if (recinfo[1].type == FIELD_BLOB)
  401.   {
  402.     uint tmp;
  403.     char *ptr;
  404.     create_key_part(blob_key,rownr);
  405.     tmp=strlen(blob_key);
  406.     int4store(pos,tmp);
  407.     ptr=blob_key;
  408.     memcpy_fixed(pos+4,&ptr,sizeof(char*));
  409.     pos+=recinfo[1].length;
  410.   }
  411.   else if (recinfo[1].type == FIELD_VARCHAR)
  412.   {
  413.     uint tmp;
  414.     create_key_part(pos+2,rownr);
  415.     tmp=strlen(pos+2);
  416.     int2store(pos,tmp);
  417.     pos+=recinfo[1].length;
  418.   }
  419.   else
  420.   {
  421.     create_key_part(pos,rownr);
  422.     pos+=recinfo[1].length;
  423.   }
  424.   if (recinfo[2].type == FIELD_BLOB)
  425.   {
  426.     uint tmp;
  427.     char *ptr;;
  428.     sprintf(blob_record,"... row: %d", rownr);
  429.     strappend(blob_record,max(MAX_REC_LENGTH-rownr,10),' ');
  430.     tmp=strlen(blob_record);
  431.     int4store(pos,tmp);
  432.     ptr=blob_record;
  433.     memcpy_fixed(pos+4,&ptr,sizeof(char*));
  434.   }
  435.   else if (recinfo[2].type == FIELD_VARCHAR)
  436.   {
  437.     uint tmp;
  438.     sprintf(pos+2,"... row: %d", rownr);
  439.     tmp=strlen(pos+2);
  440.     int2store(pos,tmp);
  441.   }
  442.   else
  443.   {
  444.     sprintf(pos,"... row: %d", rownr);
  445.     strappend(pos,recinfo[2].length,' ');
  446.   }
  447. }
  449. /* change row to test re-packing of rows and reallocation of keys */
  451. static void update_record(char *record)
  452. {
  453.   char *pos=record+1;
  454.   if (recinfo[1].type == FIELD_BLOB)
  455.   {
  456.     char *column,*ptr;
  457.     int length;
  458.     length=uint4korr(pos); /* Long blob */
  459.     memcpy_fixed(&column,pos+4,sizeof(char*));
  460.     memcpy(blob_key,column,length); /* Move old key */
  461.     ptr=blob_key;
  462.     memcpy_fixed(pos+4,&ptr,sizeof(char*)); /* Store pointer to new key */
  463.     if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
  464.       my_casedn(default_charset_info,blob_key,length);
  465.     pos+=recinfo[1].length;
  466.   }
  467.   else if (recinfo[1].type == FIELD_VARCHAR)
  468.   {
  469.     uint length=uint2korr(pos);
  470.     my_casedn(default_charset_info,pos+2,length);
  471.     pos+=recinfo[1].length;
  472.   }
  473.   else
  474.   {
  475.     if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
  476.       my_casedn(default_charset_info,pos,keyinfo[0].seg[0].length);
  477.     pos+=recinfo[1].length;
  478.   }
  480.   if (recinfo[2].type == FIELD_BLOB)
  481.   {
  482.     char *column;
  483.     int length;
  484.     length=uint4korr(pos);
  485.     memcpy_fixed(&column,pos+4,sizeof(char*));
  486.     memcpy(blob_record,column,length);
  487.     bfill(blob_record+length,20,'.'); /* Make it larger */
  488.     length+=20;
  489.     int4store(pos,length);
  490.     column=blob_record;
  491.     memcpy_fixed(pos+4,&column,sizeof(char*));
  492.   }
  493.   else if (recinfo[2].type == FIELD_VARCHAR)
  494.   {
  495.     /* Second field is longer than 10 characters */
  496.     uint length=uint2korr(pos);
  497.     bfill(pos+2+length,recinfo[2].length-length-2,'.');
  498.     length=recinfo[2].length-2;
  499.     int2store(pos,length);
  500.   }
  501.   else
  502.   {
  503.     bfill(pos+recinfo[2].length-10,10,'.');
  504.   }
  505. }
  508. static struct my_option my_long_options[] =
  509. {
  510.   {"checksum", 'c', "Undocumented",
  511.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  512. #ifndef DBUG_OFF
  513.   {"debug", '#', "Undocumented",
  514.    0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  515. #endif
  516.   {"delete_rows", 'd', "Undocumented", (gptr*) &remove_count,
  517.    (gptr*) &remove_count, 0, GET_UINT, REQUIRED_ARG, 1000, 0, 0, 0, 0, 0},
  518.   {"help", '?', "Display help and exit",
  519.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  520.   {"insert_rows", 'i', "Undocumented", (gptr*) &insert_count,
  521.    (gptr*) &insert_count, 0, GET_UINT, REQUIRED_ARG, 1000, 0, 0, 0, 0, 0},
  522.   {"key_alpha", 'a', "Undocumented",
  523.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  524.   {"key_binary_pack", 'B', "Undocumented",
  525.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  526.   {"key_blob", 'b', "Undocumented",
  527.    0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  528.   {"key_cache", 'K', "Undocumented", (gptr*) &key_cacheing,
  529.    (gptr*) &key_cacheing, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  530.   {"key_length", 'k', "Undocumented", (gptr*) &key_length, (gptr*) &key_length,
  531.    0, GET_UINT, REQUIRED_ARG, 6, 0, 0, 0, 0, 0},
  532.   {"key_multiple", 'm', "Undocumented",
  533.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  534.   {"key_prefix_pack", 'P', "Undocumented",
  535.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  536.   {"key_space_pack", 'p', "Undocumented",
  537.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  538.   {"key_varchar", 'w', "Undocumented",
  539.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  540.   {"null_fields", 'N', "Undocumented",
  541.    (gptr*) &null_fields, (gptr*) &null_fields, 0, GET_BOOL, NO_ARG,
  542.    0, 0, 0, 0, 0, 0},
  543.   {"row_fixed_size", 'S', "Undocumented",
  544.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  545.   {"row_pointer_size", 'R', "Undocumented", (gptr*) &rec_pointer_size,
  546.    (gptr*) &rec_pointer_size, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  547.   {"silent", 's', "Undocumented",
  548.    (gptr*) &silent, (gptr*) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  549.   {"skip_update", 'U', "Undocumented", (gptr*) &skip_update,
  550.    (gptr*) &skip_update, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  551.   {"unique", 'C', "Undocumented", (gptr*) &opt_unique, (gptr*) &opt_unique, 0,
  552.    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  553.   {"update_rows", 'u', "Undocumented", (gptr*) &update_count,
  554.    (gptr*) &update_count, 0, GET_UINT, REQUIRED_ARG, 1000, 0, 0, 0, 0, 0},
  555.   {"verbose", 'v', "Be more verbose", (gptr*) &verbose, (gptr*) &verbose, 0,
  556.    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  557.   {"version", 'V', "Print version number and exit",
  558.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  559.   { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
  560. };
  563. static my_bool
  564. get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
  565.        char *argument)
  566. {
  567.   switch(optid) {
  568.   case 'a':
  569.     key_type= HA_KEYTYPE_TEXT;
  570.     break;
  571.   case 'c':
  572.     create_flag|= HA_CREATE_CHECKSUM;
  573.     break;
  574.   case 'R': /* Length of record pointer */
  575.     if (rec_pointer_size > 3)
  576.       rec_pointer_size=0;
  577.     break;
  578.   case 'P':
  579.     pack_keys= HA_PACK_KEY; /* Use prefix compression */
  580.     break;
  581.   case 'B':
  582.     pack_keys= HA_BINARY_PACK_KEY; /* Use binary compression */
  583.     break;
  584.   case 'S':
  585.     if (key_field == FIELD_VARCHAR)
  586.     {
  587.       create_flag=0; /* Static sized varchar */
  588.     }
  589.     else if (key_field != FIELD_BLOB)
  590.     {
  591.       key_field=FIELD_NORMAL; /* static-size record */
  592.       extra_field=FIELD_NORMAL;
  593.     }
  594.     break;
  595.   case 'p':
  596.     pack_keys=HA_PACK_KEY; /* Use prefix + space packing */
  597.     pack_seg=HA_SPACE_PACK;
  598.     key_type=HA_KEYTYPE_TEXT;
  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.     if (key_length < 4 || key_length > MI_MAX_KEY_LENGTH)
  611.     {
  612.       fprintf(stderr,"Wrong key lengthn");
  613.       exit(1);
  614.     }
  615.     break;
  616.   case 'w':
  617.     key_field=FIELD_VARCHAR; /* varchar keys */
  618.     extra_field= FIELD_VARCHAR;
  619.     key_type= HA_KEYTYPE_VARTEXT;
  620.     pack_seg|= HA_VAR_LENGTH;
  621.     create_flag|= HA_PACK_RECORD;
  622.     break;
  623.   case 'K': /* Use key cacheing */
  624.     key_cacheing=1;
  625.     break;
  626.   case 'V':
  627.     printf("test1 Ver 1.2 n");
  628.     exit(0);
  629.   case '#':
  630.     DEBUGGER_ON;
  631.     DBUG_PUSH (argument);
  632.     break;
  633.   case '?':
  634.     usage();
  635.     exit(1);
  636.   }
  637.   return 0;
  638. }
  641. /* Read options */
  643. static void get_options(int argc, char *argv[])
  644. {
  645.   int ho_error;
  647.   if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))
  648.     exit(ho_error);
  650.   return;
  651. } /* get options */
  654. static void usage()
  655. {
  656.   printf("Usage: %s [options]nn", my_progname);
  657.   my_print_help(my_long_options);
  658.   my_print_variables(my_long_options);
  659. }