Skip navigation links

MySQL Newsletter - Subscribe Today!

The world's most popular open source database

MySQL 5.1: mysql/src/5.1-dbg/include/my_handler.h File Reference

mysql/src/5.1-dbg/include/my_handler.h File Reference

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

Include dependency graph for my_handler.h:

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

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)
#define store_key_length_inc(key, length)
#define get_rec_bits(bit_ptr, bit_ofs, bit_len)
#define set_rec_bits(bits, bit_ptr, bit_ofs, bit_len)
#define clr_rec_bits(bit_ptr, bit_ofs, bit_len)   set_rec_bits(0, bit_ptr, bit_ofs, bit_len)

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)
HA_KEYSEG * ha_find_null (HA_KEYSEG *keyseg, uchar *a)

Define Documentation

#define clr_rec_bits ( bit_ptr,
bit_ofs,
bit_len   )     set_rec_bits(0, bit_ptr, bit_ofs, bit_len)

Definition at line 81 of file my_handler.h.

Referenced by _mi_put_key_in_record(), and Field_bit::store().

#define get_key_length ( length,
key   ) 

Value:

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

Definition at line 40 of file my_handler.h.

Referenced by _mi_calc_var_pack_key_length(), _mi_get_binary_pack_key(), _mi_get_pack_key(), _mi_insert(), _mi_keylength(), _mi_keylength_part(), _mi_prefix_search(), _mi_put_key_in_record(), _mi_rec_unpack(), ha_find_null(), ha_key_cmp(), hp_rb_var_key_length(), and remove_key().

#define get_key_length_rdonly ( length,
key   ) 

Value:

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

Definition at line 47 of file my_handler.h.

#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; } \
}

Definition at line 54 of file my_handler.h.

Referenced by _mi_calc_bin_pack_key_length(), _mi_calc_var_pack_key_length(), _mi_prefix_search(), ha_key_cmp(), and remove_key().

#define get_rec_bits ( bit_ptr,
bit_ofs,
bit_len   ) 

Value:

(((((uint16) (bit_ptr)[1] << 8) | (uint16) (bit_ptr)[0]) >> (bit_ofs)) & \
   ((1 << (bit_len)) - 1))

Definition at line 68 of file my_handler.h.

Referenced by _mi_make_key(), Field_bit::cmp_max(), Field_bit::cmp_offset(), Field_bit::get_key_image(), Field_bit::key_cmp(), key_copy(), Field_bit::pack(), and Field_bit::val_int().

#define set_rec_bits ( bits,
bit_ptr,
bit_ofs,
bit_len   ) 

Value:

{ \
  (bit_ptr)[0]= ((bit_ptr)[0] & ~(((1 << (bit_len)) - 1) << (bit_ofs))) | \
                ((bits) << (bit_ofs)); \
  if ((bit_ofs) + (bit_len) > 8) \
    (bit_ptr)[1]= ((bit_ptr)[1] & ~((1 << ((bit_len) - 8 + (bit_ofs))) - 1)) | \
                  ((bits) >> (8 - (bit_ofs))); \
}

Definition at line 72 of file my_handler.h.

Referenced by _mi_put_key_in_record(), key_restore(), Field_bit::store(), and Field_bit::unpack().

#define store_key_length_inc ( key,
length   ) 

Value:

{ if ((length) < 255) \
  { *(key)++=(length); } \
  else \
  { *(key)=255; mi_int2store((key)+1,(length)); (key)+=3; } \
}

Definition at line 61 of file my_handler.h.

Referenced by _mi_get_pack_key(), _mi_make_key(), _mi_pack_key(), _mi_rec_pack(), _mi_store_bin_pack_key(), _mi_store_var_pack_key(), hp_rb_make_key(), and hp_rb_pack_key().

Typedef Documentation

typedef struct st_HA_KEYSEG HA_KEYSEG

Function Documentation

HA_KEYSEG* ha_find_null ( HA_KEYSEG *  keyseg,
uchar *  a 
)

Definition at line 493 of file my_handler.c.

