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

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

MySQL数据库

开发平台：

Visual C++

hp_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
  29. #include "heapdef.h" /* Because of _hp_find_block */
  30. #include <signal.h>
  32. #define MAX_RECORDS 100000
  33. #define MAX_KEYS 3
  35. static int get_options(int argc, char *argv[]);
  36. static int rnd(int max_value);
  37. static sig_handler endprog(int sig_number);
  39. static uint flag=0,verbose=0,testflag=0,recant=10000,silent=0;
  40. static uint keys=MAX_KEYS;
  41. static uint16 key1[1001];
  42. static my_bool key3[MAX_RECORDS];
  44. static int calc_check(byte *buf,uint length);
  46. /* Huvudprogrammet */
  48. int main(argc,argv)
  49. int argc;
  50. char *argv[];
  51. {
  52.   register uint i,j;
  53.   uint ant,n1,n2,n3;
  54.   uint reclength,write_count,update,delete,check2,dupp_keys,found_key;
  55.   int error;
  56.   ulong pos;
  57.   unsigned long key_check;
  58.   char record[128],record2[128],record3[128],key[10];
  59.   const char *filename,*filename2;
  60.   HP_INFO *file,*file2;
  61.   HP_KEYDEF keyinfo[MAX_KEYS];
  62.   HP_KEYSEG keyseg[MAX_KEYS*5];
  63.   HEAP_PTR position;
  64.   MY_INIT(argv[0]); /* init my_sys library & pthreads */
  65.   LINT_INIT(position);
  67.   filename= "test2";
  68.   filename2= "test2_2";
  69.   file=file2=0;
  70.   get_options(argc,argv);
  71.   reclength=37;
  73.   write_count=update=delete=0;
  74.   key_check=0;
  76.   keyinfo[0].seg=keyseg;
  77.   keyinfo[0].keysegs=1;
  78.   keyinfo[0].flag= 0;
  79.   keyinfo[0].seg[0].type=HA_KEYTYPE_BINARY;
  80.   keyinfo[0].seg[0].start=0;
  81.   keyinfo[0].seg[0].length=6;
  82.   keyinfo[1].seg=keyseg+1;
  83.   keyinfo[1].keysegs=2;
  84.   keyinfo[1].flag=0;
  85.   keyinfo[1].seg[0].type=HA_KEYTYPE_BINARY;
  86.   keyinfo[1].seg[0].start=7;
  87.   keyinfo[1].seg[0].length=6;
  88.   keyinfo[1].seg[1].type=HA_KEYTYPE_TEXT;
  89.   keyinfo[1].seg[1].start=0; /* Tv}delad nyckel */
  90.   keyinfo[1].seg[1].length=6;
  91.   keyinfo[2].seg=keyseg+3;
  92.   keyinfo[2].keysegs=1;
  93.   keyinfo[2].flag=HA_NOSAME;
  94.   keyinfo[2].seg[0].type=HA_KEYTYPE_BINARY;
  95.   keyinfo[2].seg[0].start=12;
  96.   keyinfo[2].seg[0].length=8;
  98.   bzero((char*) key1,sizeof(key1));
  99.   bzero((char*) key3,sizeof(key3));
  101.   printf("- Creating heap-filen");
  102.   if (heap_create(filename))
  103.     goto err;
  104.   if (!(file=heap_open(filename,2,keys,keyinfo,reclength,(ulong) flag*100000L,
  105.        (ulong) recant/2)))
  106.     goto err;
  107.   signal(SIGINT,endprog);
  109.   printf("- Writing records:sn");
  110.   strmov(record,"          ..... key");
  112.   for (i=0 ; i < recant ; i++)
  113.   {
  114.     n1=rnd(1000); n2=rnd(100); n3=rnd(min(recant*5,MAX_RECORDS));
  115.     sprintf(record,"%6d:%4d:%8d:Pos: %4d          ",n1,n2,n3,write_count);
  117.     if (heap_write(file,record))
  118.     {
  119.       if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
  120.       {
  121. printf("Error: %d in write at record: %dn",my_errno,i);
  122. goto err;
  123.       }
  124.       if (verbose) printf("   Double key: %dn",n3);
  125.     }
  126.     else
  127.     {
  128.       if (key3[n3] == 1)
  129.       {
  130. printf("Error: Didn't get error when writing second key: '%8d'n",n3);
  131. goto err;
  132.       }
  133.       write_count++; key1[n1]++; key3[n3]=1;
  134.       key_check+=n1;
  135.     }
  136.     if (testflag == 1 && heap_check_heap(file,0))
  137.     {
  138.       puts("Heap keys crashed");
  139.       goto err;
  140.     }
  141.   }
  142.   if (testflag == 1)
  143.     goto end;
  144.   if (heap_check_heap(file,0))
  145.   {
  146.     puts("Heap keys crashed");
  147.     goto err;
  148.   }
  150.   printf("- Deleten");
  151.   for (i=0 ; i < write_count/10 ; i++)
  152.   {
  153.     for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
  154.     if (j != 0)
  155.     {
  156.       sprintf(key,"%6d",j);
  157.       if (heap_rkey(file,record,0,key))
  158.       {
  159. printf("can't find key1: "%s"n",key);
  160. goto err;
  161.       }
  162. #ifdef NOT_USED
  163.       if (file->current_ptr == _hp_find_block(&file->s->block,0) ||
  164.   file->current_ptr == _hp_find_block(&file->s->block,1))
  165. continue; /* Don't remove 2 first records */
  166. #endif
  167.       if (heap_delete(file,record))
  168.       {
  169. printf("error: %d; can't delete record: "%s"n", my_errno,record);
  170. goto err;
  171.       }
  172.       delete++;
  173.       key1[atoi(record+keyinfo[0].seg[0].start)]--;
  174.       key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  175.       key_check-=atoi(record);
  176.       if (testflag == 2 && heap_check_heap(file,0))
  177.       {
  178. puts("Heap keys crashed");
  179. goto err;
  180.       }
  181.     }
  182.     else
  183.       puts("Warning: Skipping delete test because no dupplicate keys");
  184.   }
  185.   if (testflag==2) goto end;
  186.   if (heap_check_heap(file,0))
  187.   {
  188.     puts("Heap keys crashed");
  189.     goto err;
  190.   }
  192.   printf("- Updaten");
  193.   for (i=0 ; i < write_count/10 ; i++)
  194.   {
  195.     n1=rnd(1000); n2=rnd(100); n3=rnd(min(recant*2,MAX_RECORDS));
  196.     sprintf(record2,"%6d:%4d:%8d:XXX: %4d          ",n1,n2,n3,update);
  197.     if (rnd(2) == 1)
  198.     {
  199.       if (heap_scan_init(file))
  200. goto err;
  201.       j=rnd(write_count-delete);
  202.       while ((error=heap_scan(file,record) == HA_ERR_RECORD_DELETED) ||
  203.      (!error && j))
  204.       {
  205. if (!error)
  206.   j--;
  207.       }
  208.       if (error)
  209. goto err;
  210.     }
  211.     else
  212.     {
  213.       for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
  214.       if (!key1[j])
  215. continue;
  216.       sprintf(key,"%6d",j);
  217.       if (heap_rkey(file,record,0,key))
  218.       {
  219. printf("can't find key1: "%s"n",key);
  220. goto err;
  221.       }
  222.     }
  223.     if (heap_update(file,record,record2))
  224.     {
  225.       if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
  226.       {
  227. printf("error: %d; can't uppdate:nFrom: "%s"nTo:   "%s"n",
  228.        my_errno,record,record2);
  229. goto err;
  230.       }
  231.       if (verbose)
  232. printf("Double key when tryed to uppdate:nFrom: "%s"nTo:   "%s"n",record,record2);
  233.     }
  234.     else
  235.     {
  236.       key1[atoi(record+keyinfo[0].seg[0].start)]--;
  237.       key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  238.       key1[n1]++; key3[n3]=1;
  239.       update++;
  240.       key_check=key_check-atoi(record)+n1;
  241.     }
  242.     if (testflag == 3 && heap_check_heap(file,0))
  243.     {
  244.       puts("Heap keys crashed");
  245.       goto err;
  246.     }
  247.   }
  248.   if (testflag == 3) goto end;
  249.   if (heap_check_heap(file,0))
  250.   {
  251.     puts("Heap keys crashed");
  252.     goto err;
  253.   }
  255.   for (i=999, dupp_keys=found_key=0 ; i>0 ; i--)
  256.   {
  257.     if (key1[i] > dupp_keys) { dupp_keys=key1[i]; found_key=i; }
  258.     sprintf(key,"%6d",found_key);
  259.   }
  261.   if (dupp_keys > 3)
  262.   {
  263.     if (!silent)
  264.       printf("- Read first key - next - delete - next -> lastn");
  265.     DBUG_PRINT("progpos",("first - next - delete - next -> last"));
  267.     if (heap_rkey(file,record,0,key))
  268.       goto err;
  269.     if (heap_rnext(file,record3)) goto err;
  270.     if (heap_delete(file,record3)) goto err;
  271.     key_check-=atoi(record3);
  272.     key1[atoi(record+keyinfo[0].seg[0].start)]--;
  273.     key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  274.     delete++;
  275.     ant=2;
  276.     while ((error=heap_rnext(file,record3)) == 0 ||
  277.    error == HA_ERR_RECORD_DELETED)
  278.       if (! error)
  279. ant++;
  280.     if (ant != dupp_keys)
  281.     {
  282.       printf("next: I can only find: %d records of %dn",
  283.      ant,dupp_keys);
  284.       goto end;
  285.     }
  286.     dupp_keys--;
  287.     if (heap_check_heap(file,0))
  288.     {
  289.       puts("Heap keys crashed");
  290.       goto err;
  291.     }
  293.     if (!silent)
  294.       printf("- Read last key - delete - prev - prev - delete - prev -> firstn");
  296.     if (heap_rlast(file,record3)) goto err;
  297.     if (heap_delete(file,record3)) goto err;
  298.     key_check-=atoi(record3);
  299.     key1[atoi(record+keyinfo[0].seg[0].start)]--;
  300.     key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  301.     delete++;
  302.     if (heap_rprev(file,record3) || heap_rprev(file,record3))
  303.       goto err;
  304.     if (heap_delete(file,record3)) goto err;
  305.     key_check-=atoi(record3);
  306.     key1[atoi(record+keyinfo[0].seg[0].start)]--;
  307.     key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  308.     delete++;
  309.     ant=3;
  310.     while ((error=heap_rprev(file,record3)) == 0 ||
  311.    error == HA_ERR_RECORD_DELETED)
  312.     {
  313.       if (! error)
  314. ant++;
  315.     }
  316.     if (ant != dupp_keys)
  317.     {
  318.       printf("next: I can only find: %d records of %dn",
  319.      ant,dupp_keys);
  320.       goto end;
  321.     }
  322.     dupp_keys-=2;
  323.     if (heap_check_heap(file,0))
  324.     {
  325.       puts("Heap keys crashed");
  326.       goto err;
  327.     }
  328.   }
  329.   else
  330.     puts("Warning: Not enough duplicated keys:  Skipping delete key check");
  332.   if (!silent)
  333.     printf("- Read (first) - next - delete - next -> lastn");
  334.   DBUG_PRINT("progpos",("first - next - delete - next -> last"));
  336.   if (heap_scan_init(file))
  337.     goto err;
  338.   while ((error=heap_scan(file,record3) == HA_ERR_RECORD_DELETED)) ;
  339.   if (error)
  340.     goto err;
  341.   if (heap_delete(file,record3)) goto err;
  342.   key_check-=atoi(record3);
  343.   delete++;
  344.   key1[atoi(record+keyinfo[0].seg[0].start)]--;
  345.   key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  346.   ant=0;
  347.   while ((error=heap_scan(file,record3)) == 0 ||
  348.  error == HA_ERR_RECORD_DELETED)
  349.     if (! error)
  350.       ant++;
  351.   if (ant != write_count-delete)
  352.   {
  353.     printf("next: Found: %d records of %dn",ant,write_count-delete);
  354.     goto end;
  355.   }
  356.   if (heap_check_heap(file,0))
  357.   {
  358.     puts("Heap keys crashed");
  359.     goto err;
  360.   }
  362.   puts("- Test if: Read rrnd - same - rkey - same");
  363.   DBUG_PRINT("progpos",("Read rrnd - same"));
  364.   pos=rnd(write_count-delete-5)+5;
  365.   heap_scan_init(file);
  366.   i=5;
  367.   while ((error=heap_scan(file,record)) == HA_ERR_RECORD_DELETED ||
  368.  (error == 0 && pos))
  369.   {
  370.     if (!error)
  371.       pos--;
  372.     if (i-- == 0)
  373.     {
  374.       bmove(record3,record,reclength);
  375.       position=heap_position(file);
  376.     }
  377.   }
  378.   if (error)
  379.     goto err;
  380.   bmove(record2,record,reclength);
  381.   if (heap_rsame(file,record,-1) || heap_rsame(file,record2,2))
  382.     goto err;
  383.   if (bcmp(record2,record,reclength))
  384.   {
  385.     puts("heap_rsame didn't find right record");
  386.     goto end;
  387.   }
  389.   puts("- Test of read through position");
  390.   if (heap_rrnd(file,record,position))
  391.     goto err;
  392.   if (bcmp(record3,record,reclength))
  393.   {
  394.     puts("heap_frnd didn't find right record");
  395.     goto end;
  396.   }
  398.   printf("- heap_infon");
  399.   {
  400.     HEAPINFO info;
  401.     heap_info(file,&info,0);
  402.     /* We have to test with delete +1 as this may be the case if the last
  403.        inserted row was a duplicate key */
  404.     if (info.records != write_count-delete ||
  405. (info.deleted != delete && info.deleted != delete+1))
  406.     {
  407.       puts("Wrong info from heap_info");
  408.       printf("Got: records: %ld(%d)  deleted: %ld(%d)n",
  409.      info.records,write_count-delete,info.deleted,delete);
  410.     }
  411.   }
  413. #ifdef OLD_HEAP_VERSION
  414.   {
  415.     uint check;
  416.     printf("- Read through all records with rndn");
  417.     if (heap_extra(file,HA_EXTRA_RESET) || heap_extra(file,HA_EXTRA_CACHE))
  418.     {
  419.       puts("got error from heap_extra");
  420.       goto end;
  421.     }
  422.     ant=check=0;
  423.     while ((error=heap_rrnd(file,record,(ulong) -1)) != HA_ERR_END_OF_FILE &&
  424.    ant < write_count + 10)
  425.     {
  426.       if (!error)
  427.       {
  428. ant++;
  429. check+=calc_check(record,reclength);
  430.       }
  431.     }
  432.     if (ant != write_count-delete)
  433.     {
  434.       printf("rrnd: I can only find: %d records of %dn", ant,
  435.      write_count-delete);
  436.       goto end;
  437.     }
  438.     if (heap_extra(file,HA_EXTRA_NO_CACHE))
  439.     {
  440.       puts("got error from heap_extra(HA_EXTRA_NO_CACHE)");
  441.       goto end;
  442.     }
  443.   }
  444. #endif
  446.   printf("- Read through all records with scann");
  447.   if (heap_extra(file,HA_EXTRA_RESET) || heap_extra(file,HA_EXTRA_CACHE))
  448.   {
  449.     puts("got error from heap_extra");
  450.     goto end;
  451.   }
  452.   ant=check2=0;
  453.   heap_scan_init(file);
  454.   while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE &&
  455.  ant < write_count + 10)
  456.   {
  457.     if (!error)
  458.     {
  459.       ant++;
  460.       check2+=calc_check(record,reclength);
  461.     }
  462.   }
  463.   if (ant != write_count-delete)
  464.   {
  465.     printf("scan: I can only find: %d records of %dn", ant,
  466.    write_count-delete);
  467.     goto end;
  468.   }
  469. #ifdef OLD_HEAP_VERSION
  470.   if (check != check2)
  471.   {
  472.     puts("scan: Checksum didn't match reading with rrnd");
  473.     goto end;
  474.   }
  475. #endif
  478.   if (heap_extra(file,HA_EXTRA_NO_CACHE))
  479.   {
  480.     puts("got error from heap_extra(HA_EXTRA_NO_CACHE)");
  481.     goto end;
  482.   }
  484.   for (i=999, dupp_keys=found_key=0 ; i>0 ; i--)
  485.   {
  486.     if (key1[i] > dupp_keys) { dupp_keys=key1[i]; found_key=i; }
  487.     sprintf(key,"%6d",found_key);
  488.   }
  489.   printf("- Read through all keys with first-next-last-prevn");
  490.   ant=0;
  491.   for (error=heap_rkey(file,record,0,key) ;
  492.       ! error ;
  493.        error=heap_rnext(file,record))
  494.     ant++;
  495.   if (ant != dupp_keys)
  496.   {
  497.     printf("first-next: I can only find: %d records of %dn", ant,
  498.    dupp_keys);
  499.     goto end;
  500.   }
  502.   ant=0;
  503.   for (error=heap_rlast(file,record) ;
  504.       ! error ;
  505.       error=heap_rprev(file,record))
  506.   {
  507.     ant++;
  508.     check2+=calc_check(record,reclength);
  509.   }
  510.   if (ant != dupp_keys)
  511.   {
  512.     printf("last-prev: I can only find: %d records of %dn", ant,
  513.    dupp_keys);
  514.     goto end;
  515.   }
  517.   if (testflag == 4) goto end;
  519.   printf("- Reading through all rows through keysn");
  520.   if (!(file2=heap_open(filename,2,0,0,0,0,0)))
  521.     goto err;
  522.   if (heap_scan_init(file))
  523.     goto err;
  524.   while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE)
  525.   {
  526.     if (error == 0)
  527.     {
  528.       if (heap_rkey(file2,record2,2,record+keyinfo[2].seg[0].start))
  529.       {
  530. printf("can't find key3: "%.8s"n",
  531.        record+keyinfo[2].seg[0].start);
  532. goto err;
  533.       }
  534.     }
  535.   }
  536.   heap_close(file2);
  538.   printf("- Creating output heap-file 2n");
  539.   if (!(file2=heap_open(filename2,2,1,keyinfo,reclength,0L,0L)))
  540.     goto err;
  542.   printf("- Copying and removing recordsn");
  543.   if (heap_scan_init(file))
  544.     goto err;
  545.   while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE)
  546.   {
  547.     if (error == 0)
  548.     {
  549.       if (heap_write(file2,record))
  550. goto err;
  551.       key_check-=atoi(record);
  552.       write_count++;
  553.       if (heap_delete(file,record))
  554. goto err;
  555.       delete++;
  556.     }
  557.     pos++;
  558.   }
  559.   printf("- Checking heap tablesn");
  560.   if (heap_check_heap(file,1) || heap_check_heap(file2,1))
  561.   {
  562.     puts("Heap keys crashed");
  563.     goto err;
  564.   }
  566.   if (my_errno != HA_ERR_END_OF_FILE)
  567.     printf("error: %d from heap_rrndn",my_errno);
  568.   if (key_check)
  569.     printf("error: Some read got wrong: check is %ldn",(long) key_check);
  571. end:
  572.   printf("nFollowing test have been made:n");
  573.   printf("Write records: %dnUpdate records: %dnDelete records: %dn", write_count,update,delete);
  574.   heap_clear(file);
  575.   if (heap_close(file) || (file2 && heap_close(file2)))
  576.     goto err;
  577.   heap_delete_all(filename2);
  578.   heap_panic(HA_PANIC_CLOSE);
  579.   my_end(MY_GIVE_INFO);
  580.   return(0);
  581. err:
  582.   printf("Got error: %d when using heap-databasen",my_errno);
  583.   VOID(heap_close(file));
  584.   return(1);
  585. } /* main */
  588. /* Read options */
  590. static int get_options(int argc,char *argv[])
  591. {
  592.   char *pos,*progname;
  593.   DEBUGGER_OFF;
  595.   progname= argv[0];
  597.   while (--argc >0 && *(pos = *(++argv)) == '-' ) {
  598.     switch(*++pos) {
  599.     case 'B': /* Big file */
  600.       flag=1;
  601.       break;
  602.     case 'v': /* verbose */
  603.       verbose=1;
  604.       break;
  605.     case 'm': /* records */
  606.       recant=atoi(++pos);
  607.       break;
  608.     case 's':
  609.       silent=1;
  610.       break;
  611.     case 't':
  612.       testflag=atoi(++pos); /* testmod */
  613.       break;
  614.     case 'V':
  615.     case 'I':
  616.     case '?':
  617.       printf("%s  Ver 1.1 for %s at %sn",progname,SYSTEM_TYPE,MACHINE_TYPE);
  618.       puts("TCX Datakonsult AB, by Monty, for your professional usen");
  619.       printf("Usage: %s [-?ABIKLsWv] [-m#] [-t#]n",progname);
  620.       exit(0);
  621.     case '#':
  622.       DEBUGGER_ON;
  623.       DBUG_PUSH (++pos);
  624.       break;
  625.     }
  626.   }
  627.   return 0;
  628. } /* get options */
  630. /* Generate a random value in intervall 0 <=x <= n */
  632. static int rnd(max_value)
  633. int max_value;
  634. {
  635.   return (int) ((rand() & 32767)/32767.0*max_value);
  636. } /* rnd */
  639. static sig_handler endprog(int sig_number __attribute__((unused)))
  640. {
  641. #ifndef THREAD
  642.   if (my_dont_interrupt)
  643.     my_remember_signal(sig_number,endprog);
  644.   else
  645. #endif
  646.   {
  647.     heap_panic(HA_PANIC_CLOSE);
  648.     my_end(1);
  649.     exit(1);
  650.   }
  651. }
  653. static int calc_check(buf,length)
  654. byte *buf;
  655. uint length;
  656. {
  657.   int check=0;
  658.   while (length--)
  659.     check+= (int) (uchar) *(buf++);
  660.   return check;
  661. }