Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages | Search for 
mysql-5.0.2-alpha / include

my_handler.h File Reference

#include "my_global.h"
#include "my_base.h"
#include "m_ctype.h"
#include "myisampack.h"

Include dependency graph for my_handler.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Classes

struct  st_HA_KEYSEG

Defines

#define get_key_length(length, key)
#define get_key_length_rdonly(length, key)
#define get_key_pack_length(length, length_pack, key)

Typedefs

typedef st_HA_KEYSEG HA_KEYSEG

Functions

int mi_compare_text (CHARSET_INFO *, uchar *, uint, uchar *, uint, my_bool, my_bool)
int ha_key_cmp (register HA_KEYSEG *keyseg, register uchar *a, register uchar *b, uint key_length, uint nextflag, uint *diff_pos)

Define Documentation

#define get_key_length (  length,
key   ) 
 

Value:

{ if ((uchar) *(key) != 255) \
    length= (uint) (uchar) *((key)++); \
  else \
  { length=mi_uint2korr((key)+1); (key)+=3; } \
}

#define get_key_length_rdonly (  length,
key   ) 
 

Value:

{ if ((uchar) *(key) != 255) \
    length= ((uint) (uchar) *((key))); \
  else \
  { length=mi_uint2korr((key)+1); } \
}

#define get_key_pack_length (  length,
length_pack,
key   ) 
 

Value:

{ if ((uchar) *(key) != 255) \
  { length= (uint) (uchar) *((key)++); length_pack=1; }\
  else \
  { length=mi_uint2korr((key)+1); (key)+=3; length_pack=3; } \
}

Typedef Documentation

typedef struct st_HA_KEYSEG HA_KEYSEG
 

Function Documentation

int ha_key_cmp (  register HA_KEYSEG *  keyseg,
register uchar *  a,
register uchar *  b,
uint  key_length,
uint  nextflag,
uint *  diff_pos
) 
  

