rt_test.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:11k
源码类别:

MySQL数据库

开发平台:

Visual 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 */
  16. /* Testing of the basic functions of a MyISAM rtree table         */
  17. /* Written by Alex Barkov who has a shared copyright to this code */
  18. #include "myisam.h"
  19. #ifdef HAVE_RTREE_KEYS
  20. #include "rt_index.h"
  21. #define MAX_REC_LENGTH 1024
  22. #define ndims 2
  23. #define KEYALG HA_KEY_ALG_RTREE
  24. static int read_with_pos(MI_INFO * file, int silent);
  25. static void create_record(char *record,uint rownr);
  26. static void create_record1(char *record,uint rownr);
  27. static void print_record(char * record,my_off_t offs,const char * tail);
  28. static  int run_test(const char *filename);
  29. static double rt_data[]=
  30. {
  31.   /*1*/  0,10,0,10,
  32.   /*2*/  5,15,0,10,
  33.   /*3*/  0,10,5,15,
  34.   /*4*/  10,20,10,20,
  35.   /*5*/  0,10,0,10,
  36.   /*6*/  5,15,0,10,
  37.   /*7*/  0,10,5,15,
  38.   /*8*/  10,20,10,20,
  39.   /*9*/  0,10,0,10,
  40.   /*10*/  5,15,0,10,
  41.   /*11*/  0,10,5,15,
  42.   /*12*/  10,20,10,20,
  43.   /*13*/  0,10,0,10,
  44.   /*14*/  5,15,0,10,
  45.   /*15*/  0,10,5,15,
  46.   /*16*/  10,20,10,20,
  47.   /*17*/  5,15,0,10,
  48.   /*18*/  0,10,5,15,
  49.   /*19*/  10,20,10,20,
  50.   /*20*/  0,10,0,10,
  51.   /*1*/  100,110,0,10,
  52.   /*2*/  105,115,0,10,
  53.   /*3*/  100,110,5,15,
  54.   /*4*/  110,120,10,20,
  55.   /*5*/  100,110,0,10,
  56.   /*6*/  105,115,0,10,
  57.   /*7*/  100,110,5,15,
  58.   /*8*/  110,120,10,20,
  59.   /*9*/  100,110,0,10,
  60.   /*10*/  105,115,0,10,
  61.   /*11*/  100,110,5,15,
  62.   /*12*/  110,120,10,20,
  63.   /*13*/  100,110,0,10,
  64.   /*14*/  105,115,0,10,
  65.   /*15*/  100,110,5,15,
  66.   /*16*/  110,120,10,20,
  67.   /*17*/  105,115,0,10,
  68.   /*18*/  100,110,5,15,
  69.   /*19*/  110,120,10,20,
  70.   /*20*/  100,110,0,10,
  71.   -1
  72. };
  73. int main(int argc __attribute__((unused)),char *argv[] __attribute__((unused)))
  74. {
  75.   MY_INIT(argv[0]);
  76.   exit(run_test("rt_test"));
  77. }
  78. static int run_test(const char *filename)
  79. {
  80.   MI_INFO        *file;
  81.   MI_UNIQUEDEF   uniquedef;
  82.   MI_CREATE_INFO create_info;
  83.   MI_COLUMNDEF   recinfo[20];
  84.   MI_KEYDEF      keyinfo[20];
  85.   HA_KEYSEG      keyseg[20];
  86.   key_range range;
  87.   int silent=0;
  88.   int opt_unique=0;
  89.   int create_flag=0;
  90.   int key_type=HA_KEYTYPE_DOUBLE;
  91.   int key_length=8;
  92.   int null_fields=0;
  93.   int nrecords=sizeof(rt_data)/(sizeof(double)*4);/* 3000;*/
  94.   int rec_length=0;
  95.   int uniques=0;
  96.   int i;
  97.   int error;
  98.   int row_count=0;
  99.   char record[MAX_REC_LENGTH];
  100.   char read_record[MAX_REC_LENGTH];
  101.   int upd= 10;
  102.   ha_rows hrows;
  103.   
  104.   /* Define a column for NULLs and DEL markers*/
  105.   
  106.   recinfo[0].type=FIELD_NORMAL;
  107.   recinfo[0].length=1; /* For NULL bits */
  108.   rec_length=1;
  109.   
  110.   /* Define 2*ndims columns for coordinates*/
  111.   
  112.   for (i=1; i<=2*ndims ;i++){
  113.     recinfo[i].type=FIELD_NORMAL;
  114.     recinfo[i].length=key_length;
  115.     rec_length+=key_length;
  116.   }
  117.   
  118.   /* Define a key with 2*ndims segments */
  119.   
  120.   keyinfo[0].seg=keyseg;
  121.   keyinfo[0].keysegs=2*ndims;
  122.   keyinfo[0].flag=0;
  123.   keyinfo[0].key_alg=KEYALG;
  124.   
  125.   for (i=0; i<2*ndims; i++){
  126.     keyinfo[0].seg[i].type= key_type;
  127.     keyinfo[0].seg[i].flag=0;          /* Things like HA_REVERSE_SORT */
  128.     keyinfo[0].seg[i].start= (key_length*i)+1;
  129.     keyinfo[0].seg[i].length=key_length;
  130.     keyinfo[0].seg[i].null_bit= null_fields ? 2 : 0;
  131.     keyinfo[0].seg[i].null_pos=0;
  132.     keyinfo[0].seg[i].language=default_charset_info->number;
  133.   }
  134.   
  135.   if (!silent)
  136.     printf("- Creating isam-filen");
  137.   
  138.   bzero((char*) &create_info,sizeof(create_info));
  139.   create_info.max_rows=10000000;
  140.   
  141.   if (mi_create(filename,
  142.                 1,            /*  keys   */
  143.                 keyinfo,
  144.                 1+2*ndims+opt_unique, /* columns */
  145.                 recinfo,uniques,&uniquedef,&create_info,create_flag))
  146.     goto err;
  147.   
  148.   if (!silent)
  149.     printf("- Open isam-filen");
  150.   
  151.   if (!(file=mi_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
  152.     goto err;
  153.   if (!silent)
  154.     printf("- Writing key:sn");
  155.   
  156.   for (i=0; i<nrecords; i++ )
  157.   {
  158.     create_record(record,i);
  159.     error=mi_write(file,record);
  160.     print_record(record,mi_position(file),"n");
  161.     if (!error)
  162.     {
  163.       row_count++;
  164.     }
  165.     else
  166.     {
  167.       printf("mi_write: %dn", error);
  168.       goto err;
  169.     }
  170.   }
  171.   if ((error=read_with_pos(file,silent)))
  172.     goto err;
  173.   if (!silent)
  174.     printf("- Reading rows with keyn");
  175.   
  176.   for (i=0 ; i < nrecords ; i++)
  177.   {
  178.     my_errno=0;
  179.     create_record(record,i);
  180.     
  181.     bzero((char*) read_record,MAX_REC_LENGTH);
  182.     error=mi_rkey(file,read_record,0,record+1,0,HA_READ_MBR_EQUAL);
  183.     
  184.     if (error && error!=HA_ERR_KEY_NOT_FOUND)
  185.     {
  186.       printf("     mi_rkey: %3d  errno: %3dn",error,my_errno);
  187.       goto err;
  188.     }
  189.     if (error == HA_ERR_KEY_NOT_FOUND)
  190.     {
  191.       print_record(record,mi_position(file),"  NOT FOUNDn");
  192.       continue;
  193.     }
  194.     print_record(read_record,mi_position(file),"n");
  195.   }
  196.   if (!silent)
  197.     printf("- Deleting rowsn");
  198.   for (i=0; i < nrecords/4; i++)
  199.   {
  200.     my_errno=0;
  201.     bzero((char*) read_record,MAX_REC_LENGTH);
  202.     error=mi_rrnd(file,read_record,i == 0 ? 0L : HA_OFFSET_ERROR);
  203.     if (error)
  204.     {
  205.       printf("pos: %2d  mi_rrnd: %3d  errno: %3dn",i,error,my_errno);
  206.       goto err;
  207.     }
  208.     print_record(read_record,mi_position(file),"n");
  209.     error=mi_delete(file,read_record);
  210.     if (error)
  211.     {
  212.       printf("pos: %2d mi_delete: %3d errno: %3dn",i,error,my_errno);
  213.       goto err;
  214.     }
  215.   }
  216.   if (!silent)
  217.     printf("- Updating rows with positionn");
  218.   for (i=0; i < (nrecords - nrecords/4) ; i++)
  219.   {
  220.     my_errno=0;
  221.     bzero((char*) read_record,MAX_REC_LENGTH);
  222.     error=mi_rrnd(file,read_record,i == 0 ? 0L : HA_OFFSET_ERROR);
  223.     if (error)
  224.     {
  225.       if (error==HA_ERR_RECORD_DELETED)
  226.         continue;
  227.       printf("pos: %2d  mi_rrnd: %3d  errno: %3dn",i,error,my_errno);
  228.       goto err;
  229.     }
  230.     print_record(read_record,mi_position(file),"");
  231.     create_record(record,i+nrecords*upd);
  232.     printf("t-> ");
  233.     print_record(record,mi_position(file),"n");
  234.     error=mi_update(file,read_record,record);
  235.     if (error)
  236.     {
  237.       printf("pos: %2d  mi_update: %3d  errno: %3dn",i,error,my_errno);
  238.       goto err;
  239.     }
  240.   }
  241.   if ((error=read_with_pos(file,silent)))
  242.     goto err;
  243.   if (!silent)
  244.     printf("- Test mi_rkey then a sequence of mi_rnext_samen");
  245.   
  246.   create_record(record, nrecords*4/5);
  247.   print_record(record,0,"  search forn");
  248.   
  249.   if ((error=mi_rkey(file,read_record,0,record+1,0,HA_READ_MBR_INTERSECT)))
  250.   {
  251.     printf("mi_rkey: %3d  errno: %3dn",error,my_errno);
  252.     goto err;
  253.   }
  254.   print_record(read_record,mi_position(file),"  mi_rkeyn");
  255.   row_count=1;
  256.   for (;;)
  257.   {
  258.     if ((error=mi_rnext_same(file,read_record)))
  259.     {
  260.       if (error==HA_ERR_END_OF_FILE)
  261.         break;
  262.       printf("mi_next: %3d  errno: %3dn",error,my_errno);
  263.       goto err;
  264.     }
  265.     print_record(read_record,mi_position(file),"  mi_rnext_samen");
  266.       row_count++;
  267.   }
  268.   printf("     %d rowsn",row_count);
  269.   if (!silent)
  270.     printf("- Test mi_rfirst then a sequence of mi_rnextn");
  271.   error=mi_rfirst(file,read_record,0);
  272.   if (error)
  273.   {
  274.     printf("mi_rfirst: %3d  errno: %3dn",error,my_errno);
  275.     goto err;
  276.   }
  277.   row_count=1;
  278.   print_record(read_record,mi_position(file),"  mi_frirstn");
  279.   
  280.   for (i=0;i<nrecords;i++)
  281.   {
  282.     if ((error=mi_rnext(file,read_record,0)))
  283.     {
  284.       if (error==HA_ERR_END_OF_FILE)
  285.         break;
  286.       printf("mi_next: %3d  errno: %3dn",error,my_errno);
  287.       goto err;
  288.     }
  289.     print_record(read_record,mi_position(file),"  mi_rnextn");
  290.     row_count++;
  291.   }
  292.   printf("     %d rowsn",row_count);
  293.   if (!silent)
  294.     printf("- Test mi_records_in_range()n");
  295.   create_record1(record, nrecords*4/5);
  296.   print_record(record,0,"n");
  297.   
  298.   range.key= record+1;
  299.   range.length= 1000;                           /* Big enough */
  300.   range.flag= HA_READ_MBR_INTERSECT;
  301.   hrows= mi_records_in_range(file,0, &range, (key_range*) 0);
  302.   printf("     %ld rowsn", (long) hrows);
  303.   if (mi_close(file)) goto err;
  304.   my_end(MY_CHECK_ERROR);
  305.   
  306.   return 0;
  307.   
  308. err:
  309.   printf("got error: %3d when using myisam-databasen",my_errno);
  310.   return 1;           /* skip warning */
  311. }
  312. static int read_with_pos (MI_INFO * file,int silent)
  313. {
  314.   int error;
  315.   int i;
  316.   char read_record[MAX_REC_LENGTH];
  317.   if (!silent)
  318.     printf("- Reading rows with positionn");
  319.   for (i=0;;i++)
  320.   {
  321.     my_errno=0;
  322.     bzero((char*) read_record,MAX_REC_LENGTH);
  323.     error=mi_rrnd(file,read_record,i == 0 ? 0L : HA_OFFSET_ERROR);
  324.     if (error)
  325.     {
  326.       if (error==HA_ERR_END_OF_FILE)
  327.         break;
  328.       if (error==HA_ERR_RECORD_DELETED)
  329.         continue;
  330.       printf("pos: %2d  mi_rrnd: %3d  errno: %3dn",i,error,my_errno);
  331.       return error;
  332.     }
  333.     print_record(read_record,mi_position(file),"n");
  334.   }
  335.   return 0;
  336. }
  337. #ifdef NOT_USED
  338. static void bprint_record(char * record,
  339.   my_off_t offs __attribute__((unused)),
  340.   const char * tail)
  341. {
  342.   int i;
  343.   char * pos;
  344.   i=(unsigned char)record[0];
  345.   printf("%02X ",i);
  346.   
  347.   for( pos=record+1, i=0; i<32; i++,pos++){
  348.     int b=(unsigned char)*pos;
  349.     printf("%02X",b);
  350.   }
  351.   printf("%s",tail);
  352. }
  353. #endif
  354. static void print_record(char * record,
  355.  my_off_t offs __attribute__((unused)),
  356.  const char * tail)
  357. {
  358.   int i;
  359.   char * pos;
  360.   double c;
  361.   
  362.   printf("     rec=(%d)",(unsigned char)record[0]);
  363.   for ( pos=record+1, i=0; i<2*ndims; i++)
  364.    {
  365.       memcpy(&c,pos,sizeof(c));
  366.       float8get(c,pos);
  367.       printf(" %.14g ",c);
  368.       pos+=sizeof(c);
  369.    }
  370.    printf("pos=%ld",(long int)offs);
  371.    printf("%s",tail);
  372. }
  373. static void create_record1(char *record,uint rownr)
  374. {
  375.    int i;
  376.    char * pos;
  377.    double c=rownr+10;
  378.    
  379.    bzero((char*) record,MAX_REC_LENGTH);
  380.    record[0]=0x01; /* DEL marker */
  381.    for ( pos=record+1, i=0; i<2*ndims; i++)
  382.    {
  383.       memcpy(pos,&c,sizeof(c));
  384.       float8store(pos,c);
  385.       pos+=sizeof(c);
  386.    }
  387. }
  388. #ifdef NOT_USED
  389. static void create_record0(char *record,uint rownr)
  390. {
  391.    int i;
  392.    char * pos;
  393.    double c=rownr+10;
  394.    double c0=0;
  395.    
  396.    bzero((char*) record,MAX_REC_LENGTH);
  397.    record[0]=0x01; /* DEL marker */
  398.    for ( pos=record+1, i=0; i<ndims; i++)
  399.    {
  400.       memcpy(pos,&c0,sizeof(c0));
  401.       float8store(pos,c0);
  402.       pos+=sizeof(c0);
  403.       memcpy(pos,&c,sizeof(c));
  404.       float8store(pos,c);
  405.       pos+=sizeof(c);
  406.    }
  407. }
  408. #endif
  409. static void create_record(char *record,uint rownr)
  410. {
  411.    int i;
  412.    char *pos;
  413.    double *data= rt_data+rownr*4;
  414.    record[0]=0x01; /* DEL marker */
  415.    for ( pos=record+1, i=0; i<ndims*2; i++)
  416.    {
  417.       float8store(pos,data[i]);
  418.       pos+=8;
  419.    }
  420. }
  421. #else
  422. int main(int argc __attribute__((unused)),char *argv[] __attribute__((unused)))
  423. {
  424.   exit(0);
  425. }
  426. #endif /*HAVE_RTREE_KEYS*/