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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mi_test2.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：27k
源码类别：

MySQL数据库

开发平台：

Visual C++

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