mirror of
https://github.com/MariaDB/server.git
synced 2025-05-28 13:01:41 +03:00
- Reserver namespace and place in frm for TABLE_CHECKSUM and PAGE_CHECKSUM create options - Added syncing of directory when creating .frm files - Portability fixes - Added missing cast that could cause bugs - Code cleanups - Made some bit functions inline - Moved things out of myisam.h to my_handler.h to make them more accessable - Renamed some myisam variables and defines to make them more globaly usable (as they are used outside of MyISAM) - Fixed bugs in error conditions - Use compiler time asserts instead of run time - Fixed indentation HA_EXTRA_PREPARE_FOR_DELETE -> HA_EXTRA_PREPARE_FOR_DROP as the old name was wrong (Added a define for old value to ensure we don't break any old code) Added HA_EXTRA_PREPARE_FOR_RENAME as a signal for rename (before we used a DROP signal which is wrong) - Initialize error messages early to get better errors when mysqld or an engine fails to start - Fix windows bug that query_performance_frequency was not initialized if registry code failed - thread_stack -> my_thread_stack_size BitKeeper/etc/ignore: added libmysqld/scheduler.cc libmysqld/sql_connect.cc libmysqld/sql_tablespace.cc include/Makefile.am: Added my_bit.h include/m_string.h: Added bzero_if_purify() to simplify code include/my_base.h: Reserve options for the future Added HA_OPTION_NULL_FIELDS, HA_OPTION_PAGE_CHECKSUM, HA_CREATE_PAGE_CHECKSUM Added new error message HA_ERR_NEW_FILE Added optional new row type BLOCK_RECORD Renamed HA_EXTRA_PREPARE_FOR_DELETE to HA_EXTRA_PREPARE_FOR_DROP Added HA_EXTRA_PREARE_FOR_RENAME to inform handler we will do a rename (Added define to make things compatible until 6.0) Moved invalidator_by_filename form myisam.h include/my_dbug.h: Poirtablity fix include/my_global.h: Added helper macros STATIC_INLINE and MY_ERRPTR Added NEED_EXPLICIT_SYNC_DIR include/my_handler.h: Added missing casts Moved some constants and macros out from myisam.h to make these generally available Renamed mi_compare_text() to ha_compare_text() as this function is not myisam specific Renamed mi_portable_sizeof_char_ptr to portable_sizeof_char_ptr Added registering of handler messages for better error reporting during startup include/my_sys.h: Added my_sync_dir() and my_sync_dir_by_file() More comments Some indentation fixes Moved bit functions to my_bit.h Added prototype for crc32() include/myisam.h: Moved things from here to my_handler.h to make them more accessable libmysql/Makefile.shared: Added my_sync mysys/array.c: Fixed indentation and spelling errors Split set_dynamic() to two functions Added allocate_dynamic() as a new visiable function (no new code, only refactoring) mysys/mf_iocache.c: More DBUG mysys/mf_keycache.c: More explicite ASSERT Removed some casts Fixed indentation mysys/mf_tempfile.c: Fixed bug with possible dangling file descriptor mysys/my_atomic.c: Use compile time asserts instead of run time mysys/my_bit.c: Make most bit functions inline mysys/my_bitmap.c: Added my_bit.h mysys/my_compress.c: Fixed indentation mysys/my_create.c: Added my_sync_by_dir() mysys/my_delete.c: Added my_sync_by_dir() mysys/my_error.c: init_glob_errs() is now done in my_init() mysys/my_handler.c: mi_compare_text() -> ha_compare_text() as this is not MyISAM specific Added functions to initialize handler error messages Fixed indentation More clear usage of include files mysys/my_init.c: Added my_thread_stack_size to be used by other programs Ensure that global error messages are always initialized Fix windows bug that query_performance_frequency was not initialized if registry code failed mysys/my_open.c: More comments Removed duplicate code mysys/my_pread.c: Ensure that my_errno is set even if errno is 0 mysys/my_realloc.c: Added comment mysys/my_rename.c: Added syncing of directories mysys/my_symlink.c: Added my_sync_by_dir() mysys/my_sync.c: Added my_sync_dir() On recent Mac OS X, fcntl(F_FULLFSYNC) is recommended over fsync() (see "man fsync" on Mac OS X 10.3). my_sync_dir(): to sync a directory after a file creation/deletion/ renaming; can be called directly or via MY_SYNC_DIR in my_create/ my_delete/my_rename(). No-op except on Linux (see "man fsync" on Linux). my_sync_dir_from_file(): same as above, just more practical when the caller has a file name but no directory name ready. Should the #warning even be a #error? I mean do we want to release binaries which don't guarantee any durability? mysys/safemalloc.c: Added sf_malloc_report_allocated() (Debugging aid) sql/gen_lex_hash.cc: Remove inline for big function sql/ha_partition.cc: HA_EXTRA_PREPARE_FOR_DELETE -> HA_EXTRA_PREPARE_FOR_DROP prepare_for_delete -> prepare_for_rename() as this is the the time this function is called sql/ha_partition.h: prepare_for_delete -> prepare_for_rename() as this is the the time this function is called sql/handler.cc: ha_init_errors() is now called at startup before plugins This allows us to get better error messages sql/handler.h: Reserve enum value for Maria Add future proof enum for page checksums sql/item_func.cc: Include my_bit.h sql/lex.h: Added future proof CREATE table options sql/log.cc: Added comment sql/mysql_priv.h: thread_stack moved to mysys sql/mysqld.cc: thread_stack moved to mysys thread_stack -> my_thread_stack_size Initialize myisam key caches before plugins starts Initialize error to allow storage engine to give better error messages if init failes. Fixed indentation Group all MyISAM options together Added new status variable 'Opened_table_definitions' to allow one to monitor if table definition cache is too small Clarified some option help messages sql/opt_range.cc: Removed wrong usage of SAFE_MODE (this disabled key usage for UPDATES, which was never the intention) Removed print if total cost in a place where it didn't have any usable value sql/set_var.cc: thread_stack -> my_thread_stack sql/sql_class.cc: Intialize transaction object properly sql/sql_parse.cc: thread_stack -> my_thread_stack sql/sql_select.cc: Include my_bit.h mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr sql/sql_show.cc: Simplify handling of ha_choice variables Added future safe PAGE_CHECKSUM option Addid missing 'transactional=#' in information schema sql/sql_table.cc: HA_EXTRA_PREPARE_FOR_DELETE -> HA_EXTRA_FORCE_REOPEN when doing reopen HA_EXTRA_PREPARE_FOR_DELETE -> HA_EXTRA_PREPARE_FOR_RENAME when doing rename Removed not needed initialization sql/sql_test.cc: thread_stack -> my_thread_stack sql/sql_yacc.yy: Simplify handling of ha_choice variables Added future proof create table options TABLE_CHECKSUM=# & PAGE_CHECKSUM=# sql/table.cc: Save page_checksum in .frm sql/table.h: Added variable to hold create table option PAGE_CHECKSUM sql/unireg.cc: Added syncing of directories storage/myisam/ft_boolean_search.c: mi_compare_text() -> ha_compare_text() storage/myisam/ft_eval.c: mi_compare_text() -> ha_compare_text() storage/myisam/ft_nlq_search.c: mi_compare_text() -> ha_compare_text() storage/myisam/ft_parser.c: mi_compare_text() -> ha_compare_text() storage/myisam/ft_stopwords.c: mi_compare_text() -> ha_compare_text() storage/myisam/ft_test1.c: mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/ft_update.c: mi_compare_text() -> ha_compare_text() storage/myisam/ha_myisam.cc: Include my_bit.h storage/myisam/mi_check.c: MI_MAX_POSSIBLE_KEY_BUFF -> HA_MAX_POSSIBLE_KEY_BUFF mi_compare_text() -> ha_compare_text() Added BLOCK_RECORD to avoid compiler warnings storage/myisam/mi_checksum.c: mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/mi_create.c: MI_MAX_POSSIBLE_KEY -> HA_MAX_POSSIBLE_KEY MI_MAX_KEY_BLOCK_SIZE -> HA_MAX_KEY_BLOCK_SIZE mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/mi_dynrec.c: mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/mi_extra.c: HA_EXTRA_PREPARE_FOR_DELETE -> HA_EXTRA_PREPARE_FOR_DROP storage/myisam/mi_open.c: MI_MAX_POSSIBLE_KEY -> HA_MAX_POSSIBLE_KEY mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/mi_packrec.c: mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/mi_range.c: mi_compare_text -> ha_compare_text storage/myisam/mi_test1.c: mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/mi_test2.c: mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/mi_unique.c: mi_compare_text() -> ha_compare_text() storage/myisam/mi_write.c: mi_compare_text() -> ha_compare_text() storage/myisam/myisamchk.c: Include my_bit.h storage/myisam/myisamdef.h: Moved store_key_length_inc to handler.h storage/myisam/myisampack.c: mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisam/sp_test.c: mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr storage/myisammrg/ha_myisammrg.cc: HA_EXTRA_PREPARE_FOR_DELETE -> HA_EXTRA_PREPARE_FOR_DROP include/my_bit.h: New BitKeeper file ``include/my_bit.h''
632 lines
18 KiB
C
632 lines
18 KiB
C
/* Copyright (C) 2002-2006 MySQL AB
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; version 2
|
|
of the License.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with this library; if not, write to the Free
|
|
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
|
|
MA 02111-1307, USA */
|
|
|
|
#include <my_global.h>
|
|
#include <m_ctype.h>
|
|
#include <my_base.h>
|
|
#include <my_handler.h>
|
|
#include <my_sys.h>
|
|
|
|
int ha_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
|
|
uchar *b, uint b_length, my_bool part_key,
|
|
my_bool skip_end_space)
|
|
{
|
|
if (!part_key)
|
|
return charset_info->coll->strnncollsp(charset_info, a, a_length,
|
|
b, b_length, (my_bool)!skip_end_space);
|
|
return charset_info->coll->strnncoll(charset_info, a, a_length,
|
|
b, b_length, part_key);
|
|
}
|
|
|
|
|
|
static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
|
|
my_bool part_key, my_bool skip_end_space)
|
|
{
|
|
uint length= min(a_length,b_length);
|
|
uchar *end= a+ length;
|
|
int flag;
|
|
|
|
while (a < end)
|
|
if ((flag= (int) *a++ - (int) *b++))
|
|
return flag;
|
|
if (part_key && b_length < a_length)
|
|
return 0;
|
|
if (skip_end_space && a_length != b_length)
|
|
{
|
|
int swap= 1;
|
|
/*
|
|
We are using space compression. We have to check if longer key
|
|
has next character < ' ', in which case it's less than the shorter
|
|
key that has an implicite space afterwards.
|
|
|
|
This code is identical to the one in
|
|
strings/ctype-simple.c:my_strnncollsp_simple
|
|
*/
|
|
if (a_length < b_length)
|
|
{
|
|
/* put shorter key in a */
|
|
a_length= b_length;
|
|
a= b;
|
|
swap= -1; /* swap sign of result */
|
|
}
|
|
for (end= a + a_length-length; a < end ; a++)
|
|
{
|
|
if (*a != ' ')
|
|
return (*a < ' ') ? -swap : swap;
|
|
}
|
|
return 0;
|
|
}
|
|
return (int) (a_length-b_length);
|
|
}
|
|
|
|
|
|
/*
|
|
Compare two keys
|
|
|
|
SYNOPSIS
|
|
ha_key_cmp()
|
|
keyseg Array of key segments of key to compare
|
|
a First key to compare, in format from _mi_pack_key()
|
|
This is normally key specified by user
|
|
b Second key to compare. This is always from a row
|
|
key_length Length of key to compare. This can be shorter than
|
|
a to just compare sub keys
|
|
next_flag How keys should be compared
|
|
If bit SEARCH_FIND is not set the keys includes the row
|
|
position and this should also be compared
|
|
diff_pos OUT Number of first keypart where values differ, counting
|
|
from one.
|
|
diff_pos[1] OUT (b + diff_pos[1]) points to first value in tuple b
|
|
that is different from corresponding value in tuple a.
|
|
|
|
EXAMPLES
|
|
Example1: if the function is called for tuples
|
|
('aaa','bbb') and ('eee','fff'), then
|
|
diff_pos[0] = 1 (as 'aaa' != 'eee')
|
|
diff_pos[1] = 0 (offset from beggining of tuple b to 'eee' keypart).
|
|
|
|
Example2: if the index function is called for tuples
|
|
('aaa','bbb') and ('aaa','fff'),
|
|
diff_pos[0] = 2 (as 'aaa' != 'eee')
|
|
diff_pos[1] = 3 (offset from beggining of tuple b to 'fff' keypart,
|
|
here we assume that first key part is CHAR(3) NOT NULL)
|
|
|
|
NOTES
|
|
Number-keys can't be splited
|
|
|
|
RETURN VALUES
|
|
<0 If a < b
|
|
0 If a == b
|
|
>0 If a > b
|
|
*/
|
|
|
|
#define FCMP(A,B) ((int) (A) - (int) (B))
|
|
|
|
int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
|
|
register uchar *b, uint key_length, uint nextflag,
|
|
uint *diff_pos)
|
|
{
|
|
int flag;
|
|
int16 s_1,s_2;
|
|
int32 l_1,l_2;
|
|
uint32 u_1,u_2;
|
|
float f_1,f_2;
|
|
double d_1,d_2;
|
|
uint next_key_length;
|
|
uchar *orig_b= b;
|
|
|
|
*diff_pos=0;
|
|
for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
|
|
{
|
|
uchar *end;
|
|
uint piks=! (keyseg->flag & HA_NO_SORT);
|
|
(*diff_pos)++;
|
|
diff_pos[1]= (uint)(b - orig_b);
|
|
|
|
/* Handle NULL part */
|
|
if (keyseg->null_bit)
|
|
{
|
|
key_length--;
|
|
if (*a != *b && piks)
|
|
{
|
|
flag = (int) *a - (int) *b;
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
}
|
|
b++;
|
|
if (!*a++) /* If key was NULL */
|
|
{
|
|
if (nextflag == (SEARCH_FIND | SEARCH_UPDATE))
|
|
nextflag=SEARCH_SAME; /* Allow duplicate keys */
|
|
else if (nextflag & SEARCH_NULL_ARE_NOT_EQUAL)
|
|
{
|
|
/*
|
|
This is only used from mi_check() to calculate cardinality.
|
|
It can't be used when searching for a key as this would cause
|
|
compare of (a,b) and (b,a) to return the same value.
|
|
*/
|
|
return -1;
|
|
}
|
|
next_key_length=key_length;
|
|
continue; /* To next key part */
|
|
}
|
|
}
|
|
end= a+ min(keyseg->length,key_length);
|
|
next_key_length=key_length-keyseg->length;
|
|
|
|
switch ((enum ha_base_keytype) keyseg->type) {
|
|
case HA_KEYTYPE_TEXT: /* Ascii; Key is converted */
|
|
if (keyseg->flag & HA_SPACE_PACK)
|
|
{
|
|
int a_length,b_length,pack_length;
|
|
get_key_length(a_length,a);
|
|
get_key_pack_length(b_length,pack_length,b);
|
|
next_key_length=key_length-b_length-pack_length;
|
|
|
|
if (piks &&
|
|
(flag=ha_compare_text(keyseg->charset,a,a_length,b,b_length,
|
|
(my_bool) ((nextflag & SEARCH_PREFIX) &&
|
|
next_key_length <= 0),
|
|
(my_bool)!(nextflag & SEARCH_PREFIX))))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a+=a_length;
|
|
b+=b_length;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
uint length=(uint) (end-a), a_length=length, b_length=length;
|
|
if (piks &&
|
|
(flag= ha_compare_text(keyseg->charset, a, a_length, b, b_length,
|
|
(my_bool) ((nextflag & SEARCH_PREFIX) &&
|
|
next_key_length <= 0),
|
|
(my_bool)!(nextflag & SEARCH_PREFIX))))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a=end;
|
|
b+=length;
|
|
}
|
|
break;
|
|
case HA_KEYTYPE_BINARY:
|
|
case HA_KEYTYPE_BIT:
|
|
if (keyseg->flag & HA_SPACE_PACK)
|
|
{
|
|
int a_length,b_length,pack_length;
|
|
get_key_length(a_length,a);
|
|
get_key_pack_length(b_length,pack_length,b);
|
|
next_key_length=key_length-b_length-pack_length;
|
|
|
|
if (piks &&
|
|
(flag=compare_bin(a,a_length,b,b_length,
|
|
(my_bool) ((nextflag & SEARCH_PREFIX) &&
|
|
next_key_length <= 0),1)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a+=a_length;
|
|
b+=b_length;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
uint length=keyseg->length;
|
|
if (piks &&
|
|
(flag=compare_bin(a,length,b,length,
|
|
(my_bool) ((nextflag & SEARCH_PREFIX) &&
|
|
next_key_length <= 0),0)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a+=length;
|
|
b+=length;
|
|
}
|
|
break;
|
|
case HA_KEYTYPE_VARTEXT1:
|
|
case HA_KEYTYPE_VARTEXT2:
|
|
{
|
|
int a_length,b_length,pack_length;
|
|
get_key_length(a_length,a);
|
|
get_key_pack_length(b_length,pack_length,b);
|
|
next_key_length=key_length-b_length-pack_length;
|
|
|
|
if (piks &&
|
|
(flag= ha_compare_text(keyseg->charset,a,a_length,b,b_length,
|
|
(my_bool) ((nextflag & SEARCH_PREFIX) &&
|
|
next_key_length <= 0),
|
|
(my_bool) ((nextflag & (SEARCH_FIND |
|
|
SEARCH_UPDATE)) ==
|
|
SEARCH_FIND &&
|
|
! (keyseg->flag &
|
|
HA_END_SPACE_ARE_EQUAL)))))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a+= a_length;
|
|
b+= b_length;
|
|
break;
|
|
}
|
|
break;
|
|
case HA_KEYTYPE_VARBINARY1:
|
|
case HA_KEYTYPE_VARBINARY2:
|
|
{
|
|
int a_length,b_length,pack_length;
|
|
get_key_length(a_length,a);
|
|
get_key_pack_length(b_length,pack_length,b);
|
|
next_key_length=key_length-b_length-pack_length;
|
|
|
|
if (piks &&
|
|
(flag=compare_bin(a,a_length,b,b_length,
|
|
(my_bool) ((nextflag & SEARCH_PREFIX) &&
|
|
next_key_length <= 0), 0)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a+=a_length;
|
|
b+=b_length;
|
|
break;
|
|
}
|
|
break;
|
|
case HA_KEYTYPE_INT8:
|
|
{
|
|
int i_1= (int) *((signed char*) a);
|
|
int i_2= (int) *((signed char*) b);
|
|
if (piks && (flag = CMP_NUM(i_1,i_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b++;
|
|
break;
|
|
}
|
|
case HA_KEYTYPE_SHORT_INT:
|
|
s_1= mi_sint2korr(a);
|
|
s_2= mi_sint2korr(b);
|
|
if (piks && (flag = CMP_NUM(s_1,s_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 2; /* sizeof(short int); */
|
|
break;
|
|
case HA_KEYTYPE_USHORT_INT:
|
|
{
|
|
uint16 us_1,us_2;
|
|
us_1= mi_sint2korr(a);
|
|
us_2= mi_sint2korr(b);
|
|
if (piks && (flag = CMP_NUM(us_1,us_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+=2; /* sizeof(short int); */
|
|
break;
|
|
}
|
|
case HA_KEYTYPE_LONG_INT:
|
|
l_1= mi_sint4korr(a);
|
|
l_2= mi_sint4korr(b);
|
|
if (piks && (flag = CMP_NUM(l_1,l_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 4; /* sizeof(long int); */
|
|
break;
|
|
case HA_KEYTYPE_ULONG_INT:
|
|
u_1= mi_sint4korr(a);
|
|
u_2= mi_sint4korr(b);
|
|
if (piks && (flag = CMP_NUM(u_1,u_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 4; /* sizeof(long int); */
|
|
break;
|
|
case HA_KEYTYPE_INT24:
|
|
l_1=mi_sint3korr(a);
|
|
l_2=mi_sint3korr(b);
|
|
if (piks && (flag = CMP_NUM(l_1,l_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 3;
|
|
break;
|
|
case HA_KEYTYPE_UINT24:
|
|
l_1=mi_uint3korr(a);
|
|
l_2=mi_uint3korr(b);
|
|
if (piks && (flag = CMP_NUM(l_1,l_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 3;
|
|
break;
|
|
case HA_KEYTYPE_FLOAT:
|
|
mi_float4get(f_1,a);
|
|
mi_float4get(f_2,b);
|
|
/*
|
|
The following may give a compiler warning about floating point
|
|
comparison not being safe, but this is ok in this context as
|
|
we are bascily doing sorting
|
|
*/
|
|
if (piks && (flag = CMP_NUM(f_1,f_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 4; /* sizeof(float); */
|
|
break;
|
|
case HA_KEYTYPE_DOUBLE:
|
|
mi_float8get(d_1,a);
|
|
mi_float8get(d_2,b);
|
|
/*
|
|
The following may give a compiler warning about floating point
|
|
comparison not being safe, but this is ok in this context as
|
|
we are bascily doing sorting
|
|
*/
|
|
if (piks && (flag = CMP_NUM(d_1,d_2)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 8; /* sizeof(double); */
|
|
break;
|
|
case HA_KEYTYPE_NUM: /* Numeric key */
|
|
{
|
|
int swap_flag= 0;
|
|
int alength,blength;
|
|
|
|
if (keyseg->flag & HA_REVERSE_SORT)
|
|
{
|
|
swap_variables(uchar*, a, b);
|
|
swap_flag=1; /* Remember swap of a & b */
|
|
end= a+ (int) (end-b);
|
|
}
|
|
if (keyseg->flag & HA_SPACE_PACK)
|
|
{
|
|
alength= *a++; blength= *b++;
|
|
end=a+alength;
|
|
next_key_length=key_length-blength-1;
|
|
}
|
|
else
|
|
{
|
|
alength= (int) (end-a);
|
|
blength=keyseg->length;
|
|
/* remove pre space from keys */
|
|
for ( ; alength && *a == ' ' ; a++, alength--) ;
|
|
for ( ; blength && *b == ' ' ; b++, blength--) ;
|
|
}
|
|
if (piks)
|
|
{
|
|
if (*a == '-')
|
|
{
|
|
if (*b != '-')
|
|
return -1;
|
|
a++; b++;
|
|
swap_variables(uchar*, a, b);
|
|
swap_variables(int, alength, blength);
|
|
swap_flag=1-swap_flag;
|
|
alength--; blength--;
|
|
end=a+alength;
|
|
}
|
|
else if (*b == '-')
|
|
return 1;
|
|
while (alength && (*a == '+' || *a == '0'))
|
|
{
|
|
a++; alength--;
|
|
}
|
|
while (blength && (*b == '+' || *b == '0'))
|
|
{
|
|
b++; blength--;
|
|
}
|
|
if (alength != blength)
|
|
return (alength < blength) ? -1 : 1;
|
|
while (a < end)
|
|
if (*a++ != *b++)
|
|
return ((int) a[-1] - (int) b[-1]);
|
|
}
|
|
else
|
|
{
|
|
b+=(end-a);
|
|
a=end;
|
|
}
|
|
|
|
if (swap_flag) /* Restore pointers */
|
|
swap_variables(uchar*, a, b);
|
|
break;
|
|
}
|
|
#ifdef HAVE_LONG_LONG
|
|
case HA_KEYTYPE_LONGLONG:
|
|
{
|
|
longlong ll_a,ll_b;
|
|
ll_a= mi_sint8korr(a);
|
|
ll_b= mi_sint8korr(b);
|
|
if (piks && (flag = CMP_NUM(ll_a,ll_b)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 8;
|
|
break;
|
|
}
|
|
case HA_KEYTYPE_ULONGLONG:
|
|
{
|
|
ulonglong ll_a,ll_b;
|
|
ll_a= mi_uint8korr(a);
|
|
ll_b= mi_uint8korr(b);
|
|
if (piks && (flag = CMP_NUM(ll_a,ll_b)))
|
|
return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
|
|
a= end;
|
|
b+= 8;
|
|
break;
|
|
}
|
|
#endif
|
|
case HA_KEYTYPE_END: /* Ready */
|
|
goto end; /* diff_pos is incremented */
|
|
}
|
|
}
|
|
(*diff_pos)++;
|
|
end:
|
|
if (!(nextflag & SEARCH_FIND))
|
|
{
|
|
uint i;
|
|
if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
|
|
return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
|
|
flag=0;
|
|
for (i=keyseg->length ; i-- > 0 ; )
|
|
{
|
|
if (*a++ != *b++)
|
|
{
|
|
flag= FCMP(a[-1],b[-1]);
|
|
break;
|
|
}
|
|
}
|
|
if (nextflag & SEARCH_SAME)
|
|
return (flag); /* read same */
|
|
if (nextflag & SEARCH_BIGGER)
|
|
return (flag <= 0 ? -1 : 1); /* read next */
|
|
return (flag < 0 ? -1 : 1); /* read previous */
|
|
}
|
|
return 0;
|
|
} /* ha_key_cmp */
|
|
|
|
|
|
/*
|
|
Find the first NULL value in index-suffix values tuple
|
|
|
|
SYNOPSIS
|
|
ha_find_null()
|
|
keyseg Array of keyparts for key suffix
|
|
a Key suffix value tuple
|
|
|
|
DESCRIPTION
|
|
Find the first NULL value in index-suffix values tuple.
|
|
|
|
TODO
|
|
Consider optimizing this function or its use so we don't search for
|
|
NULL values in completely NOT NULL index suffixes.
|
|
|
|
RETURN
|
|
First key part that has NULL as value in values tuple, or the last key
|
|
part (with keyseg->type==HA_TYPE_END) if values tuple doesn't contain
|
|
NULLs.
|
|
*/
|
|
|
|
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, uchar *a)
|
|
{
|
|
for (; (enum ha_base_keytype) keyseg->type != HA_KEYTYPE_END; keyseg++)
|
|
{
|
|
uchar *end;
|
|
if (keyseg->null_bit)
|
|
{
|
|
if (!*a++)
|
|
return keyseg;
|
|
}
|
|
end= a+ keyseg->length;
|
|
|
|
switch ((enum ha_base_keytype) keyseg->type) {
|
|
case HA_KEYTYPE_TEXT:
|
|
case HA_KEYTYPE_BINARY:
|
|
case HA_KEYTYPE_BIT:
|
|
if (keyseg->flag & HA_SPACE_PACK)
|
|
{
|
|
int a_length;
|
|
get_key_length(a_length, a);
|
|
a += a_length;
|
|
break;
|
|
}
|
|
else
|
|
a= end;
|
|
break;
|
|
case HA_KEYTYPE_VARTEXT1:
|
|
case HA_KEYTYPE_VARTEXT2:
|
|
case HA_KEYTYPE_VARBINARY1:
|
|
case HA_KEYTYPE_VARBINARY2:
|
|
{
|
|
int a_length;
|
|
get_key_length(a_length, a);
|
|
a+= a_length;
|
|
break;
|
|
}
|
|
case HA_KEYTYPE_NUM:
|
|
if (keyseg->flag & HA_SPACE_PACK)
|
|
{
|
|
int alength= *a++;
|
|
end= a+alength;
|
|
}
|
|
a= end;
|
|
break;
|
|
case HA_KEYTYPE_INT8:
|
|
case HA_KEYTYPE_SHORT_INT:
|
|
case HA_KEYTYPE_USHORT_INT:
|
|
case HA_KEYTYPE_LONG_INT:
|
|
case HA_KEYTYPE_ULONG_INT:
|
|
case HA_KEYTYPE_INT24:
|
|
case HA_KEYTYPE_UINT24:
|
|
#ifdef HAVE_LONG_LONG
|
|
case HA_KEYTYPE_LONGLONG:
|
|
case HA_KEYTYPE_ULONGLONG:
|
|
#endif
|
|
case HA_KEYTYPE_FLOAT:
|
|
case HA_KEYTYPE_DOUBLE:
|
|
a= end;
|
|
break;
|
|
case HA_KEYTYPE_END: /* purecov: inspected */
|
|
/* keep compiler happy */
|
|
DBUG_ASSERT(0);
|
|
break;
|
|
}
|
|
}
|
|
return keyseg;
|
|
}
|
|
|
|
|
|
/*
|
|
Errors a handler can give you
|
|
*/
|
|
|
|
static const char *handler_error_messages[]=
|
|
{
|
|
"Didn't find key on read or update",
|
|
"Duplicate key on write or update",
|
|
"Undefined handler error 122",
|
|
"Someone has changed the row since it was read (while the table was locked to prevent it)",
|
|
"Wrong index given to function",
|
|
"Undefined handler error 125",
|
|
"Index file is crashed",
|
|
"Record file is crashed",
|
|
"Out of memory in engine",
|
|
"Undefined handler error 129",
|
|
"Incorrect file format",
|
|
"Command not supported by database",
|
|
"Old database file",
|
|
"No record read before update",
|
|
"Record was already deleted (or record file crashed)",
|
|
"No more room in record file",
|
|
"No more room in index file",
|
|
"No more records (read after end of file)",
|
|
"Unsupported extension used for table",
|
|
"Too big row",
|
|
"Wrong create options",
|
|
"Duplicate unique key or constraint on write or update",
|
|
"Unknown character set used in table",
|
|
"Conflicting table definitions in sub-tables of MERGE table",
|
|
"Table is crashed and last repair failed",
|
|
"Table was marked as crashed and should be repaired",
|
|
"Lock timed out; Retry transaction",
|
|
"Lock table is full; Restart program with a larger locktable",
|
|
"Updates are not allowed under a read only transactions",
|
|
"Lock deadlock; Retry transaction",
|
|
"Foreign key constraint is incorrectly formed",
|
|
"Cannot add a child row",
|
|
"Cannot delete a parent row",
|
|
"Unknown handler error"
|
|
};
|
|
|
|
|
|
/*
|
|
Register handler error messages for usage with my_error()
|
|
|
|
NOTES
|
|
This is safe to call multiple times as my_error_register()
|
|
will ignore calls to register already registered error numbers.
|
|
*/
|
|
|
|
|
|
void my_handler_error_register(void)
|
|
{
|
|
my_error_register(handler_error_messages, HA_ERR_FIRST,
|
|
HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
|
|
}
|
|
|
|
|
|
void my_handler_error_unregister(void)
|
|
{
|
|
my_error_unregister(HA_ERR_FIRST,
|
|
HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
|
|
}
|