00102 {
00103   int flag;
00104   int16 s_1,s_2;
00105   int32 l_1,l_2;
00106   uint32 u_1,u_2;
00107   float f_1,f_2;
00108   double d_1,d_2;
00109   uint next_key_length;
00110 
00111   *diff_pos=0;
00112   for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
00113   {
00114     uchar *end;
00115     uint piks=! (keyseg->flag & HA_NO_SORT);
00116     (*diff_pos)++;
00117 
00118     /* Handle NULL part */
00119     if (keyseg->null_bit)
00120     {
00121       key_length--;
00122       if (*a != *b && piks)
00123       {
00124         flag = (int) *a - (int) *b;
00125         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00126       }
00127       b++;
00128       if (!*a++)                                /* If key was NULL */
00129       {
00130         if (nextflag == (SEARCH_FIND | SEARCH_UPDATE))
00131           nextflag=SEARCH_SAME;                 /* Allow duplicate keys */
00132         else if (nextflag & SEARCH_NULL_ARE_NOT_EQUAL)
00133         {
00134           /*
00135             This is only used from mi_check() to calculate cardinality.
00136             It can't be used when searching for a key as this would cause
00137             compare of (a,b) and (b,a) to return the same value.
00138           */
00139           return -1;
00140         }
00141         next_key_length=key_length;
00142         continue;                               /* To next key part */
00143       }
00144     }
00145     end= a+ min(keyseg->length,key_length);
00146     next_key_length=key_length-keyseg->length;
00147 
00148     switch ((enum ha_base_keytype) keyseg->type) {
00149     case HA_KEYTYPE_TEXT:                       /* Ascii; Key is converted */
00150       if (keyseg->flag & HA_SPACE_PACK)
00151       {
00152         int a_length,b_length,pack_length;
00153         get_key_length(a_length,a);
00154         get_key_pack_length(b_length,pack_length,b);
00155         next_key_length=key_length-b_length-pack_length;
00156 
00157         if (piks &&
00158             (flag=mi_compare_text(keyseg->charset,a,a_length,b,b_length,
00159                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
00160                                              next_key_length <= 0),
00161                                   (my_bool)!(nextflag & SEARCH_PREFIX))))
00162           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00163         a+=a_length;
00164         b+=b_length;
00165         break;
00166       }
00167       else
00168       {
00169         uint length=(uint) (end-a), a_length=length, b_length=length;
00170         if (piks &&
00171             (flag= mi_compare_text(keyseg->charset, a, a_length, b, b_length,
00172                                    (my_bool) ((nextflag & SEARCH_PREFIX) &&
00173                                               next_key_length <= 0),
00174                                    (my_bool)!(nextflag & SEARCH_PREFIX))))
00175           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00176         a=end;
00177         b+=length;
00178       }
00179       break;
00180     case HA_KEYTYPE_BINARY:
00181       if (keyseg->flag & HA_SPACE_PACK)
00182       {
00183         int a_length,b_length,pack_length;
00184         get_key_length(a_length,a);
00185         get_key_pack_length(b_length,pack_length,b);
00186         next_key_length=key_length-b_length-pack_length;
00187 
00188         if (piks &&
00189             (flag=compare_bin(a,a_length,b,b_length,
00190                               (my_bool) ((nextflag & SEARCH_PREFIX) &&
00191                                          next_key_length <= 0),1)))
00192           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00193         a+=a_length;
00194         b+=b_length;
00195         break;
00196       }
00197       else
00198       {
00199         uint length=keyseg->length;
00200         if (piks &&
00201             (flag=compare_bin(a,length,b,length,
00202                               (my_bool) ((nextflag & SEARCH_PREFIX) &&
00203                                          next_key_length <= 0),0)))
00204           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00205         a+=length;
00206         b+=length;
00207       }
00208       break;
00209     case HA_KEYTYPE_VARTEXT:
00210       {
00211         int a_length,full_a_length,b_length,full_b_length,pack_length;
00212         get_key_length(a_length,a);
00213         get_key_pack_length(b_length,pack_length,b);
00214         full_a_length= a_length;
00215         full_b_length= b_length;
00216         next_key_length=key_length-b_length-pack_length;
00217 
00218         if (piks &&
00219             (flag= mi_compare_text(keyseg->charset,a,a_length,b,b_length,
00220                                    (my_bool) ((nextflag & SEARCH_PREFIX) &&
00221                                               next_key_length <= 0),
00222                                    (my_bool) ((nextflag & (SEARCH_FIND |
00223                                                            SEARCH_UPDATE)) ==
00224                                               SEARCH_FIND))))
00225           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00226         a+= full_a_length;
00227         b+= full_b_length;
00228         break;
00229       }
00230       break;
00231     case HA_KEYTYPE_VARBINARY:
00232       {
00233         int a_length,b_length,pack_length;
00234         get_key_length(a_length,a);
00235         get_key_pack_length(b_length,pack_length,b);
00236         next_key_length=key_length-b_length-pack_length;
00237 
00238         if (piks &&
00239             (flag=compare_bin(a,a_length,b,b_length,
00240                               (my_bool) ((nextflag & SEARCH_PREFIX) &&
00241                                          next_key_length <= 0), 0)))
00242           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00243         a+=a_length;
00244         b+=b_length;
00245         break;
00246       }
00247       break;
00248     case HA_KEYTYPE_INT8:
00249     {
00250       int i_1= (int) *((signed char*) a);
00251       int i_2= (int) *((signed char*) b);
00252       if (piks && (flag = CMP_NUM(i_1,i_2)))
00253         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00254       a= end;
00255       b++;
00256       break;
00257     }
00258     case HA_KEYTYPE_SHORT_INT:
00259       s_1= mi_sint2korr(a);
00260       s_2= mi_sint2korr(b);
00261       if (piks && (flag = CMP_NUM(s_1,s_2)))
00262         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00263       a=  end;
00264       b+= 2; /* sizeof(short int); */
00265       break;
00266     case HA_KEYTYPE_USHORT_INT:
00267       {
00268         uint16 us_1,us_2;
00269         us_1= mi_sint2korr(a);
00270         us_2= mi_sint2korr(b);
00271         if (piks && (flag = CMP_NUM(us_1,us_2)))
00272           return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00273         a=  end;
00274         b+=2; /* sizeof(short int); */
00275         break;
00276       }
00277     case HA_KEYTYPE_LONG_INT:
00278       l_1= mi_sint4korr(a);
00279       l_2= mi_sint4korr(b);
00280       if (piks && (flag = CMP_NUM(l_1,l_2)))
00281         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00282       a=  end;
00283       b+= 4; /* sizeof(long int); */
00284       break;
00285     case HA_KEYTYPE_ULONG_INT:
00286       u_1= mi_sint4korr(a);
00287       u_2= mi_sint4korr(b);
00288       if (piks && (flag = CMP_NUM(u_1,u_2)))
00289         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00290       a=  end;
00291       b+= 4; /* sizeof(long int); */
00292       break;
00293     case HA_KEYTYPE_INT24:
00294       l_1=mi_sint3korr(a);
00295       l_2=mi_sint3korr(b);
00296       if (piks && (flag = CMP_NUM(l_1,l_2)))
00297         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00298       a=  end;
00299       b+= 3;
00300       break;
00301     case HA_KEYTYPE_UINT24:
00302       l_1=mi_uint3korr(a);
00303       l_2=mi_uint3korr(b);
00304       if (piks && (flag = CMP_NUM(l_1,l_2)))
00305         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00306       a=  end;
00307       b+= 3;
00308       break;
00309     case HA_KEYTYPE_FLOAT:
00310       mi_float4get(f_1,a);
00311       mi_float4get(f_2,b);
00312       /*
00313         The following may give a compiler warning about floating point
00314         comparison not being safe, but this is ok in this context as
00315         we are bascily doing sorting
00316       */
00317       if (piks && (flag = CMP_NUM(f_1,f_2)))
00318         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00319       a=  end;
00320       b+= 4; /* sizeof(float); */
00321       break;
00322     case HA_KEYTYPE_DOUBLE:
00323       mi_float8get(d_1,a);
00324       mi_float8get(d_2,b);
00325       /*
00326         The following may give a compiler warning about floating point
00327         comparison not being safe, but this is ok in this context as
00328         we are bascily doing sorting
00329       */
00330       if (piks && (flag = CMP_NUM(d_1,d_2)))
00331         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00332       a=  end;
00333       b+= 8;  /* sizeof(double); */
00334       break;
00335     case HA_KEYTYPE_NUM:                                /* Numeric key */
00336     {
00337       int swap_flag= 0;
00338       int alength,blength;
00339 
00340       if (keyseg->flag & HA_REVERSE_SORT)
00341       {
00342         swap_variables(uchar*, a, b);
00343         swap_flag=1;                            /* Remember swap of a & b */
00344         end= a+ (int) (end-b);
00345       }
00346       if (keyseg->flag & HA_SPACE_PACK)
00347       {
00348         alength= *a++; blength= *b++;
00349         end=a+alength;
00350         next_key_length=key_length-blength-1;
00351       }
00352       else
00353       {
00354         alength= (int) (end-a);
00355         blength=keyseg->length;
00356         /* remove pre space from keys */
00357         for ( ; alength && *a == ' ' ; a++, alength--) ;
00358         for ( ; blength && *b == ' ' ; b++, blength--) ;
00359       }
00360       if (piks)
00361       {
00362         if (*a == '-')
00363         {
00364           if (*b != '-')
00365             return -1;
00366           a++; b++;
00367           swap_variables(uchar*, a, b);
00368           swap_variables(int, alength, blength);
00369           swap_flag=1-swap_flag;
00370           alength--; blength--;
00371           end=a+alength;
00372         }
00373         else if (*b == '-')
00374           return 1;
00375         while (alength && (*a == '+' || *a == '0'))
00376         {
00377           a++; alength--;
00378         }
00379         while (blength && (*b == '+' || *b == '0'))
00380         {
00381           b++; blength--;
00382         }
00383         if (alength != blength)
00384           return (alength < blength) ? -1 : 1;
00385         while (a < end)
00386           if (*a++ !=  *b++)
00387             return ((int) a[-1] - (int) b[-1]);
00388       }
00389       else
00390       {
00391         b+=(end-a);
00392         a=end;
00393       }
00394 
00395       if (swap_flag)                            /* Restore pointers */
00396         swap_variables(uchar*, a, b);
00397       break;
00398     }
00399 #ifdef HAVE_LONG_LONG
00400     case HA_KEYTYPE_LONGLONG:
00401     {
00402       longlong ll_a,ll_b;
00403       ll_a= mi_sint8korr(a);
00404       ll_b= mi_sint8korr(b);
00405       if (piks && (flag = CMP_NUM(ll_a,ll_b)))
00406         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00407       a=  end;
00408       b+= 8;
00409       break;
00410     }
00411     case HA_KEYTYPE_ULONGLONG:
00412     {
00413       ulonglong ll_a,ll_b;
00414       ll_a= mi_uint8korr(a);
00415       ll_b= mi_uint8korr(b);
00416       if (piks && (flag = CMP_NUM(ll_a,ll_b)))
00417         return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
00418       a=  end;
00419       b+= 8;
00420       break;
00421     }
00422 #endif
00423     case HA_KEYTYPE_END:                        /* Ready */
00424       goto end;                                 /* diff_pos is incremented */
00425     }
00426   }
00427   (*diff_pos)++;
00428 end:
00429   if (!(nextflag & SEARCH_FIND))
00430   {
00431     uint i;
00432     if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
00433       return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
00434     flag=0;
00435     for (i=keyseg->length ; i-- > 0 ; )
00436     {
00437       if (*a++ != *b++)
00438       {
00439         flag= FCMP(a[-1],b[-1]);
00440         break;
00441       }
00442     }
00443     if (nextflag & SEARCH_SAME)
00444       return (flag);                            /* read same */
00445     if (nextflag & SEARCH_BIGGER)
00446       return (flag <= 0 ? -1 : 1);              /* read next */
00447     return (flag < 0 ? -1 : 1);                 /* read previous */
00448   }
00449   return 0;
00450 } /* ha_key_cmp */

int mi_compare_text (  CHARSET_INFO *  ,
uchar *  ,
uint  ,
uchar *  ,
uint  ,
my_bool  ,
my_bool 
) 
  

00023 {
00024   if (skip_end_space)
00025     return charset_info->coll->strnncollsp(charset_info, a, a_length,
00026                                            b, b_length);
00027   return charset_info->coll->strnncoll(charset_info, a, a_length,
00028                                        b, b_length, part_key);
00029 }

Generated on Thu Feb 24 10:34:42 2005 for MySQL by  doxygen 1.3.9.1