References DBUG_ASSERT, st_HA_KEYSEG::flag, get_key_length, HA_KEYTYPE_BINARY, HA_KEYTYPE_BIT, HA_KEYTYPE_DOUBLE, HA_KEYTYPE_END, HA_KEYTYPE_FLOAT, HA_KEYTYPE_INT24, HA_KEYTYPE_INT8, HA_KEYTYPE_LONG_INT, HA_KEYTYPE_LONGLONG, HA_KEYTYPE_NUM, HA_KEYTYPE_SHORT_INT, HA_KEYTYPE_TEXT, HA_KEYTYPE_UINT24, HA_KEYTYPE_ULONG_INT, HA_KEYTYPE_ULONGLONG, HA_KEYTYPE_USHORT_INT, HA_KEYTYPE_VARBINARY1, HA_KEYTYPE_VARBINARY2, HA_KEYTYPE_VARTEXT1, HA_KEYTYPE_VARTEXT2, HA_SPACE_PACK, keyseg, st_HA_KEYSEG::length, st_HA_KEYSEG::null_bit, and st_HA_KEYSEG::type.

Referenced by mi_collect_stats_nonulls_first(), and mi_collect_stats_nonulls_next().

00494 {
00495   for (; (enum ha_base_keytype) keyseg->type != HA_KEYTYPE_END; keyseg++)
00496   {
00497     uchar *end;
00498     if (keyseg->null_bit)
00499     {
00500       if (!*a++)
00501         return keyseg;
00502     }
00503     end= a+ keyseg->length;
00504 
00505     switch ((enum ha_base_keytype) keyseg->type) {
00506     case HA_KEYTYPE_TEXT:
00507     case HA_KEYTYPE_BINARY:
00508     case HA_KEYTYPE_BIT:
00509       if (keyseg->flag & HA_SPACE_PACK)
00510       {
00511         int a_length;
00512         get_key_length(a_length, a);
00513         a += a_length;
00514         break;
00515       }
00516       else
00517         a= end;
00518       break;
00519     case HA_KEYTYPE_VARTEXT1:
00520     case HA_KEYTYPE_VARTEXT2:
00521     case HA_KEYTYPE_VARBINARY1:
00522     case HA_KEYTYPE_VARBINARY2:
00523       {
00524         int a_length;
00525         get_key_length(a_length, a);
00526         a+= a_length;
00527         break;
00528       }
00529     case HA_KEYTYPE_NUM:
00530       if (keyseg->flag & HA_SPACE_PACK)
00531       {
00532         int alength= *a++;
00533         end= a+alength;
00534       }
00535       a= end;
00536       break;
00537     case HA_KEYTYPE_INT8:
00538     case HA_KEYTYPE_SHORT_INT:
00539     case HA_KEYTYPE_USHORT_INT:
00540     case HA_KEYTYPE_LONG_INT:
00541     case HA_KEYTYPE_ULONG_INT:
00542     case HA_KEYTYPE_INT24:
00543     case HA_KEYTYPE_UINT24:
00544 #ifdef HAVE_LONG_LONG
00545     case HA_KEYTYPE_LONGLONG:
00546     case HA_KEYTYPE_ULONGLONG:
00547 #endif
00548     case HA_KEYTYPE_FLOAT:
00549     case HA_KEYTYPE_DOUBLE:
00550       a= end;
00551       break;
00552     case HA_KEYTYPE_END:                        /* purecov: inspected */
00553       /* keep compiler happy */
00554       DBUG_ASSERT(0);
00555       break;
00556     }
00557   }
00558   return keyseg;
00559 }

Here is the caller graph for this function:

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

Definition at line 116 of file my_handler.c.

Referenced by _mi_bin_search(), _mi_prefix_search(), _mi_search(), _mi_seq_search(), check_one_rb_key(), chk_index(), keys_compare(), mi_collect_stats_nonulls_next(), mi_rnext_same(), queue_key_cmp(), sort_key_cmp(), and sort_key_write().

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

Here is the caller graph for this function:

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

Definition at line 21 of file my_handler.c.

References charset_info, charset_info_st::coll, and my_collation_handler_st::strnncollsp.

Referenced by _ft2_search(), _mi_ft_cmp(), _mi_ft_update(), _mi_insert(), FT_STOPWORD_cmp(), FT_WORD_cmp(), ftb_find_relevance_add_word(), FTB_WORD_cmp_list(), ha_key_cmp(), mi_unique_comp(), sort_ft_key_write(), and walk_and_match().

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

Here is the caller graph for this function:

Generated on Sat Sep 9 01:35:22 2006 for MySQL 5.1 by  doxygen 1.4.7