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

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

MySQL数据库

开发平台：

Visual C++

mi_test2.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. /* Test av isam-databas: stor test */
  19. #ifndef USE_MY_FUNC /* We want to be able to dbug this !! */
  20. #define USE_MY_FUNC
  21. #endif
  22. #ifdef DBUG_OFF
  23. #undef DBUG_OFF
  24. #endif
  25. #ifndef SAFEMALLOC
  26. #define SAFEMALLOC
  27. #endif
  28. #include "myisamdef.h"
  29. #include <m_ctype.h>
  31. #define STANDARD_LENGTH 37
  32. #define MYISAM_KEYS 6
  33. #define MAX_PARTS 4
  34. #if !defined(MSDOS) && !defined(labs)
  35. #define labs(a) abs(a)
  36. #endif
  38. static void get_options(int argc, char *argv[]);
  39. static uint rnd(uint max_value);
  40. static void fix_length(byte *record,uint length);
  41. static void put_blob_in_record(char *blob_pos,char **blob_buffer);
  42. static void copy_key(struct st_myisam_info *info,uint inx,
  43.      uchar *record,uchar *key);
  45. static int verbose=0,testflag=0,
  46.     first_key=0,async_io=0,key_cacheing=0,write_cacheing=0,locking=0,
  47.             rec_pointer_size=0,pack_fields=1,use_log=0,silent=0,
  48.             opt_quick_mode=0;
  49. static int pack_seg=HA_SPACE_PACK,pack_type=HA_PACK_KEY,remove_count=-1,
  50.    create_flag=0;
  51. static ulong key_cache_size=IO_SIZE*16;
  52. static uint key_cache_block_size= KEY_CACHE_BLOCK_SIZE;
  54. static uint keys=MYISAM_KEYS,recant=1000;
  55. static uint use_blob=0;
  56. static uint16 key1[1001],key3[5000];
  57. static char record[300],record2[300],key[100],key2[100],
  58.     read_record[300],read_record2[300],read_record3[300];
  59. static HA_KEYSEG glob_keyseg[MYISAM_KEYS][MAX_PARTS];
  61. /* Test program */
  63. int main(int argc, char *argv[])
  64. {
  65.   uint i;
  66.   int j,n1,n2,n3,error,k;
  67.   uint write_count,update,dupp_keys,opt_delete,start,length,blob_pos,
  68.        reclength,ant,found_parts;
  69.   my_off_t lastpos;
  70.   ha_rows range_records,records;
  71.   MI_INFO *file;
  72.   MI_KEYDEF keyinfo[10];
  73.   MI_COLUMNDEF recinfo[10];
  74.   MI_ISAMINFO info;
  75.   const char *filename;
  76.   char *blob_buffer;
  77.   MI_CREATE_INFO create_info;
  78.   MY_INIT(argv[0]);
  80.   filename= "test2";
  81.   get_options(argc,argv);
  82.   if (! async_io)
  83.     my_disable_async_io=1;
  85.   reclength=STANDARD_LENGTH+60+(use_blob ? 8 : 0);
  86.   blob_pos=STANDARD_LENGTH+60;
  87.   keyinfo[0].seg= &glob_keyseg[0][0];
  88.   keyinfo[0].seg[0].start=0;
  89.   keyinfo[0].seg[0].length=6;
  90.   keyinfo[0].seg[0].type=HA_KEYTYPE_TEXT;
  91.   keyinfo[0].seg[0].language= default_charset_info->number;
  92.   keyinfo[0].seg[0].flag=(uint8) pack_seg;
  93.   keyinfo[0].seg[0].null_bit=0;
  94.   keyinfo[0].seg[0].null_pos=0;
  95.   keyinfo[0].key_alg=HA_KEY_ALG_BTREE;
  96.   keyinfo[0].keysegs=1;
  97.   keyinfo[0].flag = pack_type;
  98.   keyinfo[1].seg= &glob_keyseg[1][0];
  99.   keyinfo[1].seg[0].start=7;
  100.   keyinfo[1].seg[0].length=6;
  101.   keyinfo[1].seg[0].type=HA_KEYTYPE_BINARY;
  102.   keyinfo[1].seg[0].flag=0;
  103.   keyinfo[1].seg[0].null_bit=0;
  104.   keyinfo[1].seg[0].null_pos=0;
  105.   keyinfo[1].seg[1].start=0; /* two part key */
  106.   keyinfo[1].seg[1].length=6;
  107.   keyinfo[1].seg[1].type=HA_KEYTYPE_NUM;
  108.   keyinfo[1].seg[1].flag=HA_REVERSE_SORT;
  109.   keyinfo[1].seg[1].null_bit=0;
  110.   keyinfo[1].seg[1].null_pos=0;
  111.   keyinfo[1].key_alg=HA_KEY_ALG_BTREE;
  112.   keyinfo[1].keysegs=2;
  113.   keyinfo[1].flag =0;
  114.   keyinfo[2].seg= &glob_keyseg[2][0];
  115.   keyinfo[2].seg[0].start=12;
  116.   keyinfo[2].seg[0].length=8;
  117.   keyinfo[2].seg[0].type=HA_KEYTYPE_BINARY;
  118.   keyinfo[2].seg[0].flag=HA_REVERSE_SORT;
  119.   keyinfo[2].seg[0].null_bit=0;
  120.   keyinfo[2].seg[0].null_pos=0;
  121.   keyinfo[2].key_alg=HA_KEY_ALG_BTREE;
  122.   keyinfo[2].keysegs=1;
  123.   keyinfo[2].flag =HA_NOSAME;
  124.   keyinfo[3].seg= &glob_keyseg[3][0];
  125.   keyinfo[3].seg[0].start=0;
  126.   keyinfo[3].seg[0].length=reclength-(use_blob ? 8 : 0);
  127.   keyinfo[3].seg[0].type=HA_KEYTYPE_TEXT;
  128.   keyinfo[3].seg[0].language=default_charset_info->number;
  129.   keyinfo[3].seg[0].flag=(uint8) pack_seg;
  130.   keyinfo[3].seg[0].null_bit=0;
  131.   keyinfo[3].seg[0].null_pos=0;
  132.   keyinfo[3].key_alg=HA_KEY_ALG_BTREE;
  133.   keyinfo[3].keysegs=1;
  134.   keyinfo[3].flag = pack_type;
  135.   keyinfo[4].seg= &glob_keyseg[4][0];
  136.   keyinfo[4].seg[0].start=0;
  137.   keyinfo[4].seg[0].length=5;
  138.   keyinfo[4].seg[0].type=HA_KEYTYPE_TEXT;
  139.   keyinfo[4].seg[0].language=default_charset_info->number;
  140.   keyinfo[4].seg[0].flag=0;
  141.   keyinfo[4].seg[0].null_bit=0;
  142.   keyinfo[4].seg[0].null_pos=0;
  143.   keyinfo[4].key_alg=HA_KEY_ALG_BTREE;
  144.   keyinfo[4].keysegs=1;
  145.   keyinfo[4].flag = pack_type;
  146.   keyinfo[5].seg= &glob_keyseg[5][0];
  147.   keyinfo[5].seg[0].start=0;
  148.   keyinfo[5].seg[0].length=4;
  149.   keyinfo[5].seg[0].type=HA_KEYTYPE_TEXT;
  150.   keyinfo[5].seg[0].language=default_charset_info->number;
  151.   keyinfo[5].seg[0].flag=pack_seg;
  152.   keyinfo[5].seg[0].null_bit=0;
  153.   keyinfo[5].seg[0].null_pos=0;
  154.   keyinfo[5].key_alg=HA_KEY_ALG_BTREE;
  155.   keyinfo[5].keysegs=1;
  156.   keyinfo[5].flag = pack_type;
  158.   recinfo[0].type=pack_fields ? FIELD_SKIP_PRESPACE : 0;
  159.   recinfo[0].length=7;
  160.   recinfo[0].null_bit=0;
  161.   recinfo[0].null_pos=0;
  162.   recinfo[1].type=pack_fields ? FIELD_SKIP_PRESPACE : 0;
  163.   recinfo[1].length=5;
  164.   recinfo[1].null_bit=0;
  165.   recinfo[1].null_pos=0;
  166.   recinfo[2].type=pack_fields ? FIELD_SKIP_PRESPACE : 0;
  167.   recinfo[2].length=9;
  168.   recinfo[2].null_bit=0;
  169.   recinfo[2].null_pos=0;
  170.   recinfo[3].type=FIELD_NORMAL;
  171.   recinfo[3].length=STANDARD_LENGTH-7-5-9-4;
  172.   recinfo[3].null_bit=0;
  173.   recinfo[3].null_pos=0;
  174.   recinfo[4].type=pack_fields ? FIELD_SKIP_ZERO : 0;
  175.   recinfo[4].length=4;
  176.   recinfo[4].null_bit=0;
  177.   recinfo[4].null_pos=0;
  178.   recinfo[5].type=pack_fields ? FIELD_SKIP_ENDSPACE : 0;
  179.   recinfo[5].length=60;
  180.   recinfo[5].null_bit=0;
  181.   recinfo[5].null_pos=0;
  182.   if (use_blob)
  183.   {
  184.     recinfo[6].type=FIELD_BLOB;
  185.     recinfo[6].length=4+mi_portable_sizeof_char_ptr;
  186.     recinfo[6].null_bit=0;
  187.     recinfo[6].null_pos=0;
  188.   }
  190.   write_count=update=dupp_keys=opt_delete=0;
  191.   blob_buffer=0;
  193.   for (i=1000 ; i>0 ; i--) key1[i]=0;
  194.   for (i=4999 ; i>0 ; i--) key3[i]=0;
  196.   if (!silent)
  197.     printf("- Creating isam-filen");
  198.   /*  DBUG_PUSH(""); */
  199.   /* my_delete(filename,MYF(0)); */ /* Remove old locks under gdb */
  200.   file= 0;
  201.   bzero((char*) &create_info,sizeof(create_info));
  202.   create_info.max_rows=(ha_rows) (rec_pointer_size ?
  203.   (1L << (rec_pointer_size*8))/
  204.   reclength : 0);
  205.   create_info.reloc_rows=(ha_rows) 100;
  206.   if (mi_create(filename,keys,&keyinfo[first_key],
  207. use_blob ? 7 : 6, &recinfo[0],
  208. 0,(MI_UNIQUEDEF*) 0,
  209. &create_info,create_flag))
  210.     goto err;
  211.   if (use_log)
  212.     mi_log(1);
  213.   if (!(file=mi_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
  214.     goto err;
  215.   if (!silent)
  216.     printf("- Writing key:sn");
  217.   if (key_cacheing)
  218.     init_key_cache(dflt_key_cache,key_cache_block_size,key_cache_size,0,0);
  219.   if (locking)
  220.     mi_lock_database(file,F_WRLCK);
  221.   if (write_cacheing)
  222.     mi_extra(file,HA_EXTRA_WRITE_CACHE,0);
  223.   if (opt_quick_mode)
  224.     mi_extra(file,HA_EXTRA_QUICK,0);
  226.   for (i=0 ; i < recant ; i++)
  227.   {
  228.     n1=rnd(1000); n2=rnd(100); n3=rnd(5000);
  229.     sprintf(record,"%6d:%4d:%8d:Pos: %4d    ",n1,n2,n3,write_count);
  230.     int4store(record+STANDARD_LENGTH-4,(long) i);
  231.     fix_length(record,(uint) STANDARD_LENGTH+rnd(60));
  232.     put_blob_in_record(record+blob_pos,&blob_buffer);
  233.     DBUG_PRINT("test",("record: %d",i));
  235.     if (mi_write(file,record))
  236.     {
  237.       if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
  238.       {
  239. printf("Error: %d in write at record: %dn",my_errno,i);
  240. goto err;
  241.       }
  242.       if (verbose) printf("   Double key: %dn",n3);
  243.     }
  244.     else
  245.     {
  246.       if (key3[n3] == 1 && first_key <3 && first_key+keys >= 3)
  247.       {
  248. printf("Error: Didn't get error when writing second key: '%8d'n",n3);
  249. goto err;
  250.       }
  251.       write_count++; key1[n1]++; key3[n3]=1;
  252.     }
  254.     /* Check if we can find key without flushing database */
  255.     if (i == recant/2)
  256.     {
  257.       for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
  258.       if (!j)
  259. for (j=999 ; j>0 && key1[j] == 0 ; j--) ;
  260.       sprintf(key,"%6d",j);
  261.       if (mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT))
  262.       {
  263. printf("Test in loop: Can't find key: "%s"n",key);
  264. goto err;
  265.       }
  266.     }
  267.   }
  268.   if (testflag==1) goto end;
  270.   if (write_cacheing)
  271.   {
  272.     if (mi_extra(file,HA_EXTRA_NO_CACHE,0))
  273.     {
  274.       puts("got error from mi_extra(HA_EXTRA_NO_CACHE)");
  275.       goto end;
  276.     }
  277.   }
  278.   if (key_cacheing)
  279.     resize_key_cache(dflt_key_cache,key_cache_block_size,key_cache_size*2,0,0);
  281.   if (!silent)
  282.     printf("- Deleten");
  283.   for (i=0 ; i<recant/10 ; i++)
  284.   {
  285.     for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
  286.     if (j != 0)
  287.     {
  288.       sprintf(key,"%6d",j);
  289.       if (mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT))
  290.       {
  291. printf("can't find key1: "%s"n",key);
  292. goto err;
  293.       }
  294.       if (opt_delete == (uint) remove_count) /* While testing */
  295. goto end;
  296.       if (mi_delete(file,read_record))
  297.       {
  298. printf("error: %d; can't delete record: "%s"n", my_errno,read_record);
  299. goto err;
  300.       }
  301.       opt_delete++;
  302.       key1[atoi(read_record+keyinfo[0].seg[0].start)]--;
  303.       key3[atoi(read_record+keyinfo[2].seg[0].start)]=0;
  304.     }
  305.     else
  306.       puts("Warning: Skipping delete test because no dupplicate keys");
  307.   }
  308.   if (testflag==2) goto end;
  310.   if (!silent)
  311.     printf("- Updaten");
  312.   for (i=0 ; i<recant/10 ; i++)
  313.   {
  314.     n1=rnd(1000); n2=rnd(100); n3=rnd(5000);
  315.     sprintf(record2,"%6d:%4d:%8d:XXX: %4d     ",n1,n2,n3,update);
  316.     int4store(record2+STANDARD_LENGTH-4,(long) i);
  317.     fix_length(record2,(uint) STANDARD_LENGTH+rnd(60));
  319.     for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
  320.     if (j != 0)
  321.     {
  322.       sprintf(key,"%6d",j);
  323.       if (mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT))
  324.       {
  325. printf("can't find key1: "%s"n",key);
  326. goto err;
  327.       }
  328.       if (use_blob)
  329.       {
  330. if (i & 1)
  331.   put_blob_in_record(record+blob_pos,&blob_buffer);
  332. else
  333.   bmove(record+blob_pos,read_record+blob_pos,8);
  334.       }
  335.       if (mi_update(file,read_record,record2))
  336.       {
  337. if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
  338. {
  339.   printf("error: %d; can't update:nFrom: "%s"nTo:   "%s"n",
  340.  my_errno,read_record,record2);
  341.   goto err;
  342. }
  343. if (verbose)
  344.   printf("Double key when tried to update:nFrom: "%s"nTo:   "%s"n",record,record2);
  345.       }
  346.       else
  347.       {
  348. key1[atoi(read_record+keyinfo[0].seg[0].start)]--;
  349. key3[atoi(read_record+keyinfo[2].seg[0].start)]=0;
  350. key1[n1]++; key3[n3]=1;
  351. update++;
  352.       }
  353.     }
  354.   }
  355.   if (testflag == 3)
  356.     goto end;
  358.   for (i=999, dupp_keys=j=0 ; i>0 ; i--)
  359.   {
  360.     if (key1[i] > dupp_keys)
  361.     {
  362.       dupp_keys=key1[i]; j=i;
  363.     }
  364.   }
  365.   sprintf(key,"%6d",j);
  366.   start=keyinfo[0].seg[0].start;
  367.   length=keyinfo[0].seg[0].length;
  368.   if (dupp_keys)
  369.   {
  370.     if (!silent)
  371.       printf("- Same key: first - next -> last - prev -> firstn");
  372.     DBUG_PRINT("progpos",("first - next -> last - prev -> first"));
  373.     if (verbose) printf("  Using key: "%s"  Keys: %dn",key,dupp_keys);
  375.     if (mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT))
  376.       goto err;
  377.     if (mi_rsame(file,read_record2,-1))
  378.       goto err;
  379.     if (memcmp(read_record,read_record2,reclength) != 0)
  380.     {
  381.       printf("mi_rsame didn't find same recordn");
  382.       goto end;
  383.     }
  384.     info.recpos=mi_position(file);
  385.     if (mi_rfirst(file,read_record2,0) ||
  386. mi_rsame_with_pos(file,read_record2,0,info.recpos) ||
  387. memcmp(read_record,read_record2,reclength) != 0)
  388.     {
  389.       printf("mi_rsame_with_pos didn't find same recordn");
  390.       goto end;
  391.     }
  392.     {
  393.       int skr=mi_rnext(file,read_record2,0);
  394.       if ((skr && my_errno != HA_ERR_END_OF_FILE) ||
  395.   mi_rprev(file,read_record2,-1) ||
  396.   memcmp(read_record,read_record2,reclength) != 0)
  397.       {
  398. printf("mi_rsame_with_pos lost positionn");
  399. goto end;
  400.       }
  401.     }
  402.     ant=1;
  403.     while (mi_rnext(file,read_record2,0) == 0 &&
  404.    memcmp(read_record2+start,key,length) == 0) ant++;
  405.     if (ant != dupp_keys)
  406.     {
  407.       printf("next: Found: %d keys of %dn",ant,dupp_keys);
  408.       goto end;
  409.     }
  410.     ant=0;
  411.     while (mi_rprev(file,read_record3,0) == 0 &&
  412.    bcmp(read_record3+start,key,length) == 0) ant++;
  413.     if (ant != dupp_keys)
  414.     {
  415.       printf("prev: Found: %d records of %dn",ant,dupp_keys);
  416.       goto end;
  417.     }
  419.     /* Check of mi_rnext_same */
  420.     if (mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT))
  421.       goto err;
  422.     ant=1;
  423.     while (!mi_rnext_same(file,read_record3) && ant < dupp_keys+10)
  424.       ant++;
  425.     if (ant != dupp_keys || my_errno != HA_ERR_END_OF_FILE)
  426.     {
  427.       printf("mi_rnext_same: Found: %d records of %dn",ant,dupp_keys);
  428.       goto end;
  429.     }
  430.   }
  432.   if (!silent)
  433.     printf("- All keys: first - next -> last - prev -> firstn");
  434.   DBUG_PRINT("progpos",("All keys: first - next -> last - prev -> first"));
  435.   ant=1;
  436.   if (mi_rfirst(file,read_record,0))
  437.   {
  438.     printf("Can't find first recordn");
  439.     goto end;
  440.   }
  441.   while ((error=mi_rnext(file,read_record3,0)) == 0 && ant < write_count+10)
  442.     ant++;
  443.   if (ant != write_count - opt_delete || error != HA_ERR_END_OF_FILE)
  444.   {
  445.     printf("next: I found: %d records of %d (error: %d)n",
  446.    ant, write_count - opt_delete, error);
  447.     goto end;
  448.   }
  449.   if (mi_rlast(file,read_record2,0) ||
  450.       bcmp(read_record2,read_record3,reclength))
  451.   {
  452.     printf("Can't find last recordn");
  453.     DBUG_DUMP("record2",(byte*) read_record2,reclength);
  454.     DBUG_DUMP("record3",(byte*) read_record3,reclength);
  455.     goto end;
  456.   }
  457.   ant=1;
  458.   while (mi_rprev(file,read_record3,0) == 0 && ant < write_count+10)
  459.     ant++;
  460.   if (ant != write_count - opt_delete)
  461.   {
  462.     printf("prev: I found: %d records of %dn",ant,write_count);
  463.     goto end;
  464.   }
  465.   if (bcmp(read_record,read_record3,reclength))
  466.   {
  467.     printf("Can't find first recordn");
  468.     goto end;
  469.   }
  471.   if (!silent)
  472.     printf("- Test if: Read first - next - prev - prev - next == firstn");
  473.   DBUG_PRINT("progpos",("- Read first - next - prev - prev - next == first"));
  474.   if (mi_rfirst(file,read_record,0) ||
  475.       mi_rnext(file,read_record3,0) ||
  476.       mi_rprev(file,read_record3,0) ||
  477.       mi_rprev(file,read_record3,0) == 0 ||
  478.       mi_rnext(file,read_record3,0))
  479.       goto err;
  480.   if (bcmp(read_record,read_record3,reclength) != 0)
  481.      printf("Can't find first recordn");
  483.   if (!silent)
  484.     printf("- Test if: Read last - prev - next - next - prev == lastn");
  485.   DBUG_PRINT("progpos",("Read last - prev - next - next - prev == last"));
  486.   if (mi_rlast(file,read_record2,0) ||
  487.       mi_rprev(file,read_record3,0) ||
  488.       mi_rnext(file,read_record3,0) ||
  489.       mi_rnext(file,read_record3,0) == 0 ||
  490.       mi_rprev(file,read_record3,0))
  491.       goto err;
  492.   if (bcmp(read_record2,read_record3,reclength))
  493.      printf("Can't find last recordn");
  495.   if (!silent)
  496.     puts("- Test read key-part");
  497.   strmov(key2,key);
  498.   for(i=strlen(key2) ; i-- > 1 ;)
  499.   {
  500.     key2[i]=0;
  502.     /* The following row is just to catch some bugs in the key code */
  503.     bzero((char*) file->lastkey,file->s->base.max_key_length*2);
  504.     if (mi_rkey(file,read_record,0,key2,(uint) i,HA_READ_PREFIX))
  505.       goto err;
  506.     if (bcmp(read_record+start,key,(uint) i))
  507.     {
  508.       puts("Didn't find right record");
  509.       goto end;
  510.     }
  511.   }
  512.   if (dupp_keys > 2)
  513.   {
  514.     if (!silent)
  515.       printf("- Read key (first) - next - delete - next -> lastn");
  516.     DBUG_PRINT("progpos",("first - next - delete - next -> last"));
  517.     if (mi_rkey(file,read_record,0,key,0,HA_READ_KEY_EXACT)) goto err;
  518.     if (mi_rnext(file,read_record3,0)) goto err;
  519.     if (mi_delete(file,read_record3)) goto err;
  520.     opt_delete++;
  521.     ant=1;
  522.     while (mi_rnext(file,read_record3,0) == 0 &&
  523.    bcmp(read_record3+start,key,length) == 0) ant++;
  524.     if (ant != dupp_keys-1)
  525.     {
  526.       printf("next: I can only find: %d keys of %dn",ant,dupp_keys-1);
  527.       goto end;
  528.     }
  529.   }
  530.   if (dupp_keys>4)
  531.   {
  532.     if (!silent)
  533.       printf("- Read last of key - prev - delete - prev -> firstn");
  534.     DBUG_PRINT("progpos",("last - prev - delete - prev -> first"));
  535.     if (mi_rprev(file,read_record3,0)) goto err;
  536.     if (mi_rprev(file,read_record3,0)) goto err;
  537.     if (mi_delete(file,read_record3)) goto err;
  538.     opt_delete++;
  539.     ant=1;
  540.     while (mi_rprev(file,read_record3,0) == 0 &&
  541.    bcmp(read_record3+start,key,length) == 0) ant++;
  542.     if (ant != dupp_keys-2)
  543.     {
  544.       printf("next: I can only find: %d keys of %dn",ant,dupp_keys-2);
  545.       goto end;
  546.     }
  547.   }
  548.   if (dupp_keys > 6)
  549.   {
  550.     if (!silent)
  551.       printf("- Read first - delete - next -> lastn");
  552.     DBUG_PRINT("progpos",("first - delete - next -> last"));
  553.     if (mi_rkey(file,read_record3,0,key,0,HA_READ_KEY_EXACT)) goto err;
  554.     if (mi_delete(file,read_record3)) goto err;
  555.     opt_delete++;
  556.     ant=1;
  557.     if (mi_rnext(file,read_record,0))
  558.       goto err; /* Skall finnas poster */
  559.     while (mi_rnext(file,read_record3,0) == 0 &&
  560.    bcmp(read_record3+start,key,length) == 0) ant++;
  561.     if (ant != dupp_keys-3)
  562.     {
  563.       printf("next: I can only find: %d keys of %dn",ant,dupp_keys-3);
  564.       goto end;
  565.     }
  567.     if (!silent)
  568.       printf("- Read last - delete - prev -> firstn");
  569.     DBUG_PRINT("progpos",("last - delete - prev -> first"));
  570.     if (mi_rprev(file,read_record3,0)) goto err;
  571.     if (mi_delete(file,read_record3)) goto err;
  572.     opt_delete++;
  573.     ant=0;
  574.     while (mi_rprev(file,read_record3,0) == 0 &&
  575.    bcmp(read_record3+start,key,length) == 0) ant++;
  576.     if (ant != dupp_keys-4)
  577.     {
  578.       printf("next: I can only find: %d keys of %dn",ant,dupp_keys-4);
  579.       goto end;
  580.     }
  581.   }
  583.   if (!silent)
  584.     puts("- Test if: Read rrnd - same");
  585.   DBUG_PRINT("progpos",("Read rrnd - same"));
  586.   for (i=0 ; i < write_count ; i++)
  587.   {
  588.     if (mi_rrnd(file,read_record,i == 0 ? 0L : HA_OFFSET_ERROR) == 0)
  589.       break;
  590.   }
  591.   if (i == write_count)
  592.     goto err;
  594.   bmove(read_record2,read_record,reclength);
  595.   for (i=min(2,keys) ; i-- > 0 ;)
  596.   {
  597.     if (mi_rsame(file,read_record2,(int) i)) goto err;
  598.     if (bcmp(read_record,read_record2,reclength) != 0)
  599.     {
  600.       printf("is_rsame didn't find same recordn");
  601.       goto end;
  602.     }
  603.   }
  604.   if (!silent)
  605.     puts("- Test mi_records_in_range");
  606.   mi_status(file,&info,HA_STATUS_VARIABLE);
  607.   for (i=0 ; i < info.keys ; i++)
  608.   {
  609.     key_range min_key, max_key;
  610.     if (mi_rfirst(file,read_record,(int) i) ||
  611. mi_rlast(file,read_record2,(int) i))
  612.       goto err;
  613.     copy_key(file,(uint) i,(uchar*) read_record,(uchar*) key);
  614.     copy_key(file,(uint) i,(uchar*) read_record2,(uchar*) key2);
  615.     min_key.key= key;
  616.     min_key.length= USE_WHOLE_KEY;
  617.     min_key.flag= HA_READ_KEY_EXACT;
  618.     max_key.key= key2;
  619.     max_key.length= USE_WHOLE_KEY;
  620.     max_key.flag= HA_READ_AFTER_KEY;
  622.     range_records= mi_records_in_range(file,(int) i, &min_key, &max_key);
  623.     if (range_records < info.records*8/10 ||
  624. range_records > info.records*12/10)
  625.     {
  626.       printf("mi_records_range returned %ld; Should be about %ldn",
  627.      (long) range_records,(long) info.records);
  628.       goto end;
  629.     }
  630.     if (verbose)
  631.     {
  632.       printf("mi_records_range returned %ld;  Exact is %ld  (diff: %4.2g %%)n",
  633.      (long) range_records, (long) info.records,
  634.      labs((long) range_records - (long) info.records)*100.0/
  635.      info.records);
  636.     }
  637.   }
  638.   for (i=0 ; i < 5 ; i++)
  639.   {
  640.     for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
  641.     for (k=rnd(1000)+1 ; k>0 && key1[k] == 0 ; k--) ;
  642.     if (j != 0 && k != 0)
  643.     {
  644.       key_range min_key, max_key;
  645.       if (j > k)
  646. swap_variables(int, j, k);
  647.       sprintf(key,"%6d",j);
  648.       sprintf(key2,"%6d",k);
  650.       min_key.key= key;
  651.       min_key.length= USE_WHOLE_KEY;
  652.       min_key.flag= HA_READ_AFTER_KEY;
  653.       max_key.key= key2;
  654.       max_key.length= USE_WHOLE_KEY;
  655.       max_key.flag= HA_READ_BEFORE_KEY;
  656.       range_records= mi_records_in_range(file, 0, &min_key, &max_key);
  657.       records=0;
  658.       for (j++ ; j < k ; j++)
  659. records+=key1[j];
  660.       if ((long) range_records < (long) records*7/10-2 ||
  661.   (long) range_records > (long) records*14/10+2)
  662.       {
  663. printf("mi_records_range for key: %d returned %lu; Should be about %lun",
  664.        i, (ulong) range_records, (ulong) records);
  665. goto end;
  666.       }
  667.       if (verbose && records)
  668.       {
  669. printf("mi_records_range returned %lu;  Exact is %lu  (diff: %4.2g %%)n",
  670.        (ulong) range_records, (ulong) records,
  671.        labs((long) range_records-(long) records)*100.0/records);
  673.       }
  674.     }
  675.     }
  677.   if (!silent)
  678.     printf("- mi_infon");
  679.   mi_status(file,&info,HA_STATUS_VARIABLE | HA_STATUS_CONST);
  680.   if (info.records != write_count-opt_delete || info.deleted > opt_delete + update
  681.       || info.keys != keys)
  682.   {
  683.     puts("Wrong info from mi_info");
  684.     printf("Got: records: %lu  delete: %lu  i_keys: %dn",
  685.    (ulong) info.records, (ulong) info.deleted, info.keys);
  686.   }
  687.   if (verbose)
  688.   {
  689.     char buff[80];
  690.     get_date(buff,3,info.create_time);
  691.     printf("info: Created %sn",buff);
  692.     get_date(buff,3,info.check_time);
  693.     printf("info: checked %sn",buff);
  694.     get_date(buff,3,info.update_time);
  695.     printf("info: Modified %sn",buff);
  696.   }
  698.   mi_panic(HA_PANIC_WRITE);
  699.   mi_panic(HA_PANIC_READ);
  700.   if (mi_is_changed(file))
  701.     puts("Warning: mi_is_changed reported that datafile was changed");
  703.   if (!silent)
  704.     printf("- mi_extra(CACHE) + mi_rrnd.... + mi_extra(NO_CACHE)n");
  705.   if (mi_extra(file,HA_EXTRA_RESET,0) || mi_extra(file,HA_EXTRA_CACHE,0))
  706.   {
  707.     if (locking || (!use_blob && !pack_fields))
  708.     {
  709.       puts("got error from mi_extra(HA_EXTRA_CACHE)");
  710.       goto end;
  711.     }
  712.   }
  713.   ant=0;
  714.   while ((error=mi_rrnd(file,record,HA_OFFSET_ERROR)) != HA_ERR_END_OF_FILE &&
  715.  ant < write_count + 10)
  716. ant+= error ? 0 : 1;
  717.   if (ant != write_count-opt_delete)
  718.   {
  719.     printf("rrnd with cache: I can only find: %d records of %dn",
  720.    ant,write_count-opt_delete);
  721.     goto end;
  722.   }
  723.   if (mi_extra(file,HA_EXTRA_NO_CACHE,0))
  724.   {
  725.     puts("got error from mi_extra(HA_EXTRA_NO_CACHE)");
  726.     goto end;
  727.   }
  729.   ant=0;
  730.   mi_scan_init(file);
  731.   while ((error=mi_scan(file,record)) != HA_ERR_END_OF_FILE &&
  732.  ant < write_count + 10)
  733. ant+= error ? 0 : 1;
  734.   if (ant != write_count-opt_delete)
  735.   {
  736.     printf("scan with cache: I can only find: %d records of %dn",
  737.    ant,write_count-opt_delete);
  738.     goto end;
  739.   }
  741.   if (testflag == 4) goto end;
  743.   if (!silent)
  744.     printf("- Removing keysn");
  745.   DBUG_PRINT("progpos",("Removing keys"));
  746.   lastpos = HA_OFFSET_ERROR;
  747.   /* DBUG_POP(); */
  748.   mi_extra(file,HA_EXTRA_RESET,0);
  749.   found_parts=0;
  750.   while ((error=mi_rrnd(file,read_record,HA_OFFSET_ERROR)) !=
  751.  HA_ERR_END_OF_FILE)
  752.   {
  753.     info.recpos=mi_position(file);
  754.     if (lastpos >= info.recpos && lastpos != HA_OFFSET_ERROR)
  755.     {
  756.       printf("mi_rrnd didn't advance filepointer; old: %ld, new: %ldn",
  757.      (long) lastpos, (long) info.recpos);
  758.       goto err;
  759.     }
  760.     lastpos=info.recpos;
  761.     if (error == 0)
  762.     {
  763.       if (opt_delete == (uint) remove_count) /* While testing */
  764. goto end;
  765.       if (mi_rsame(file,read_record,-1))
  766.       {
  767. printf("can't find record %lxn",(long) info.recpos);
  768. goto err;
  769.       }
  770.       if (use_blob)
  771.       {
  772. ulong blob_length,pos;
  773. uchar *ptr;
  774. longget(blob_length,read_record+blob_pos+4);
  775. ptr=(uchar*) blob_length;
  776. longget(blob_length,read_record+blob_pos);
  777. for (pos=0 ; pos < blob_length ; pos++)
  778. {
  779.   if (ptr[pos] != (uchar) (blob_length+pos))
  780.   {
  781.     printf("found blob with wrong info at %ldn",(long) lastpos);
  782.     use_blob=0;
  783.     break;
  784.   }
  785. }
  786.       }
  787.       if (mi_delete(file,read_record))
  788.       {
  789. printf("can't delete record: %6.6s,  delete_count: %dn",
  790.        read_record, opt_delete);
  791. goto err;
  792.       }
  793.       opt_delete++;
  794.     }
  795.     else
  796.       found_parts++;
  797.   }
  798.   if (my_errno != HA_ERR_END_OF_FILE && my_errno != HA_ERR_RECORD_DELETED)
  799.     printf("error: %d from mi_rrndn",my_errno);
  800.   if (write_count != opt_delete)
  801.   {
  802.     printf("Deleted only %d of %d records (%d parts)n",opt_delete,write_count,
  803.    found_parts);
  804.     goto err;
  805.   }
  806. end:
  807.   if (mi_close(file))
  808.     goto err;
  809.   mi_panic(HA_PANIC_CLOSE); /* Should close log */
  810.   if (!silent)
  811.   {
  812.     printf("nFollowing test have been made:n");
  813.     printf("Write records: %dnUpdate records: %dnSame-key-read: %dnDelete records: %dn", write_count,update,dupp_keys,opt_delete);
  814.     if (rec_pointer_size)
  815.       printf("Record pointer size:  %dn",rec_pointer_size);
  816.     printf("myisam_block_size:    %un", myisam_block_size);
  817.     if (key_cacheing)
  818.     {
  819.       puts("Key cache used");
  820.       printf("key_cache_block_size: %un", key_cache_block_size);
  821.       if (write_cacheing)
  822. puts("Key cache resized");
  823.     }
  824.     if (write_cacheing)
  825.       puts("Write cacheing used");
  826.     if (write_cacheing)
  827.       puts("quick mode");
  828.     if (async_io && locking)
  829.       puts("Asyncron io with locking used");
  830.     else if (locking)
  831.       puts("Locking used");
  832.     if (use_blob)
  833.       puts("blobs used");
  834.     printf("key cache status: n
  835. blocks used:%10lun
  836. not flushed:%10lun
  837. w_requests: %10lun
  838. writes:     %10lun
  839. r_requests: %10lun
  840. reads:      %10lun",
  841.            dflt_key_cache->blocks_used,
  842.            dflt_key_cache->global_blocks_changed,
  843.            (ulong) dflt_key_cache->global_cache_w_requests,
  844.            (ulong) dflt_key_cache->global_cache_write,
  845.            (ulong) dflt_key_cache->global_cache_r_requests,
  846.            (ulong) dflt_key_cache->global_cache_read);
  847.   }
  848.   end_key_cache(dflt_key_cache,1);
  849.   if (blob_buffer)
  850.     my_free(blob_buffer,MYF(0));
  851.   my_end(silent ? MY_CHECK_ERROR : MY_CHECK_ERROR | MY_GIVE_INFO);
  852.   return(0);
  853. err:
  854.   printf("got error: %d when using MyISAM-databasen",my_errno);
  855.   if (file)
  856.     VOID(mi_close(file));
  857.   return(1);
  858. } /* main */
  861. /* l{ser optioner */
  862. /* OBS! intierar endast DEBUG - ingen debuggning h{r ! */
  864. static void get_options(int argc, char **argv)
  865. {
  866.   char *pos,*progname;
  867.   DEBUGGER_OFF;
  869.   progname= argv[0];
  871.   while (--argc >0 && *(pos = *(++argv)) == '-' ) {
  872.     switch(*++pos) {
  873.     case 'B':
  874.       pack_type= HA_BINARY_PACK_KEY;
  875.       break;
  876.     case 'b':
  877.       use_blob=1;
  878.       break;
  879.     case 'K': /* Use key cacheing */
  880.       key_cacheing=1;
  881.       if (*++pos)
  882. key_cache_size=atol(pos);
  883.       break;
  884.     case 'W': /* Use write cacheing */
  885.       write_cacheing=1;
  886.       if (*++pos)
  887. my_default_record_cache_size=atoi(pos);
  888.       break;
  889.     case 'd':
  890.       remove_count= atoi(++pos);
  891.       break;
  892.     case 'i':
  893.       if (*++pos)
  894. srand(atoi(pos));
  895.       break;
  896.     case 'l':
  897.       use_log=1;
  898.       break;
  899.     case 'L':
  900.       locking=1;
  901.       break;
  902.     case 'A': /* use asyncron io */
  903.       async_io=1;
  904.       if (*++pos)
  905. my_default_record_cache_size=atoi(pos);
  906.       break;
  907.     case 'v': /* verbose */
  908.       verbose=1;
  909.       break;
  910.     case 'm': /* records */
  911.       if ((recant=atoi(++pos)) < 10)
  912.       {
  913. fprintf(stderr,"record count must be >= 10n");
  914. exit(1);
  915.       }
  916.       break;
  917.     case 'e': /* myisam_block_length */
  918.       if ((myisam_block_size=atoi(++pos)) < MI_MIN_KEY_BLOCK_LENGTH ||
  919.   myisam_block_size > MI_MAX_KEY_BLOCK_LENGTH)
  920.       {
  921. fprintf(stderr,"Wrong myisam_block_lengthn");
  922. exit(1);
  923.       }
  924.       myisam_block_size=1 << my_bit_log2(myisam_block_size);
  925.       break;
  926.     case 'E': /* myisam_block_length */
  927.       if ((key_cache_block_size=atoi(++pos)) < MI_MIN_KEY_BLOCK_LENGTH ||
  928.   key_cache_block_size > MI_MAX_KEY_BLOCK_LENGTH)
  929.       {
  930. fprintf(stderr,"Wrong key_cache_block_sizen");
  931. exit(1);
  932.       }
  933.       key_cache_block_size=1 << my_bit_log2(key_cache_block_size);
  934.       break;
  935.     case 'f':
  936.       if ((first_key=atoi(++pos)) < 0 || first_key >= MYISAM_KEYS)
  937. first_key=0;
  938.       break;
  939.     case 'k':
  940.       if ((keys=(uint) atoi(++pos)) < 1 ||
  941.    keys > (uint) (MYISAM_KEYS-first_key))
  942. keys=MYISAM_KEYS-first_key;
  943.       break;
  944.     case 'P':
  945.       pack_type=0; /* Don't use DIFF_LENGTH */
  946.       pack_seg=0;
  947.       break;
  948.     case 'R': /* Length of record pointer */
  949.       rec_pointer_size=atoi(++pos);
  950.       if (rec_pointer_size > 7)
  951. rec_pointer_size=0;
  952.       break;
  953.     case 'S':
  954.       pack_fields=0; /* Static-length-records */
  955.       break;
  956.     case 's':
  957.       silent=1;
  958.       break;
  959.     case 't':
  960.       testflag=atoi(++pos); /* testmod */
  961.       break;
  962.     case 'q':
  963.       opt_quick_mode=1;
  964.       break;
  965.     case 'c':
  966.       create_flag|= HA_CREATE_CHECKSUM;
  967.       break;
  968.     case 'D':
  969.       create_flag|=HA_CREATE_DELAY_KEY_WRITE;
  970.       break;
  971.     case '?':
  972.     case 'I':
  973.     case 'V':
  974.       printf("%s  Ver 1.2 for %s at %sn",progname,SYSTEM_TYPE,MACHINE_TYPE);
  975.       puts("By Monty, for your professional usen");
  976.       printf("Usage: %s [-?AbBcDIKLPRqSsVWltv] [-k#] [-f#] [-m#] [-e#] [-E#] [-t#]n",
  977.      progname);
  978.       exit(0);
  979.     case '#':
  980.       DEBUGGER_ON;
  981.       DBUG_PUSH (++pos);
  982.       break;
  983.     default:
  984.       printf("Illegal option: '%c'n",*pos);
  985.       break;
  986.     }
  987.   }
  988.   return;
  989. } /* get options */
  991. /* Get a random value 0 <= x <= n */
  993. static uint rnd(uint max_value)
  994. {
  995.   return (uint) ((rand() & 32767)/32767.0*max_value);
  996. } /* rnd */
  999. /* Create a variable length record */
  1001. static void fix_length(byte *rec, uint length)
  1002. {
  1003.   bmove(rec+STANDARD_LENGTH,
  1004. "0123456789012345678901234567890123456789012345678901234567890",
  1005. length-STANDARD_LENGTH);
  1006.   strfill(rec+length,STANDARD_LENGTH+60-length,' ');
  1007. } /* fix_length */
  1010. /* Put maybe a blob in record */
  1012. static void put_blob_in_record(char *blob_pos, char **blob_buffer)
  1013. {
  1014.   ulong i,length;
  1015.   if (use_blob)
  1016.   {
  1017.     if (rnd(10) == 0)
  1018.     {
  1019.       if (! *blob_buffer &&
  1020.   !(*blob_buffer=my_malloc((uint) use_blob,MYF(MY_WME))))
  1021.       {
  1022. use_blob=0;
  1023. return;
  1024.       }
  1025.       length=rnd(use_blob);
  1026.       for (i=0 ; i < length ; i++)
  1027. (*blob_buffer)[i]=(char) (length+i);
  1028.       int4store(blob_pos,length);
  1029.       memcpy_fixed(blob_pos+4,(char*) blob_buffer,sizeof(char*));
  1030.     }
  1031.     else
  1032.     {
  1033.       int4store(blob_pos,0);
  1034.     }
  1035.   }
  1036.   return;
  1037. }
  1040. static void copy_key(MI_INFO *info,uint inx,uchar *rec,uchar *key_buff)
  1041. {
  1042.   HA_KEYSEG *keyseg;
  1044.   for (keyseg=info->s->keyinfo[inx].seg ; keyseg->type ; keyseg++)
  1045.   {
  1046.     memcpy(key_buff,rec+keyseg->start,(size_t) keyseg->length);
  1047.     key_buff+=keyseg->length;
  1048.   }
  1049.   return;
  1050. }