database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-18 23:03:28 +03:00
Code Activity

Update of query cache code.

Browse Source 
Changed some sql_alloc() -> thd->alloc()
Removed a lot of compiler warnings on Linux Alpha (64 bit)
Fixed some core dumps on 64 bit systems (wrong type for packet_len)


Docs/manual.texi:
  Added base information about the query cache.
include/hash.h:
  Export hash_replace
include/myisam.h:
  Update of query cache code
libmysql/net.c:
  Add casts to make things safe on 64 bit systems.
myisam/mi_write.c:
  Update of query cache code
myisammrg/myrg_extra.c:
  Update of query cache code
mysys/hash.c:
  Added safety check to hash_replace
sql/field.cc:
  Removed compiler warnings.
sql/field.h:
  Removed compiler warnings
sql/ha_myisam.cc:
  Fixed wrong type of packet_len
sql/item.h:
  Remove warnings
sql/log_event.cc:
  Cleanup
sql/log_event.h:
  Cleanup to make code more readable
sql/mf_iocache.cc:
  Fixed wrong type
sql/mysql_priv.h:
  Update of query cache code
sql/mysqld.cc:
  Update of query cache code
sql/net_serv.cc:
  Remove compiler warnings
sql/opt_range.h:
  Remove compiler warnings
sql/sql_cache.cc:
  Update of query cache code
sql/sql_cache.h:
  Update of query cache code
sql/sql_class.h:
  Cleanup
sql/sql_insert.cc:
  Use thd->alloc() instead of sql_alloc()
sql/sql_parse.cc:
  Fixed compiler warnings.
  Changed some sql_alloc() -> thd->alloc()
sql/sql_select.cc:
  Changed sql_alloc() -> thd_alloc()
sql/sql_select.h:
  Faster alloc()
sql/sql_show.cc:
  Update of query cache code
sql/sql_table.cc:
  Faster alloc()
sql/table.cc:
  Faster alloc()
This commit is contained in:
unknown
2001-12-05 13:03:00 +02:00
parent 7c999bb032
commit eca2a1a3dc
28 changed files with 2208 additions and 1953 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
Docs/manual.texi
View File

@ -18100,6 +18100,9 @@ differ somewhat:
| protocol_version | 10 | | protocol_version | 10 |
| record_buffer | 131072 | | record_buffer | 131072 |
| query_buffer_size | 0 | | query_buffer_size | 0 |
| query_cache_limit | 1048576 |
| query_cache_size | 16768060 |
| query_cache_startup_type | 1 |
| safe_show_database | OFF | | safe_show_database | OFF |
| server_id | 0 | | server_id | 0 |
| skip_locking | ON | | skip_locking | ON |
@ -18497,6 +18500,18 @@ buffer to avoid a disk seeks. If not set, then it's set to the value of
The initial allocation of the query buffer. If most of your queries are The initial allocation of the query buffer. If most of your queries are
long (like when inserting blobs), you should increase this! long (like when inserting blobs), you should increase this!
@item @code{query_cache_limit}
Don't cache results that are bigger than this. (Default 1M).
@item @code{query_cache_size}
The memory allocated to store results from old queries. If this is zero
the query cache is disabled.
@item @code{query_cache_startup_type}
This may have be set to 0 (cache results but don't retrieve results from
cache), 1 (cache results by defaults) or 2 (only cache @code{SELECT}'s marked
with @code{SQL_CACHE}).
@item @code{safe_show_databases} @item @code{safe_show_databases}
Don't show databases for which the user doesn't have any database or Don't show databases for which the user doesn't have any database or
table privileges. This can improve security if you're concerned about table privileges. This can improve security if you're concerned about
@ -25730,6 +25745,17 @@ flag again, the @code{SQL_MAX_JOIN_SIZE} variable will be ignored.
You can set a default value for this variable by starting @code{mysqld} with You can set a default value for this variable by starting @code{mysqld} with
@code{-O max_join_size=#}. @code{-O max_join_size=#}.
@item SQL_QUERY_CACHE_TYPE = [OFF | ON | DEMAND]
@item SQL_QUERY_CACHE_TYPE = [0 | 1 | 2]
The numbers are standing for the correspoding verbose option.
@multitable @columnfractions .3 .7
@item 0 or OFF @tab Cache @code{SELECT} results, but don't retrieve results from cache.
@item 1 or ON @tab Cache all @code{SELECT}'s that are not marked with @code{SQL_NO_CACHE}.
@item 2 or DEMAND @tab Cache only @code{SELECT SQL_CACHE}) queries.
@end multitable
@item SQL_SAFE_UPDATES = 0 | 1 @item SQL_SAFE_UPDATES = 0 | 1
If set to @code{1}, MySQL will abort if an @code{UPDATE} or If set to @code{1}, MySQL will abort if an @code{UPDATE} or
@code{DELETE} is attempted that doesn't use a key or @code{LIMIT} in the @code{DELETE} is attempted that doesn't use a key or @code{LIMIT} in the
@ -31085,7 +31111,7 @@ mysql> SELECT id,FLOOR(value/100) FROM tbl_name ORDER BY RAND();
@c help SELECT @c help SELECT
@example @example
SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT] SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
[HIGH_PRIORITY] [SQL_CACHE | SQL_NO_CACHE] [HIGH_PRIORITY]
[DISTINCT | DISTINCTROW | ALL] [DISTINCT | DISTINCTROW | ALL]
select_expression,... select_expression,...
[INTO @{OUTFILE | DUMPFILE@} 'file_name' export_options] [INTO @{OUTFILE | DUMPFILE@} 'file_name' export_options]
@ -31213,9 +31239,8 @@ mysql> select user,max(salary) AS sum from users
@end example @end example
@item @item
@code{SQL_SMALL_RESULT}, @code{SQL_BIG_RESULT}, @code{SQL_BUFFER_RESULT}, All options beginning with @code{SQL_}, @code{STRAIGHT_JOIN}, and
@code{STRAIGHT_JOIN}, and @code{HIGH_PRIORITY} are MySQL extensions @code{HIGH_PRIORITY} are MySQL extensions to ANSI SQL.
to ANSI SQL92.
@item @item
@code{HIGH_PRIORITY} will give the @code{SELECT} higher priority than @code{HIGH_PRIORITY} will give the @code{SELECT} higher priority than
@ -31243,6 +31268,14 @@ result set will be small. In this case, MySQL will use fast
temporary tables to store the resulting table instead of using sorting. In temporary tables to store the resulting table instead of using sorting. In
MySQL Version 3.23 this shouldn't normally be needed. MySQL Version 3.23 this shouldn't normally be needed.
@item
@code{SQL_CACHE} tells MySQL to store the query result in the query cache
even if you are using @code{SQL_QUERY_CACHE_METHOD} 2 (= @code{DEMAND}).
@item
@code{SQL_NO_CACHE} tells MySL to not store the query result in the
query cache.
@item @item
@cindex @code{GROUP BY}, extensions to ANSI SQL @cindex @code{GROUP BY}, extensions to ANSI SQL
If you use @code{GROUP BY}, the output rows will be sorted according to the If you use @code{GROUP BY}, the output rows will be sorted according to the
@ -46164,6 +46197,11 @@ Our TODO section contains what we plan to have in 4.0. @xref{TODO MySQL 4.0}.
@itemize @bullet @itemize @bullet
@item @item
A new query cache to cache results from identical @code{SELECT} queries.
@item
Fixed core dump bug on 64 bit machines when it got a wrong communication
packet.
@item
@code{MATCH ... AGAINST(... IN BOOLEAN MODE)} can now work @code{MATCH ... AGAINST(... IN BOOLEAN MODE)} can now work
without @code{FULLTEXT} index. without @code{FULLTEXT} index.
@item @item

1
include/hash.h
View File

@ -54,6 +54,7 @@ gptr hash_next(HASH *info,const byte *key,uint length);
my_bool hash_insert(HASH *info,const byte *data); my_bool hash_insert(HASH *info,const byte *data);
my_bool hash_delete(HASH *hash,byte *record); my_bool hash_delete(HASH *hash,byte *record);
my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length); my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length);
void hash_replace(HASH *hash, uint idx, byte *new_row);
my_bool hash_check(HASH *hash); /* Only in debug library */ my_bool hash_check(HASH *hash); /* Only in debug library */
#define hash_clear(H) bzero((char*) (H),sizeof(*(H))) #define hash_clear(H) bzero((char*) (H),sizeof(*(H)))

2
include/myisam.h
View File

@ -192,7 +192,7 @@ typedef struct st_columndef /* column information */
} MI_COLUMNDEF; } MI_COLUMNDEF;
/* invalidator function reference for Query Cache */ /* invalidator function reference for Query Cache */
typedef void (* invalidator_by_filename) (char * filename); typedef void (* invalidator_by_filename)(const char * filename);
extern my_string myisam_log_filename; /* Name of logfile */ extern my_string myisam_log_filename; /* Name of logfile */
extern uint myisam_block_size; extern uint myisam_block_size;

42
libmysql/net.c
View File

@ -94,6 +94,7 @@ inline int local_thr_alarm(my_bool *A,int B __attribute__((unused)),ALARM *C __a
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
extern ulong bytes_sent, bytes_received; extern ulong bytes_sent, bytes_received;
extern pthread_mutex_t LOCK_bytes_sent , LOCK_bytes_received; extern pthread_mutex_t LOCK_bytes_sent , LOCK_bytes_received;
extern void query_cache_insert(NET *net, const char *packet, ulong length);
#else #else
#undef statistic_add #undef statistic_add
#define statistic_add(A,B,C) #define statistic_add(A,B,C)
@ -108,7 +109,7 @@ static int net_write_buff(NET *net,const char *packet,ulong len);
int my_net_init(NET *net, Vio* vio) int my_net_init(NET *net, Vio* vio)
{ {
if (!(net->buff=(uchar*) my_malloc(net_buffer_length+ if (!(net->buff=(uchar*) my_malloc((uint32) net_buffer_length+
NET_HEADER_SIZE + COMP_HEADER_SIZE, NET_HEADER_SIZE + COMP_HEADER_SIZE,
MYF(MY_WME)))) MYF(MY_WME))))
return 1; return 1;
@ -125,6 +126,7 @@ int my_net_init(NET *net, Vio* vio)
net->compress=0; net->reading_or_writing=0; net->compress=0; net->reading_or_writing=0;
net->where_b = net->remain_in_buf=0; net->where_b = net->remain_in_buf=0;
net->last_errno=0; net->last_errno=0;
net->query_cache_query=0;
if (vio != 0) /* If real connection */ if (vio != 0) /* If real connection */
{ {
@ -160,7 +162,7 @@ static my_bool net_realloc(NET *net, ulong length)
pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1); pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1);
/* We must allocate some extra bytes for the end 0 and to be able to /* We must allocate some extra bytes for the end 0 and to be able to
read big compressed blocks */ read big compressed blocks */
if (!(buff=(uchar*) my_realloc((char*) net->buff, pkt_length + if (!(buff=(uchar*) my_realloc((char*) net->buff, (uint32) pkt_length +
NET_HEADER_SIZE + COMP_HEADER_SIZE, NET_HEADER_SIZE + COMP_HEADER_SIZE,
MYF(MY_WME)))) MYF(MY_WME))))
{ {
@ -187,7 +189,7 @@ void net_clear(NET *net)
if (!vio_is_blocking(net->vio)) /* Safety if SSL */ if (!vio_is_blocking(net->vio)) /* Safety if SSL */
{ {
while ( (count = vio_read(net->vio, (char*) (net->buff), while ( (count = vio_read(net->vio, (char*) (net->buff),
net->max_packet)) > 0) (uint32) net->max_packet)) > 0)
DBUG_PRINT("info",("skipped %d bytes from file: %s", DBUG_PRINT("info",("skipped %d bytes from file: %s",
count,vio_description(net->vio))); count,vio_description(net->vio)));
if (is_blocking) if (is_blocking)
@ -241,7 +243,7 @@ my_net_write(NET *net,const char *packet,ulong len)
{ {
const ulong z_size = MAX_THREE_BYTES; const ulong z_size = MAX_THREE_BYTES;
int3store(buff, z_size); int3store(buff, z_size);
buff[3]= net->pkt_nr++; buff[3]= (uchar) net->pkt_nr++;
if (net_write_buff(net, (char*) buff, NET_HEADER_SIZE) || if (net_write_buff(net, (char*) buff, NET_HEADER_SIZE) ||
net_write_buff(net, packet, z_size)) net_write_buff(net, packet, z_size))
return 1; return 1;
@ -250,7 +252,7 @@ my_net_write(NET *net,const char *packet,ulong len)
} }
/* Write last packet */ /* Write last packet */
int3store(buff,len); int3store(buff,len);
buff[3]= net->pkt_nr++; buff[3]= (uchar) net->pkt_nr++;
if (net_write_buff(net,(char*) buff,NET_HEADER_SIZE)) if (net_write_buff(net,(char*) buff,NET_HEADER_SIZE))
return 1; return 1;
return net_write_buff(net,packet,len); return net_write_buff(net,packet,len);
@ -280,7 +282,7 @@ net_write_command(NET *net,uchar command,const char *packet,ulong len)
do do
{ {
int3store(buff, MAX_THREE_BYTES); int3store(buff, MAX_THREE_BYTES);
buff[3]= net->pkt_nr++; buff[3]= (uchar) net->pkt_nr++;
if (net_write_buff(net,(char*) buff, header_size) || if (net_write_buff(net,(char*) buff, header_size) ||
net_write_buff(net,packet,len)) net_write_buff(net,packet,len))
return 1; return 1;
@ -292,7 +294,7 @@ net_write_command(NET *net,uchar command,const char *packet,ulong len)
len=length; /* Data left to be written */ len=length; /* Data left to be written */
} }
int3store(buff,length); int3store(buff,length);
buff[3]= net->pkt_nr++; buff[3]= (uchar) net->pkt_nr++;
return test(net_write_buff(net,(char*) buff,header_size) || return test(net_write_buff(net,(char*) buff,header_size) ||
net_write_buff(net,packet,len) || net_flush(net)); net_write_buff(net,packet,len) || net_flush(net));
} }
@ -341,6 +343,10 @@ net_real_write(NET *net,const char *packet,ulong len)
my_bool net_blocking = vio_is_blocking(net->vio); my_bool net_blocking = vio_is_blocking(net->vio);
DBUG_ENTER("net_real_write"); DBUG_ENTER("net_real_write");
#ifdef MYSQL_SERVER
query_cache_insert(net, packet, len);
#endif
if (net->error == 2) if (net->error == 2)
DBUG_RETURN(-1); /* socket can't be used */ DBUG_RETURN(-1); /* socket can't be used */
@ -351,8 +357,8 @@ net_real_write(NET *net,const char *packet,ulong len)
ulong complen; ulong complen;
uchar *b; uchar *b;
uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE; uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
if (!(b=(uchar*) my_malloc(len + NET_HEADER_SIZE + COMP_HEADER_SIZE, if (!(b=(uchar*) my_malloc((uint32) len + NET_HEADER_SIZE +
MYF(MY_WME)))) COMP_HEADER_SIZE, MYF(MY_WME))))
{ {
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
net->last_errno=ER_OUT_OF_RESOURCES; net->last_errno=ER_OUT_OF_RESOURCES;
@ -389,7 +395,7 @@ net_real_write(NET *net,const char *packet,ulong len)
pos=(char*) packet; end=pos+len; pos=(char*) packet; end=pos+len;
while (pos != end) while (pos != end)
{ {
if ((long) (length=vio_write(net->vio,pos,(ulong) (end-pos))) <= 0) if ((long) (length=vio_write(net->vio,pos,(uint32) (end-pos))) <= 0)
{ {
my_bool interrupted = vio_should_retry(net->vio); my_bool interrupted = vio_should_retry(net->vio);
#if (!defined(__WIN__) && !defined(__EMX__) && !defined(OS2)) #if (!defined(__WIN__) && !defined(__EMX__) && !defined(OS2))
@ -473,7 +479,7 @@ net_real_write(NET *net,const char *packet,ulong len)
big packet big packet
*/ */
static void my_net_skip_rest(NET *net, ulong remain, thr_alarm_t *alarmed) static void my_net_skip_rest(NET *net, uint32 remain, thr_alarm_t *alarmed)
{ {
ALARM alarm_buff; ALARM alarm_buff;
uint retry_count=0; uint retry_count=0;
@ -496,7 +502,7 @@ static void my_net_skip_rest(NET *net, ulong remain, thr_alarm_t *alarmed)
} }
return; return;
} }
remain -= length; remain -= (uint32) length;
statistic_add(bytes_received,length,&LOCK_bytes_received); statistic_add(bytes_received,length,&LOCK_bytes_received);
} }
} }
@ -521,8 +527,8 @@ my_real_read(NET *net, ulong *complen)
ALARM alarm_buff; ALARM alarm_buff;
#endif #endif
my_bool net_blocking=vio_is_blocking(net->vio); my_bool net_blocking=vio_is_blocking(net->vio);
ulong remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE : uint32 remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
NET_HEADER_SIZE); NET_HEADER_SIZE);
*complen = 0; *complen = 0;
net->reading_or_writing=1; net->reading_or_writing=1;
@ -599,7 +605,7 @@ my_real_read(NET *net, ulong *complen)
continue; continue;
} }
#endif #endif
DBUG_PRINT("error",("Couldn't read packet: remain: %d errno: %d length: %d alarmed: %d", remain,vio_errno(net->vio),length,alarmed)); DBUG_PRINT("error",("Couldn't read packet: remain: %lu errno: %d length: %ld alarmed: %d", remain,vio_errno(net->vio),length,alarmed));
len= packet_error; len= packet_error;
net->error=2; /* Close socket */ net->error=2; /* Close socket */
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
@ -608,7 +614,7 @@ my_real_read(NET *net, ulong *complen)
#endif #endif
goto end; goto end;
} }
remain -= (ulong) length; remain -= (uint32) length;
pos+= (ulong) length; pos+= (ulong) length;
statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received); statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received);
} }
@ -655,14 +661,14 @@ my_real_read(NET *net, ulong *complen)
{ {
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
if (i == 1) if (i == 1)
my_net_skip_rest(net, len, &alarmed); my_net_skip_rest(net, (uint32) len, &alarmed);
#endif #endif
len= packet_error; /* Return error */ len= packet_error; /* Return error */
goto end; goto end;
} }
} }
pos=net->buff + net->where_b; pos=net->buff + net->where_b;
remain = len; remain = (uint32) len;
} }
} }

6
myisam/mi_write.c
View File

@ -149,6 +149,12 @@ int mi_write(MI_INFO *info, byte *record)
info->lastpos=filepos; info->lastpos=filepos;
myisam_log_record(MI_LOG_WRITE,info,record,filepos,0); myisam_log_record(MI_LOG_WRITE,info,record,filepos,0);
VOID(_mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE)); VOID(_mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE));
if (info->invalidator != 0)
{
DBUG_PRINT("info", ("invalidator... '%s' (update)", info->filename));
(*info->invalidator)(info->filename);
info->invalidator=0;
}
allow_break(); /* Allow SIGHUP & SIGINT */ allow_break(); /* Allow SIGHUP & SIGINT */
DBUG_RETURN(0); DBUG_RETURN(0);

3
myisammrg/myrg_extra.c
View File

@ -50,9 +50,10 @@ int myrg_extra(MYRG_INFO *info,enum ha_extra_function function)
void myrg_extrafunc(MYRG_INFO *info, invalidator_by_filename inv) void myrg_extrafunc(MYRG_INFO *info, invalidator_by_filename inv)
{ {
MYRG_TABLE *file; MYRG_TABLE *file;
DBUG_ENTER("myrg_extrafunc"); DBUG_ENTER("myrg_extrafunc");
for (file=info->open_tables ; file != info->end_table ; file++) for (file=info->open_tables ; file != info->end_table ; file++)
file->table->s->invalidator = inv; file->table->s->invalidator = inv;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }

3
mysys/hash.c
View File

@ -583,7 +583,8 @@ byte *hash_element(HASH *hash,uint idx)
void hash_replace(HASH *hash, uint idx, byte *new_row) void hash_replace(HASH *hash, uint idx, byte *new_row)
{ {
dynamic_element(&hash->array,idx,HASH_LINK*)->data=new_row; if (idx != NO_RECORD) /* Safety */
dynamic_element(&hash->array,idx,HASH_LINK*)->data=new_row;
} }

235
sql/field.cc
View File

@ -219,14 +219,15 @@ static bool test_if_real(const char *str,int length)
****************************************************************************/ ****************************************************************************/
Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg, Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
utype unireg_check_arg, const char *field_name_arg, utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg) struct st_table *table_arg)
:ptr(ptr_arg),null_ptr(null_ptr_arg),null_bit(null_bit_arg), :ptr(ptr_arg),null_ptr(null_ptr_arg),
table(table_arg),query_id(0),key_start(0),part_of_key(0),part_of_sortkey(0), table(table_arg),table_name(table_arg ? table_arg->table_name : 0),
table_name(table_arg ? table_arg->table_name : 0), field_name(field_name_arg),
field_name(field_name_arg), unireg_check(unireg_check_arg), query_id(0),key_start(0),part_of_key(0),part_of_sortkey(0),
field_length(length_arg) unireg_check(unireg_check_arg),
field_length(length_arg),null_bit(null_bit_arg)
{ {
flags=null_ptr ? 0: NOT_NULL_FLAG; flags=null_ptr ? 0: NOT_NULL_FLAG;
} }
@ -242,8 +243,8 @@ void Field::copy_from_tmp(int row_offset)
memcpy(ptr,ptr+row_offset,pack_length()); memcpy(ptr,ptr+row_offset,pack_length());
if (null_ptr) if (null_ptr)
{ {
*null_ptr= ((null_ptr[0] & (uchar) ~(uint) null_bit) | *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) |
null_ptr[row_offset] & (uchar) null_bit); null_ptr[row_offset] & (uchar) null_bit);
} }
} }
@ -1049,7 +1050,7 @@ void Field_short::sort_string(char *to,uint length __attribute__((unused)))
if (unsigned_flag) if (unsigned_flag)
to[0] = ptr[0]; to[0] = ptr[0];
else else
to[0] = ptr[0] ^ 128; /* Revers signbit */ to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
to[1] = ptr[1]; to[1] = ptr[1];
} }
else else
@ -1058,7 +1059,7 @@ void Field_short::sort_string(char *to,uint length __attribute__((unused)))
if (unsigned_flag) if (unsigned_flag)
to[0] = ptr[1]; to[0] = ptr[1];
else else
to[0] = ptr[1] ^ 128; /* Revers signbit */ to[0] = (char) (ptr[1] ^ 128); /* Revers signbit */
to[1] = ptr[0]; to[1] = ptr[0];
} }
} }
@ -1129,12 +1130,12 @@ void Field_medium::store(double nr)
} }
else if (nr >= (double) (long) (1L << 24)) else if (nr >= (double) (long) (1L << 24))
{ {
ulong tmp=(ulong) (1L << 24)-1L; uint32 tmp=(uint32) (1L << 24)-1L;
int3store(ptr,tmp); int3store(ptr,tmp);
current_thd->cuted_fields++; current_thd->cuted_fields++;
} }
else else
int3store(ptr,(ulong) nr); int3store(ptr,(uint32) nr);
} }
else else
{ {
@ -1171,7 +1172,7 @@ void Field_medium::store(longlong nr)
current_thd->cuted_fields++; current_thd->cuted_fields++;
} }
else else
int3store(ptr,(ulong) nr); int3store(ptr,(uint32) nr);
} }
else else
{ {
@ -1449,7 +1450,7 @@ int Field_long::cmp(const char *a_ptr, const char *b_ptr)
longget(b,b_ptr); longget(b,b_ptr);
} }
if (unsigned_flag) if (unsigned_flag)
return ((ulong) a < (ulong) b) ? -1 : ((ulong) a > (ulong) b) ? 1 : 0; return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
return (a < b) ? -1 : (a > b) ? 1 : 0; return (a < b) ? -1 : (a > b) ? 1 : 0;
} }
@ -1461,7 +1462,7 @@ void Field_long::sort_string(char *to,uint length __attribute__((unused)))
if (unsigned_flag) if (unsigned_flag)
to[0] = ptr[0]; to[0] = ptr[0];
else else
to[0] = ptr[0] ^ 128; /* Revers signbit */ to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
to[1] = ptr[1]; to[1] = ptr[1];
to[2] = ptr[2]; to[2] = ptr[2];
to[3] = ptr[3]; to[3] = ptr[3];
@ -1472,7 +1473,7 @@ void Field_long::sort_string(char *to,uint length __attribute__((unused)))
if (unsigned_flag) if (unsigned_flag)
to[0] = ptr[3]; to[0] = ptr[3];
else else
to[0] = ptr[3] ^ 128; /* Revers signbit */ to[0] = (char) (ptr[3] ^ 128); /* Revers signbit */
to[1] = ptr[2]; to[1] = ptr[2];
to[2] = ptr[1]; to[2] = ptr[1];
to[3] = ptr[0]; to[3] = ptr[0];
@ -1660,7 +1661,7 @@ void Field_longlong::sort_string(char *to,uint length __attribute__((unused)))
if (unsigned_flag) if (unsigned_flag)
to[0] = ptr[0]; to[0] = ptr[0];
else else
to[0] = ptr[0] ^ 128; /* Revers signbit */ to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
to[1] = ptr[1]; to[1] = ptr[1];
to[2] = ptr[2]; to[2] = ptr[2];
to[3] = ptr[3]; to[3] = ptr[3];
@ -1675,7 +1676,7 @@ void Field_longlong::sort_string(char *to,uint length __attribute__((unused)))
if (unsigned_flag) if (unsigned_flag)
to[0] = ptr[7]; to[0] = ptr[7];
else else
to[0] = ptr[7] ^ 128; /* Revers signbit */ to[0] = (char) (ptr[7] ^ 128); /* Revers signbit */
to[1] = ptr[6]; to[1] = ptr[6];
to[2] = ptr[5]; to[2] = ptr[5];
to[3] = ptr[4]; to[3] = ptr[4];
@ -1910,7 +1911,7 @@ void Field_float::sort_string(char *to,uint length __attribute__((unused)))
{ /* make complement */ { /* make complement */
uint i; uint i;
for (i=0 ; i < sizeof(nr); i++) for (i=0 ; i < sizeof(nr); i++)
tmp[i]=tmp[i] ^ (uchar) 255; tmp[i]= (uchar) (tmp[i] ^ (uchar) 255);
} }
else else
{ {
@ -2278,10 +2279,10 @@ void Field_timestamp::store(longlong nr)
{ {
part1=(long) (nr/LL(1000000)); part1=(long) (nr/LL(1000000));
part2=(long) (nr - (longlong) part1*LL(1000000)); part2=(long) (nr - (longlong) part1*LL(1000000));
l_time.year= part1/10000L; part1%=10000L; l_time.year= (int) (part1/10000L); part1%=10000L;
l_time.month= (int) part1 / 100; l_time.month= (int) part1 / 100;
l_time.day= (int) part1 % 100; l_time.day= (int) part1 % 100;
l_time.hour= part2/10000L; part2%=10000L; l_time.hour= (int) (part2/10000L); part2%=10000L;
l_time.minute=(int) part2 / 100; l_time.minute=(int) part2 / 100;
l_time.second=(int) part2 % 100; l_time.second=(int) part2 % 100;
timestamp=my_gmt_sec(&l_time); timestamp=my_gmt_sec(&l_time);
@ -2295,7 +2296,7 @@ void Field_timestamp::store(longlong nr)
} }
else else
#endif #endif
longstore(ptr,(ulong)timestamp); longstore(ptr,(uint32) timestamp);
} }
@ -2596,7 +2597,7 @@ void Field_time::store(longlong nr)
double Field_time::val_real(void) double Field_time::val_real(void)
{ {
ulong j= (ulong) uint3korr(ptr); uint32 j= (uint32) uint3korr(ptr);
return (double) j; return (double) j;
} }
@ -2632,19 +2633,19 @@ bool Field_time::get_time(TIME *ltime)
ltime->neg= 1; ltime->neg= 1;
tmp=-tmp; tmp=-tmp;
} }
ltime->hour=tmp/10000; ltime->hour= (int) (tmp/10000);
tmp-=ltime->hour*10000; tmp-=ltime->hour*10000;
ltime->minute= tmp/100; ltime->minute= (int) tmp/100;
ltime->second= tmp % 100; ltime->second= (int) tmp % 100;
ltime->second_part=0; ltime->second_part=0;
return 0; return 0;
} }
int Field_time::cmp(const char *a_ptr, const char *b_ptr) int Field_time::cmp(const char *a_ptr, const char *b_ptr)
{ {
long a,b; int32 a,b;
a=(long) sint3korr(a_ptr); a=(int32) sint3korr(a_ptr);
b=(long) sint3korr(b_ptr); b=(int32) sint3korr(b_ptr);
return (a < b) ? -1 : (a > b) ? 1 : 0; return (a < b) ? -1 : (a > b) ? 1 : 0;
} }
@ -2755,14 +2756,14 @@ void Field_year::sql_type(String &res) const
** Stored as a 4 byte unsigned int ** Stored as a 4 byte unsigned int
****************************************************************************/ ****************************************************************************/
void Field_date::store(const char *from,uint len) void Field_date::store(const char *from, uint len)
{ {
TIME l_time; TIME l_time;
ulong tmp; uint32 tmp;
if (str_to_TIME(from,len,&l_time,1) == TIMESTAMP_NONE) if (str_to_TIME(from,len,&l_time,1) == TIMESTAMP_NONE)
tmp=0; tmp=0;
else else
tmp=(ulong) l_time.year*10000L + (ulong) (l_time.month*100+l_time.day); tmp=(uint32) l_time.year*10000L + (uint32) (l_time.month*100+l_time.day);
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
if (table->db_low_byte_first) if (table->db_low_byte_first)
{ {
@ -2934,7 +2935,7 @@ void Field_newdate::store(double nr)
void Field_newdate::store(longlong nr) void Field_newdate::store(longlong nr)
{ {
long tmp; int32 tmp;
if (nr >= LL(100000000) && nr <= LL(99991231235959)) if (nr >= LL(100000000) && nr <= LL(99991231235959))
nr=nr/LL(1000000); // Timestamp to date nr=nr/LL(1000000); // Timestamp to date
if (nr < 0L || nr > 99991231L) if (nr < 0L || nr > 99991231L)
@ -2944,16 +2945,16 @@ void Field_newdate::store(longlong nr)
} }
else else
{ {
tmp=(long) nr; tmp=(int32) nr;
if (tmp) if (tmp)
{ {
if (tmp < YY_PART_YEAR*10000L) // Fix short dates if (tmp < YY_PART_YEAR*10000L) // Fix short dates
tmp+=20000000L; tmp+= (uint32) 20000000L;
else if (tmp < 999999L) else if (tmp < 999999L)
tmp+=19000000L; tmp+= (uint32) 19000000L;
} }
uint month=((tmp/100) % 100); uint month= (uint) ((tmp/100) % 100);
uint day= tmp%100; uint day= (uint) (tmp%100);
if (month > 12 || day > 31) if (month > 12 || day > 31)
{ {
tmp=0L; // Don't allow date to change tmp=0L; // Don't allow date to change
@ -2962,7 +2963,7 @@ void Field_newdate::store(longlong nr)
else else
tmp= day + month*32 + (tmp/10000)*16*32; tmp= day + month*32 + (tmp/10000)*16*32;
} }
int3store(ptr,tmp); int3store(ptr,(int32) tmp);
} }
void Field_newdate::store_time(TIME *ltime,timestamp_type type) void Field_newdate::store_time(TIME *ltime,timestamp_type type)
@ -2987,7 +2988,7 @@ double Field_newdate::val_real(void)
longlong Field_newdate::val_int(void) longlong Field_newdate::val_int(void)
{ {
ulong j=uint3korr(ptr); ulong j= uint3korr(ptr);
j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L; j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
return (longlong) j; return (longlong) j;
} }
@ -2997,25 +2998,25 @@ String *Field_newdate::val_str(String *val_buffer,
{ {
val_buffer->alloc(field_length); val_buffer->alloc(field_length);
val_buffer->length(field_length); val_buffer->length(field_length);
ulong tmp=(ulong) uint3korr(ptr); uint32 tmp=(uint32) uint3korr(ptr);
int part; int part;
char *pos=(char*) val_buffer->ptr()+10; char *pos=(char*) val_buffer->ptr()+10;
/* Open coded to get more speed */ /* Open coded to get more speed */
*pos--=0; *pos--=0; // End NULL
part=(int) (tmp & 31); part=(int) (tmp & 31);
*pos--='0'+part%10; *pos--= (char) ('0'+part%10);
*pos--='0'+part/10; *pos--= (char) ('0'+part/10);
*pos--='-'; *pos--= '-';
part=(int) (tmp >> 5 & 15); part=(int) (tmp >> 5 & 15);
*pos--='0'+part%10; *pos--= (char) ('0'+part%10);
*pos--='0'+part/10; *pos--= (char) ('0'+part/10);
*pos--='-'; *pos--= '-';
part=(int) (tmp >> 9); part=(int) (tmp >> 9);
*pos--='0'+part%10; part/=10; *pos--= (char) ('0'+part%10); part/=10;
*pos--='0'+part%10; part/=10; *pos--= (char) ('0'+part%10); part/=10;
*pos--='0'+part%10; part/=10; *pos--= (char) ('0'+part%10); part/=10;
*pos='0'+part; *pos= (char) ('0'+part);
return val_buffer; return val_buffer;
} }
@ -3023,7 +3024,7 @@ bool Field_newdate::get_date(TIME *ltime,bool fuzzydate)
{ {
if (is_null()) if (is_null())
return 1; return 1;
ulong tmp=(ulong) uint3korr(ptr); uint32 tmp=(uint32) uint3korr(ptr);
bzero((char*) ltime,sizeof(*ltime)); bzero((char*) ltime,sizeof(*ltime));
ltime->day= tmp & 31; ltime->day= tmp & 31;
ltime->month= (tmp >> 5) & 15; ltime->month= (tmp >> 5) & 15;
@ -3039,9 +3040,9 @@ bool Field_newdate::get_time(TIME *ltime)
int Field_newdate::cmp(const char *a_ptr, const char *b_ptr) int Field_newdate::cmp(const char *a_ptr, const char *b_ptr)
{ {
ulong a,b; uint32 a,b;
a=(ulong) uint3korr(a_ptr); a=(uint32) uint3korr(a_ptr);
b=(ulong) uint3korr(b_ptr); b=(uint32) uint3korr(b_ptr);
return (a < b) ? -1 : (a > b) ? 1 : 0; return (a < b) ? -1 : (a > b) ? 1 : 0;
} }
@ -3175,44 +3176,44 @@ String *Field_datetime::val_str(String *val_buffer,
pos=(char*) val_buffer->ptr()+19; pos=(char*) val_buffer->ptr()+19;
*pos--=0; *pos--=0;
*pos--='0'+(char) (part2%10); part2/=10; *pos--= (char) ('0'+(char) (part2%10)); part2/=10;
*pos--='0'+(char) (part2%10); part3= (int) (part2 / 10); *pos--= (char) ('0'+(char) (part2%10)); part3= (int) (part2 / 10);
*pos--=':'; *pos--= ':';
*pos--='0'+(char) (part3%10); part3/=10; *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
*pos--='0'+(char) (part3%10); part3/=10; *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
*pos--=':'; *pos--= ':';
*pos--='0'+(char) (part3%10); part3/=10; *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
*pos--='0'+(char) part3; *pos--= (char) ('0'+(char) part3);
*pos--=' '; *pos--= ' ';
*pos--='0'+(char) (part1%10); part1/=10; *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
*pos--='0'+(char) (part1%10); part1/=10; *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
*pos--='-'; *pos--= '-';
*pos--='0'+(char) (part1%10); part1/=10; *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
*pos--='0'+(char) (part1%10); part3= (int) (part1/10); *pos--= (char) ('0'+(char) (part1%10)); part3= (int) (part1/10);
*pos--='-'; *pos--= '-';
*pos--='0'+(char) (part3%10); part3/=10; *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
*pos--='0'+(char) (part3%10); part3/=10; *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
*pos--='0'+(char) (part3%10); part3/=10; *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
*pos='0'+(char) part3; *pos=(char) ('0'+(char) part3);
return val_buffer; return val_buffer;
} }
bool Field_datetime::get_date(TIME *ltime,bool fuzzydate) bool Field_datetime::get_date(TIME *ltime,bool fuzzydate)
{ {
longlong tmp=Field_datetime::val_int(); longlong tmp=Field_datetime::val_int();
long part1,part2; uint32 part1,part2;
part1=(long) (tmp/LL(1000000)); part1=(uint32) (tmp/LL(1000000));
part2=(long) (tmp - (ulonglong) part1*LL(1000000)); part2=(uint32) (tmp - (ulonglong) part1*LL(1000000));
ltime->time_type= TIMESTAMP_FULL; ltime->time_type= TIMESTAMP_FULL;
ltime->neg=0; ltime->neg= 0;
ltime->second_part=0; ltime->second_part= 0;
ltime->second= part2%100; ltime->second= (int) (part2%100);
ltime->minute= part2/100%100; ltime->minute= (int) (part2/100%100);
ltime->hour= part2/10000; ltime->hour= (int) (part2/10000);
ltime->day= part1%100; ltime->day= (int) (part1%100);
ltime->month= part1/100%100; ltime->month= (int) (part1/100%100);
ltime->year= part1/10000; ltime->year= (int) (part1/10000);
return (!fuzzydate && (!ltime->month || !ltime->day)) ? 1 : 0; return (!fuzzydate && (!ltime->month || !ltime->day)) ? 1 : 0;
} }
@ -3331,7 +3332,7 @@ void Field_string::store(longlong nr)
{ {
char buff[22]; char buff[22];
char *end=longlong10_to_str(nr,buff,-10); char *end=longlong10_to_str(nr,buff,-10);
Field_string::store(buff,end-buff); Field_string::store(buff,(uint) (end-buff));
} }
@ -3522,7 +3523,7 @@ void Field_varstring::store(longlong nr)
{ {
char buff[22]; char buff[22];
char *end=longlong10_to_str(nr,buff,-10); char *end=longlong10_to_str(nr,buff,-10);
Field_varstring::store(buff,end-buff); Field_varstring::store(buff,(uint) (end-buff));
} }
@ -3613,9 +3614,9 @@ char *Field_varstring::pack(char *to, const char *from, uint max_length)
uint length=uint2korr(from); uint length=uint2korr(from);
if (length > max_length) if (length > max_length)
length=max_length; length=max_length;
*to++= (length & 255); *to++= (char) (length & 255);
if (max_length > 255) if (max_length > 255)
*to++= (uchar) (length >> 8); *to++= (char) (length >> 8);
if (length) if (length)
memcpy(to, from+2, length); memcpy(to, from+2, length);
return to+length; return to+length;
@ -3704,7 +3705,7 @@ uint Field_varstring::max_packed_col_length(uint max_length)
** packlength slot and may be from 1-4. ** packlength slot and may be from 1-4.
****************************************************************************/ ****************************************************************************/
Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg, Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg,uint blob_pack_length, struct st_table *table_arg,uint blob_pack_length,
bool binary_arg) bool binary_arg)
@ -3721,7 +3722,7 @@ Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
} }
void Field_blob::store_length(ulong number) void Field_blob::store_length(uint32 number)
{ {
switch (packlength) { switch (packlength) {
case 1: case 1:
@ -3748,9 +3749,9 @@ void Field_blob::store_length(ulong number)
shortstore(ptr,(unsigned short) number); shortstore(ptr,(unsigned short) number);
break; break;
case 3: case 3:
if (number > (ulong) (1L << 24)) if (number > (uint32) (1L << 24))
{ {
number= (ulong) (1L << 24)-1L; number= (uint32) (1L << 24)-1L;
current_thd->cuted_fields++; current_thd->cuted_fields++;
} }
int3store(ptr,number); int3store(ptr,number);
@ -3768,11 +3769,11 @@ void Field_blob::store_length(ulong number)
} }
ulong Field_blob::get_length(const char *pos) uint32 Field_blob::get_length(const char *pos)
{ {
switch (packlength) { switch (packlength) {
case 1: case 1:
return (ulong) (uchar) pos[0]; return (uint32) (uchar) pos[0];
case 2: case 2:
{ {
uint16 tmp; uint16 tmp;
@ -3782,10 +3783,10 @@ ulong Field_blob::get_length(const char *pos)
else else
#endif #endif
shortget(tmp,pos); shortget(tmp,pos);
return (ulong) tmp; return (uint32) tmp;
} }
case 3: case 3:
return (ulong) uint3korr(pos); return (uint32) uint3korr(pos);
case 4: case 4:
{ {
uint32 tmp; uint32 tmp;
@ -3795,7 +3796,7 @@ ulong Field_blob::get_length(const char *pos)
else else
#endif #endif
longget(tmp,pos); longget(tmp,pos);
return (ulong) tmp; return (uint32) tmp;
} }
} }
return 0; // Impossible return 0; // Impossible
@ -3841,14 +3842,14 @@ void Field_blob::store(const char *from,uint len)
void Field_blob::store(double nr) void Field_blob::store(double nr)
{ {
value.set(nr); value.set(nr);
Field_blob::store(value.ptr(),value.length()); Field_blob::store(value.ptr(),(uint) value.length());
} }
void Field_blob::store(longlong nr) void Field_blob::store(longlong nr)
{ {
value.set(nr); value.set(nr);
Field_blob::store(value.ptr(),value.length()); Field_blob::store(value.ptr(), (uint) value.length());
} }
@ -3859,7 +3860,7 @@ double Field_blob::val_real(void)
memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
if (!blob) if (!blob)
return 0.0; return 0.0;
ulong length=get_length(ptr); uint32 length=get_length(ptr);
char save=blob[length]; // Ok to patch blob in NISAM char save=blob[length]; // Ok to patch blob in NISAM
blob[length]=0; blob[length]=0;
@ -3875,7 +3876,7 @@ longlong Field_blob::val_int(void)
memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
if (!blob) if (!blob)
return 0; return 0;
ulong length=get_length(ptr); uint32 length=get_length(ptr);
char save=blob[length]; // Ok to patch blob in NISAM char save=blob[length]; // Ok to patch blob in NISAM
blob[length]=0; blob[length]=0;
@ -3898,8 +3899,8 @@ String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
} }
int Field_blob::cmp(const char *a,ulong a_length, const char *b, int Field_blob::cmp(const char *a,uint32 a_length, const char *b,
ulong b_length) uint32 b_length)
{ {
int diff; int diff;
if (binary_flag) if (binary_flag)
@ -3933,11 +3934,11 @@ int Field_blob::cmp_binary_offset(uint row_offset)
int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr, int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr,
ulong max_length) uint32 max_length)
{ {
char *a,*b; char *a,*b;
uint diff; uint diff;
ulong a_length,b_length; uint32 a_length,b_length;
memcpy_fixed(&a,a_ptr+packlength,sizeof(char*)); memcpy_fixed(&a,a_ptr+packlength,sizeof(char*));
memcpy_fixed(&b,b_ptr+packlength,sizeof(char*)); memcpy_fixed(&b,b_ptr+packlength,sizeof(char*));
a_length=get_length(a_ptr); a_length=get_length(a_ptr);
@ -3956,9 +3957,9 @@ int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr,
void Field_blob::get_key_image(char *buff,uint length) void Field_blob::get_key_image(char *buff,uint length)
{ {
length-=HA_KEY_BLOB_LENGTH; length-=HA_KEY_BLOB_LENGTH;
ulong blob_length=get_length(ptr); uint32 blob_length=get_length(ptr);
char *blob; char *blob;
if ((ulong) length > blob_length) if ((uint32) length > blob_length)
{ {
#ifdef HAVE_purify #ifdef HAVE_purify
bzero(buff+2+blob_length, (length-blob_length)); bzero(buff+2+blob_length, (length-blob_length));
@ -4052,7 +4053,7 @@ char *Field_blob::pack(char *to, const char *from, uint max_length)
{ {
char *save=ptr; char *save=ptr;
ptr=(char*) from; ptr=(char*) from;
ulong length=get_length(); // Length of from string uint32 length=get_length(); // Length of from string
if (length > max_length) if (length > max_length)
{ {
ptr=to; ptr=to;
@ -4075,7 +4076,7 @@ char *Field_blob::pack(char *to, const char *from, uint max_length)
const char *Field_blob::unpack(char *to, const char *from) const char *Field_blob::unpack(char *to, const char *from)
{ {
memcpy(to,from,packlength); memcpy(to,from,packlength);
ulong length=get_length(from); uint32 length=get_length(from);
from+=packlength; from+=packlength;
if (length) if (length)
memcpy_fixed(to+packlength, &from, sizeof(from)); memcpy_fixed(to+packlength, &from, sizeof(from));
@ -4140,7 +4141,7 @@ char *Field_blob::pack_key(char *to, const char *from, uint max_length)
{ {
char *save=ptr; char *save=ptr;
ptr=(char*) from; ptr=(char*) from;
ulong length=get_length(); // Length of from string uint32 length=get_length(); // Length of from string
if (length > max_length) if (length > max_length)
length=max_length; length=max_length;
*to++= (uchar) length; *to++= (uchar) length;
@ -4163,9 +4164,9 @@ char *Field_blob::pack_key_from_key_image(char *to, const char *from,
uint length=uint2korr(from); uint length=uint2korr(from);
if (length > max_length) if (length > max_length)
length=max_length; length=max_length;
*to++= (length & 255); *to++= (char) (length & 255);
if (max_length > 255) if (max_length > 255)
*to++= (uchar) (length >> 8); *to++= (char) (length >> 8);
if (length) if (length)
memcpy(to, from+2, length); memcpy(to, from+2, length);
return to+length; return to+length;
@ -4278,7 +4279,7 @@ void Field_enum::store(const char *from,uint length)
conv=buff; conv=buff;
} }
my_errno=0; my_errno=0;
tmp=strtoul(conv,&end,10); tmp=(uint) strtoul(conv,&end,10);
if (my_errno || end != conv+length || tmp > typelib->count) if (my_errno || end != conv+length || tmp > typelib->count)
{ {
tmp=0; tmp=0;
@ -4624,7 +4625,7 @@ uint pack_length_to_packflag(uint type)
Field *make_field(char *ptr, uint32 field_length, Field *make_field(char *ptr, uint32 field_length,
uchar *null_pos, uint null_bit, uchar *null_pos, uchar null_bit,
uint pack_flag, uint pack_flag,
Field::utype unireg_check, Field::utype unireg_check,
TYPELIB *interval, TYPELIB *interval,

138
sql/field.h
View File

@ -16,8 +16,8 @@
/* /*
** Because of the function new_field all field classes that have static Because of the function new_field() all field classes that have static
** variables must declare the size_of() member function. variables must declare the size_of() member function.
*/ */
#ifdef __GNUC__ #ifdef __GNUC__
@ -37,21 +37,22 @@ public:
static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); } static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
static void operator delete(void *ptr_arg, size_t size) {} /*lint -e715 */ static void operator delete(void *ptr_arg, size_t size) {} /*lint -e715 */
enum utype { NONE,DATE,SHIELD,NOEMPTY,CASEUP,PNR,BGNR,PGNR,YES,NO,REL, char *ptr; // Position to field in record
CHECK,EMPTY,UNKNOWN_FIELD,CASEDN,NEXT_NUMBER,INTERVAL_FIELD,
BIT_FIELD, TIMESTAMP_FIELD,CAPITALIZE,BLOB_FIELD};
char *ptr; // Position to field in record
uchar *null_ptr; // Byte where null_bit is uchar *null_ptr; // Byte where null_bit is
uint8 null_bit; // And position to it
struct st_table *table; // Pointer for table struct st_table *table; // Pointer for table
ulong query_id; // For quick test of used fields const char *table_name,*field_name;
key_map key_start,part_of_key,part_of_sortkey;// Field is part of these keys. ulong query_id; // For quick test of used fields
const char *table_name,*field_name; // Field is part of the following keys
utype unireg_check; key_map key_start,part_of_key,part_of_sortkey;
uint32 field_length; // Length of field enum utype { NONE,DATE,SHIELD,NOEMPTY,CASEUP,PNR,BGNR,PGNR,YES,NO,REL,
uint16 flags; CHECK,EMPTY,UNKNOWN_FIELD,CASEDN,NEXT_NUMBER,INTERVAL_FIELD,
BIT_FIELD, TIMESTAMP_FIELD,CAPITALIZE,BLOB_FIELD};
utype unireg_check;
uint32 field_length; // Length of field
uint16 flags;
uchar null_bit; // Bit used to test null bit
Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,uint null_bit_arg, Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,uchar null_bit_arg,
utype unireg_check_arg, const char *field_name_arg, utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg); struct st_table *table_arg);
virtual ~Field() {} virtual ~Field() {}
@ -77,7 +78,7 @@ public:
virtual enum_field_types real_type() const { return type(); } virtual enum_field_types real_type() const { return type(); }
inline int cmp(const char *str) { return cmp(ptr,str); } inline int cmp(const char *str) { return cmp(ptr,str); }
virtual int cmp(const char *,const char *)=0; virtual int cmp(const char *,const char *)=0;
virtual int cmp_binary(const char *a,const char *b, ulong max_length=~0L) virtual int cmp_binary(const char *a,const char *b, uint32 max_length=~0L)
{ return memcmp(a,b,pack_length()); } { return memcmp(a,b,pack_length()); }
virtual int cmp_offset(uint row_offset) virtual int cmp_offset(uint row_offset)
{ return memcmp(ptr,ptr+row_offset,pack_length()); } { return memcmp(ptr,ptr+row_offset,pack_length()); }
@ -101,30 +102,30 @@ public:
inline void set_null(int row_offset=0) inline void set_null(int row_offset=0)
{ if (null_ptr) null_ptr[row_offset]|= null_bit; } { if (null_ptr) null_ptr[row_offset]|= null_bit; }
inline void set_notnull(int row_offset=0) inline void set_notnull(int row_offset=0)
{ if (null_ptr) null_ptr[row_offset]&= ~null_bit; } { if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; }
inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; } inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; }
inline bool real_maybe_null(void) { return null_ptr != 0; } inline bool real_maybe_null(void) { return null_ptr != 0; }
virtual void make_field(Send_field *)=0; virtual void make_field(Send_field *)=0;
virtual void sort_string(char *buff,uint length)=0; virtual void sort_string(char *buff,uint length)=0;
virtual bool optimize_range(); virtual bool optimize_range();
virtual bool store_for_compare() { return 0; } virtual bool store_for_compare() { return 0; }
inline Field *new_field(struct st_table *new_table) Field *new_field(MEM_ROOT *root, struct st_table *new_table)
{
Field *tmp= (Field*) memdup_root(root,(char*) this,size_of());
if (tmp)
{ {
Field *tmp= (Field*) sql_memdup((char*) this,size_of()); tmp->table=new_table;
if (tmp) tmp->key_start=tmp->part_of_key=tmp->part_of_sortkey=0;
{ tmp->unireg_check=Field::NONE;
tmp->table=new_table; tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
tmp->key_start=tmp->part_of_key=tmp->part_of_sortkey=0; tmp->reset_fields();
tmp->unireg_check=Field::NONE;
tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
tmp->reset_fields();
}
return tmp;
}
inline void move_field(char *ptr_arg,uchar *null_ptr_arg,uint null_bit_arg)
{
ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
} }
return tmp;
}
inline void move_field(char *ptr_arg,uchar *null_ptr_arg,uchar null_bit_arg)
{
ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
}
inline void move_field(char *ptr_arg) { ptr=ptr_arg; } inline void move_field(char *ptr_arg) { ptr=ptr_arg; }
inline void move_field(my_ptrdiff_t ptr_diff) inline void move_field(my_ptrdiff_t ptr_diff)
{ {
@ -157,7 +158,7 @@ public:
bool send(THD *thd, String *packet); bool send(THD *thd, String *packet);
virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0) virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0)
{ {
uint length=pack_length(); uint32 length=pack_length();
memcpy(to,from,length); memcpy(to,from,length);
return to+length; return to+length;
} }
@ -212,10 +213,10 @@ public:
const uint8 dec; const uint8 dec;
bool zerofill,unsigned_flag; // Purify cannot handle bit fields bool zerofill,unsigned_flag; // Purify cannot handle bit fields
Field_num(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, Field_num(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, utype unireg_check_arg, uchar null_bit_arg, utype unireg_check_arg,
const char *field_name_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
uint dec_arg,bool zero_arg,bool unsigned_arg) uint8 dec_arg,bool zero_arg,bool unsigned_arg)
:Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, table_arg), unireg_check_arg, field_name_arg, table_arg),
dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg) dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg)
@ -230,7 +231,7 @@ public:
void add_zerofill_and_unsigned(String &res) const; void add_zerofill_and_unsigned(String &res) const;
friend class create_field; friend class create_field;
void make_field(Send_field *); void make_field(Send_field *);
uint decimals() const { return dec; } uint decimals() const { return (uint) dec; }
uint size_of() const { return sizeof(*this); } uint size_of() const { return sizeof(*this); }
bool eq_def(Field *field); bool eq_def(Field *field);
}; };
@ -239,7 +240,7 @@ public:
class Field_str :public Field { class Field_str :public Field {
public: public:
Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, utype unireg_check_arg, uchar null_bit_arg, utype unireg_check_arg,
const char *field_name_arg, const char *field_name_arg,
struct st_table *table_arg) struct st_table *table_arg)
:Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
@ -256,10 +257,10 @@ public:
class Field_decimal :public Field_num { class Field_decimal :public Field_num {
public: public:
Field_decimal(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_decimal(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
uint dec_arg,bool zero_arg,bool unsigned_arg) uint8 dec_arg,bool zero_arg,bool unsigned_arg)
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, table_arg, unireg_check_arg, field_name_arg, table_arg,
dec_arg, zero_arg,unsigned_arg) dec_arg, zero_arg,unsigned_arg)
@ -285,7 +286,7 @@ public:
class Field_tiny :public Field_num { class Field_tiny :public Field_num {
public: public:
Field_tiny(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_tiny(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
bool zero_arg, bool unsigned_arg) bool zero_arg, bool unsigned_arg)
@ -314,7 +315,7 @@ public:
class Field_short :public Field_num { class Field_short :public Field_num {
public: public:
Field_short(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_short(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
bool zero_arg, bool unsigned_arg) bool zero_arg, bool unsigned_arg)
@ -343,7 +344,7 @@ public:
class Field_medium :public Field_num { class Field_medium :public Field_num {
public: public:
Field_medium(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_medium(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
bool zero_arg, bool unsigned_arg) bool zero_arg, bool unsigned_arg)
@ -372,7 +373,7 @@ public:
class Field_long :public Field_num { class Field_long :public Field_num {
public: public:
Field_long(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_long(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
bool zero_arg, bool unsigned_arg) bool zero_arg, bool unsigned_arg)
@ -407,7 +408,7 @@ public:
class Field_longlong :public Field_num { class Field_longlong :public Field_num {
public: public:
Field_longlong(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_longlong(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
bool zero_arg, bool unsigned_arg) bool zero_arg, bool unsigned_arg)
@ -442,10 +443,10 @@ public:
class Field_float :public Field_num { class Field_float :public Field_num {
public: public:
Field_float(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_float(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
uint dec_arg,bool zero_arg,bool unsigned_arg) uint8 dec_arg,bool zero_arg,bool unsigned_arg)
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, table_arg, unireg_check_arg, field_name_arg, table_arg,
dec_arg, zero_arg,unsigned_arg) dec_arg, zero_arg,unsigned_arg)
@ -469,16 +470,16 @@ public:
class Field_double :public Field_num { class Field_double :public Field_num {
public: public:
Field_double(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_double(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg, struct st_table *table_arg,
uint dec_arg,bool zero_arg,bool unsigned_arg) uint8 dec_arg,bool zero_arg,bool unsigned_arg)
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, table_arg, unireg_check_arg, field_name_arg, table_arg,
dec_arg, zero_arg,unsigned_arg) dec_arg, zero_arg,unsigned_arg)
{} {}
Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg, Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
struct st_table *table_arg, uint dec_arg) struct st_table *table_arg, uint8 dec_arg)
:Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0, :Field_num((char*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0,
NONE, field_name_arg, table_arg,dec_arg,0,0) NONE, field_name_arg, table_arg,dec_arg,0,0)
{} {}
@ -567,7 +568,7 @@ public:
class Field_year :public Field_tiny { class Field_year :public Field_tiny {
public: public:
Field_year(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_year(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg) struct st_table *table_arg)
:Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, :Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
@ -586,7 +587,7 @@ public:
class Field_date :public Field_str { class Field_date :public Field_str {
public: public:
Field_date(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg, Field_date(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg) struct st_table *table_arg)
:Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg, :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
@ -612,7 +613,7 @@ public:
class Field_newdate :public Field_str { class Field_newdate :public Field_str {
public: public:
Field_newdate(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg, Field_newdate(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg) struct st_table *table_arg)
:Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg, :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
@ -643,7 +644,7 @@ public:
class Field_time :public Field_str { class Field_time :public Field_str {
public: public:
Field_time(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg, Field_time(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg) struct st_table *table_arg)
:Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg, :Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg,
@ -671,7 +672,7 @@ public:
class Field_datetime :public Field_str { class Field_datetime :public Field_str {
public: public:
Field_datetime(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg, Field_datetime(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg) struct st_table *table_arg)
:Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg, :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
@ -705,7 +706,7 @@ class Field_string :public Field_str {
bool binary_flag; bool binary_flag;
public: public:
Field_string(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg, Field_string(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg,bool binary_arg) struct st_table *table_arg,bool binary_arg)
:Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
@ -760,7 +761,7 @@ class Field_varstring :public Field_str {
bool binary_flag; bool binary_flag;
public: public:
Field_varstring(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg, Field_varstring(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg,bool binary_arg) struct st_table *table_arg,bool binary_arg)
:Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
@ -813,7 +814,7 @@ class Field_blob :public Field_str {
String value; // For temporaries String value; // For temporaries
bool binary_flag; bool binary_flag;
public: public:
Field_blob(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg, Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg,uint blob_pack_length, struct st_table *table_arg,uint blob_pack_length,
bool binary_arg); bool binary_arg);
@ -837,21 +838,22 @@ public:
longlong val_int(void); longlong val_int(void);
String *val_str(String*,String *); String *val_str(String*,String *);
int cmp(const char *,const char*); int cmp(const char *,const char*);
int cmp(const char *a, ulong a_length, const char *b, ulong b_length); int cmp(const char *a, uint32 a_length, const char *b, uint32 b_length);
int cmp_offset(uint offset); int cmp_offset(uint offset);
int cmp_binary(const char *a,const char *b, ulong max_length=~0L); int cmp_binary(const char *a,const char *b, uint32 max_length=~0L);
int cmp_binary_offset(uint row_offset); int cmp_binary_offset(uint row_offset);
int key_cmp(const byte *,const byte*); int key_cmp(const byte *,const byte*);
int key_cmp(const byte *str, uint length); int key_cmp(const byte *str, uint length);
uint32 key_length() const { return 0; } uint32 key_length() const { return 0; }
void sort_string(char *buff,uint length); void sort_string(char *buff,uint length);
uint32 pack_length() const { return (uint32) (packlength+table->blob_ptr_size); } uint32 pack_length() const
void reset(void) { bzero(ptr,packlength+sizeof(char*)); } { return (uint32) (packlength+table->blob_ptr_size); }
void reset(void) { bzero(ptr, packlength+sizeof(char*)); }
void reset_fields() { bzero((char*) &value,sizeof(value)); } void reset_fields() { bzero((char*) &value,sizeof(value)); }
void store_length(ulong number); void store_length(uint32 number);
inline ulong get_length(uint row_offset=0) inline uint32 get_length(uint row_offset=0)
{ return get_length(ptr+row_offset); } { return get_length(ptr+row_offset); }
ulong get_length(const char *ptr); uint32 get_length(const char *ptr);
bool binary() const { return binary_flag; } bool binary() const { return binary_flag; }
inline void get_ptr(char **str) inline void get_ptr(char **str)
{ {
@ -862,7 +864,7 @@ public:
memcpy(ptr,length,packlength); memcpy(ptr,length,packlength);
memcpy_fixed(ptr+packlength,&data,sizeof(char*)); memcpy_fixed(ptr+packlength,&data,sizeof(char*));
} }
inline void set_ptr(ulong length,char *data) inline void set_ptr(uint32 length,char *data)
{ {
store_length(length); store_length(length);
memcpy_fixed(ptr+packlength,&data,sizeof(char*)); memcpy_fixed(ptr+packlength,&data,sizeof(char*));
@ -902,7 +904,7 @@ protected:
public: public:
TYPELIB *typelib; TYPELIB *typelib;
Field_enum(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_enum(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg,uint packlength_arg, struct st_table *table_arg,uint packlength_arg,
TYPELIB *typelib_arg) TYPELIB *typelib_arg)
@ -939,7 +941,7 @@ public:
class Field_set :public Field_enum { class Field_set :public Field_enum {
public: public:
Field_set(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, Field_set(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uint null_bit_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg, enum utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg,uint32 packlength_arg, struct st_table *table_arg,uint32 packlength_arg,
TYPELIB *typelib_arg) TYPELIB *typelib_arg)
@ -1022,7 +1024,7 @@ public:
Field *make_field(char *ptr, uint32 field_length, Field *make_field(char *ptr, uint32 field_length,
uchar *null_pos, uint null_bit, uchar *null_pos, uchar null_bit,
uint pack_flag, Field::utype unireg_check, uint pack_flag, Field::utype unireg_check,
TYPELIB *interval, const char *field_name, TYPELIB *interval, const char *field_name,
struct st_table *table); struct st_table *table);
@ -1065,7 +1067,7 @@ bool test_if_int(const char *str,int length);
#define f_is_zerofill(x) ((x) & FIELDFLAG_ZEROFILL) #define f_is_zerofill(x) ((x) & FIELDFLAG_ZEROFILL)
#define f_is_packed(x) ((x) & FIELDFLAG_PACK) #define f_is_packed(x) ((x) & FIELDFLAG_PACK)
#define f_packtype(x) (((x) >> FIELDFLAG_PACK_SHIFT) & 15) #define f_packtype(x) (((x) >> FIELDFLAG_PACK_SHIFT) & 15)
#define f_decimals(x) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC) #define f_decimals(x) ((uint8) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
#define f_is_alpha(x) (!f_is_num(x)) #define f_is_alpha(x) (!f_is_num(x))
#define f_is_binary(x) ((x) & FIELDFLAG_BINARY) #define f_is_binary(x) ((x) & FIELDFLAG_BINARY)
#define f_is_enum(x) ((x) & FIELDFLAG_INTERVAL) #define f_is_enum(x) ((x) & FIELDFLAG_INTERVAL)

4
sql/ha_myisam.cc
View File

@ -130,7 +130,7 @@ int ha_myisam::net_read_dump(NET* net)
my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME)); my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
for(;;) for(;;)
{ {
uint packet_len = my_net_read(net); ulong packet_len = my_net_read(net);
if (!packet_len) if (!packet_len)
break ; // end of file break ; // end of file
if (packet_len == packet_error) if (packet_len == packet_error)
@ -139,7 +139,7 @@ int ha_myisam::net_read_dump(NET* net)
error= -1; error= -1;
goto err; goto err;
} }
if (my_write(data_fd, (byte*)net->read_pos, packet_len, if (my_write(data_fd, (byte*)net->read_pos, (uint) packet_len,
MYF(MY_WME|MY_FNABP))) MYF(MY_WME|MY_FNABP)))
{ {
error = errno; error = errno;

4
sql/item.h
View File

@ -206,14 +206,14 @@ public:
Item_real(const char *str_arg,uint length) :value(atof(str_arg)) Item_real(const char *str_arg,uint length) :value(atof(str_arg))
{ {
name=(char*) str_arg; name=(char*) str_arg;
decimals=nr_of_decimals(str_arg); decimals=(uint8) nr_of_decimals(str_arg);
max_length=length; max_length=length;
} }
Item_real(const char *str,double val_arg,uint decimal_par,uint length) Item_real(const char *str,double val_arg,uint decimal_par,uint length)
:value(val_arg) :value(val_arg)
{ {
name=(char*) str; name=(char*) str;
decimals=decimal_par; decimals=(uint8) decimal_par;
max_length=length; max_length=length;
} }
Item_real(double value_par) :value(value_par) {} Item_real(double value_par) :value(value_par) {}

248
sql/log_event.cc
View File

@ -193,14 +193,14 @@ void Query_log_event::pack_info(String* packet)
char buf[256]; char buf[256];
String tmp(buf, sizeof(buf)); String tmp(buf, sizeof(buf));
tmp.length(0); tmp.length(0);
if(db && db_len) if (db && db_len)
{ {
tmp.append("use "); tmp.append("use ");
tmp.append(db, db_len); tmp.append(db, db_len);
tmp.append("; ", 2); tmp.append("; ", 2);
} }
if(query && q_len) if (query && q_len)
tmp.append(query, q_len); tmp.append(query, q_len);
net_store_data(packet, (char*)tmp.ptr(), tmp.length()); net_store_data(packet, (char*)tmp.ptr(), tmp.length());
} }
@ -224,7 +224,7 @@ void Load_log_event::pack_info(String* packet)
char buf[256]; char buf[256];
String tmp(buf, sizeof(buf)); String tmp(buf, sizeof(buf));
tmp.length(0); tmp.length(0);
if(db && db_len) if (db && db_len)
{ {
tmp.append("use "); tmp.append("use ");
tmp.append(db, db_len); tmp.append(db, db_len);
@ -234,9 +234,9 @@ void Load_log_event::pack_info(String* packet)
tmp.append("LOAD DATA INFILE '"); tmp.append("LOAD DATA INFILE '");
tmp.append(fname, fname_len); tmp.append(fname, fname_len);
tmp.append("' ", 2); tmp.append("' ", 2);
if(sql_ex.opt_flags && REPLACE_FLAG ) if (sql_ex.opt_flags && REPLACE_FLAG )
tmp.append(" REPLACE "); tmp.append(" REPLACE ");
else if(sql_ex.opt_flags && IGNORE_FLAG ) else if (sql_ex.opt_flags && IGNORE_FLAG )
tmp.append(" IGNORE "); tmp.append(" IGNORE ");
tmp.append("INTO TABLE "); tmp.append("INTO TABLE ");
@ -278,12 +278,11 @@ void Load_log_event::pack_info(String* packet)
if (num_fields) if (num_fields)
{ {
uint i;
const char* field = fields; const char* field = fields;
tmp.append(" ("); tmp.append(" (");
for(i = 0; i < num_fields; i++) for (uint i = 0; i < num_fields; i++)
{ {
if(i) if (i)
tmp.append(" ,"); tmp.append(" ,");
tmp.append( field); tmp.append( field);
@ -304,7 +303,7 @@ void Rotate_log_event::pack_info(String* packet)
tmp.append(new_log_ident, ident_len); tmp.append(new_log_ident, ident_len);
tmp.append(";pos="); tmp.append(";pos=");
tmp.append(llstr(pos,buf)); tmp.append(llstr(pos,buf));
if(flags & LOG_EVENT_FORCED_ROTATE_F) if (flags & LOG_EVENT_FORCED_ROTATE_F)
tmp.append("; forced by master"); tmp.append("; forced by master");
net_store_data(packet, tmp.ptr(), tmp.length()); net_store_data(packet, tmp.ptr(), tmp.length());
} }
@ -414,7 +413,7 @@ int Log_event::read_log_event(IO_CACHE* file, String* packet,
// if the read hits eof, we must report it as eof // if the read hits eof, we must report it as eof
// so the caller will know it can go into cond_wait to be woken up // so the caller will know it can go into cond_wait to be woken up
// on the next update to the log // on the next update to the log
if(!file->error) return LOG_READ_EOF; if (!file->error) return LOG_READ_EOF;
return file->error > 0 ? LOG_READ_TRUNC: LOG_READ_IO; return file->error > 0 ? LOG_READ_TRUNC: LOG_READ_IO;
} }
data_len = uint4korr(buf + EVENT_LEN_OFFSET); data_len = uint4korr(buf + EVENT_LEN_OFFSET);
@ -430,7 +429,7 @@ int Log_event::read_log_event(IO_CACHE* file, String* packet,
{ {
if (packet->append(file, data_len)) if (packet->append(file, data_len))
{ {
if(log_lock) if (log_lock)
pthread_mutex_unlock(log_lock); pthread_mutex_unlock(log_lock);
// here we should never hit eof in a non-error condtion // here we should never hit eof in a non-error condtion
// eof means we are reading the event partially, which should // eof means we are reading the event partially, which should
@ -445,13 +444,13 @@ int Log_event::read_log_event(IO_CACHE* file, String* packet,
#endif // MYSQL_CLIENT #endif // MYSQL_CLIENT
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
#define UNLOCK_MUTEX if(log_lock) pthread_mutex_unlock(log_lock); #define UNLOCK_MUTEX if (log_lock) pthread_mutex_unlock(log_lock);
#else #else
#define UNLOCK_MUTEX #define UNLOCK_MUTEX
#endif #endif
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
#define LOCK_MUTEX if(log_lock) pthread_mutex_lock(log_lock); #define LOCK_MUTEX if (log_lock) pthread_mutex_lock(log_lock);
#else #else
#define LOCK_MUTEX #define LOCK_MUTEX
#endif #endif
@ -501,7 +500,7 @@ Log_event* Log_event::read_log_event(IO_CACHE* file, bool old_format)
} }
buf[data_len] = 0; buf[data_len] = 0;
memcpy(buf, head, header_size); memcpy(buf, head, header_size);
if(my_b_read(file, (byte*) buf + header_size, if (my_b_read(file, (byte*) buf + header_size,
data_len - header_size)) data_len - header_size))
{ {
error = "read error"; error = "read error";
@ -511,7 +510,7 @@ Log_event* Log_event::read_log_event(IO_CACHE* file, bool old_format)
res->register_temp_buf(buf); res->register_temp_buf(buf);
err: err:
UNLOCK_MUTEX; UNLOCK_MUTEX;
if(error) if (error)
{ {
sql_print_error(error); sql_print_error(error);
my_free(buf, MYF(MY_ALLOW_ZERO_PTR)); my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
@ -679,7 +678,7 @@ Rotate_log_event::Rotate_log_event(const char* buf, int event_len,
// EVENT_LEN_OFFSET // EVENT_LEN_OFFSET
int header_size = (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN; int header_size = (old_format) ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
uint ident_offset; uint ident_offset;
if(event_len < header_size) if (event_len < header_size)
return; return;
buf += header_size; buf += header_size;
if (old_format) if (old_format)
@ -775,9 +774,9 @@ void Query_log_event::print(FILE* file, bool short_form, char* last_db)
bool same_db = 0; bool same_db = 0;
if(db && last_db) if (db && last_db)
{ {
if(!(same_db = !memcmp(last_db, db, db_len + 1))) if (!(same_db = !memcmp(last_db, db, db_len + 1)))
memcpy(last_db, db, db_len + 1); memcpy(last_db, db, db_len + 1);
} }
@ -838,7 +837,7 @@ int Intvar_log_event::write_data(IO_CACHE* file)
void Intvar_log_event::print(FILE* file, bool short_form, char* last_db) void Intvar_log_event::print(FILE* file, bool short_form, char* last_db)
{ {
char llbuff[22]; char llbuff[22];
if(!short_form) if (!short_form)
{ {
print_header(file); print_header(file);
fprintf(file, "\tIntvar\n"); fprintf(file, "\tIntvar\n");
@ -971,86 +970,83 @@ char* sql_ex_info::init(char* buf,char* buf_end,bool use_new_format)
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
Load_log_event::Load_log_event(THD* thd, sql_exchange* ex, Load_log_event::Load_log_event(THD* thd, sql_exchange* ex,
const char* db_arg, const char* table_name_arg, const char* db_arg, const char* table_name_arg,
List<Item>& fields_arg, enum enum_duplicates handle_dup): List<Item>& fields_arg,
Log_event(thd),thread_id(thd->thread_id), enum enum_duplicates handle_dup):
num_fields(0),fields(0),field_lens(0),field_block_len(0), Log_event(thd), fields(0), field_lens(0),
table_name(table_name_arg), table_name(table_name_arg), db(db_arg), fname(ex->file_name),
db(db_arg), thread_id(thd->thread_id), num_fields(0), field_block_len(0)
fname(ex->file_name) {
{ time_t end_time;
time_t end_time; time(&end_time);
time(&end_time); exec_time = (ulong) (end_time - thd->start_time);
exec_time = (ulong) (end_time - thd->start_time); db_len = (db) ? (uint32) strlen(db) : 0;
db_len = (db) ? (uint32) strlen(db) : 0; table_name_len = (table_name) ? (uint32) strlen(table_name) : 0;
table_name_len = (table_name) ? (uint32) strlen(table_name) : 0; fname_len = (fname) ? (uint) strlen(fname) : 0;
fname_len = (fname) ? (uint) strlen(fname) : 0; sql_ex.field_term = (char*) ex->field_term->ptr();
sql_ex.field_term = (char*) ex->field_term->ptr(); sql_ex.field_term_len = (uint8) ex->field_term->length();
sql_ex.field_term_len = (uint8) ex->field_term->length(); sql_ex.enclosed = (char*) ex->enclosed->ptr();
sql_ex.enclosed = (char*) ex->enclosed->ptr(); sql_ex.enclosed_len = (uint8) ex->enclosed->length();
sql_ex.enclosed_len = (uint8) ex->enclosed->length(); sql_ex.line_term = (char*) ex->line_term->ptr();
sql_ex.line_term = (char*) ex->line_term->ptr(); sql_ex.line_term_len = (uint8) ex->line_term->length();
sql_ex.line_term_len = (uint8) ex->line_term->length(); sql_ex.line_start = (char*) ex->line_start->ptr();
sql_ex.line_start = (char*) ex->line_start->ptr(); sql_ex.line_start_len = (uint8) ex->line_start->length();
sql_ex.line_start_len = (uint8) ex->line_start->length(); sql_ex.escaped = (char*) ex->escaped->ptr();
sql_ex.escaped = (char*) ex->escaped->ptr(); sql_ex.escaped_len = (uint8) ex->escaped->length();
sql_ex.escaped_len = (uint8) ex->escaped->length(); sql_ex.opt_flags = 0;
sql_ex.opt_flags = 0; sql_ex.cached_new_format = -1;
sql_ex.cached_new_format = -1;
if(ex->dumpfile) if (ex->dumpfile)
sql_ex.opt_flags |= DUMPFILE_FLAG; sql_ex.opt_flags |= DUMPFILE_FLAG;
if(ex->opt_enclosed) if (ex->opt_enclosed)
sql_ex.opt_flags |= OPT_ENCLOSED_FLAG; sql_ex.opt_flags |= OPT_ENCLOSED_FLAG;
sql_ex.empty_flags = 0; sql_ex.empty_flags = 0;
switch(handle_dup) switch(handle_dup) {
{ case DUP_IGNORE: sql_ex.opt_flags |= IGNORE_FLAG; break;
case DUP_IGNORE: sql_ex.opt_flags |= IGNORE_FLAG; break; case DUP_REPLACE: sql_ex.opt_flags |= REPLACE_FLAG; break;
case DUP_REPLACE: sql_ex.opt_flags |= REPLACE_FLAG; break; case DUP_ERROR: break;
case DUP_ERROR: break;
}
if(!ex->field_term->length())
sql_ex.empty_flags |= FIELD_TERM_EMPTY;
if(!ex->enclosed->length())
sql_ex.empty_flags |= ENCLOSED_EMPTY;
if(!ex->line_term->length())
sql_ex.empty_flags |= LINE_TERM_EMPTY;
if(!ex->line_start->length())
sql_ex.empty_flags |= LINE_START_EMPTY;
if(!ex->escaped->length())
sql_ex.empty_flags |= ESCAPED_EMPTY;
skip_lines = ex->skip_lines;
List_iterator<Item> li(fields_arg);
field_lens_buf.length(0);
fields_buf.length(0);
Item* item;
while((item = li++))
{
num_fields++;
uchar len = (uchar) strlen(item->name);
field_block_len += len + 1;
fields_buf.append(item->name, len + 1);
field_lens_buf.append((char*)&len, 1);
}
field_lens = (const uchar*)field_lens_buf.ptr();
fields = fields_buf.ptr();
} }
if (!ex->field_term->length())
sql_ex.empty_flags |= FIELD_TERM_EMPTY;
if (!ex->enclosed->length())
sql_ex.empty_flags |= ENCLOSED_EMPTY;
if (!ex->line_term->length())
sql_ex.empty_flags |= LINE_TERM_EMPTY;
if (!ex->line_start->length())
sql_ex.empty_flags |= LINE_START_EMPTY;
if (!ex->escaped->length())
sql_ex.empty_flags |= ESCAPED_EMPTY;
skip_lines = ex->skip_lines;
List_iterator<Item> li(fields_arg);
field_lens_buf.length(0);
fields_buf.length(0);
Item* item;
while((item = li++))
{
num_fields++;
uchar len = (uchar) strlen(item->name);
field_block_len += len + 1;
fields_buf.append(item->name, len + 1);
field_lens_buf.append((char*)&len, 1);
}
field_lens = (const uchar*)field_lens_buf.ptr();
fields = fields_buf.ptr();
}
#endif #endif
// the caller must do buf[event_len] = 0 before he starts using the // the caller must do buf[event_len] = 0 before he starts using the
// constructed event // constructed event
Load_log_event::Load_log_event(const char* buf, int event_len, Load_log_event::Load_log_event(const char* buf, int event_len,
bool old_format): bool old_format):
Log_event(buf, old_format),num_fields(0),fields(0), Log_event(buf, old_format),fields(0),
field_lens(0),field_block_len(0), field_lens(0), num_fields(0), field_block_len(0)
table_name(0),db(0),fname(0)
{ {
if (!event_len) // derived class, will call copy_log_event() itself if (!event_len) // derived class, will call copy_log_event() itself
return; return;
@ -1112,32 +1108,32 @@ void Load_log_event::print(FILE* file, bool short_form, char* last_db)
bool same_db = 0; bool same_db = 0;
if(db && last_db) if (db && last_db)
{ {
if(!(same_db = !memcmp(last_db, db, db_len + 1))) if (!(same_db = !memcmp(last_db, db, db_len + 1)))
memcpy(last_db, db, db_len + 1); memcpy(last_db, db, db_len + 1);
} }
if(db && db[0] && !same_db) if (db && db[0] && !same_db)
fprintf(file, "use %s;\n", db); fprintf(file, "use %s;\n", db);
fprintf(file, "LOAD DATA INFILE '%-*s' ", fname_len, fname); fprintf(file, "LOAD DATA INFILE '%-*s' ", fname_len, fname);
if(sql_ex.opt_flags && REPLACE_FLAG ) if (sql_ex.opt_flags && REPLACE_FLAG )
fprintf(file," REPLACE "); fprintf(file," REPLACE ");
else if(sql_ex.opt_flags && IGNORE_FLAG ) else if (sql_ex.opt_flags && IGNORE_FLAG )
fprintf(file," IGNORE "); fprintf(file," IGNORE ");
fprintf(file, "INTO TABLE %s ", table_name); fprintf(file, "INTO TABLE %s ", table_name);
if(sql_ex.field_term) if (sql_ex.field_term)
{ {
fprintf(file, " FIELDS TERMINATED BY "); fprintf(file, " FIELDS TERMINATED BY ");
pretty_print_str(file, sql_ex.field_term, sql_ex.field_term_len); pretty_print_str(file, sql_ex.field_term, sql_ex.field_term_len);
} }
if(sql_ex.enclosed) if (sql_ex.enclosed)
{ {
if(sql_ex.opt_flags && OPT_ENCLOSED_FLAG ) if (sql_ex.opt_flags && OPT_ENCLOSED_FLAG )
fprintf(file," OPTIONALLY "); fprintf(file," OPTIONALLY ");
fprintf(file, " ENCLOSED BY "); fprintf(file, " ENCLOSED BY ");
pretty_print_str(file, sql_ex.enclosed, sql_ex.enclosed_len); pretty_print_str(file, sql_ex.enclosed, sql_ex.enclosed_len);
@ -1161,7 +1157,7 @@ void Load_log_event::print(FILE* file, bool short_form, char* last_db)
pretty_print_str(file, sql_ex.line_start, sql_ex.line_start_len); pretty_print_str(file, sql_ex.line_start, sql_ex.line_start_len);
} }
if((int)skip_lines > 0) if ((int)skip_lines > 0)
fprintf(file, " IGNORE %ld LINES ", (long) skip_lines); fprintf(file, " IGNORE %ld LINES ", (long) skip_lines);
if (num_fields) if (num_fields)
@ -1169,9 +1165,9 @@ void Load_log_event::print(FILE* file, bool short_form, char* last_db)
uint i; uint i;
const char* field = fields; const char* field = fields;
fprintf( file, " ("); fprintf( file, " (");
for(i = 0; i < num_fields; i++) for (i = 0; i < num_fields; i++)
{ {
if(i) if (i)
fputc(',', file); fputc(',', file);
fprintf(file, field); fprintf(file, field);
@ -1197,24 +1193,24 @@ void Load_log_event::set_fields(List<Item> &fields)
{ {
uint i; uint i;
const char* field = this->fields; const char* field = this->fields;
for(i = 0; i < num_fields; i++) for (i = 0; i < num_fields; i++)
{ {
fields.push_back(new Item_field(db, table_name, field)); fields.push_back(new Item_field(db, table_name, field));
field += field_lens[i] + 1; field += field_lens[i] + 1;
} }
} }
Slave_log_event::Slave_log_event(THD* thd_arg,struct st_master_info* mi): Slave_log_event::Slave_log_event(THD* thd_arg,struct st_master_info* mi):
Log_event(thd_arg),mem_pool(0),master_host(0) Log_event(thd_arg),mem_pool(0),master_host(0)
{ {
if(!mi->inited) if (!mi->inited)
return; return;
pthread_mutex_lock(&mi->lock); pthread_mutex_lock(&mi->lock);
master_host_len = strlen(mi->host); master_host_len = strlen(mi->host);
master_log_len = strlen(mi->log_file_name); master_log_len = strlen(mi->log_file_name);
// on OOM, just do not initialize the structure and print the error // on OOM, just do not initialize the structure and print the error
if((mem_pool = (char*)my_malloc(get_data_size() + 1, if ((mem_pool = (char*)my_malloc(get_data_size() + 1,
MYF(MY_WME)))) MYF(MY_WME))))
{ {
master_host = mem_pool + SL_MASTER_HOST_OFFSET ; master_host = mem_pool + SL_MASTER_HOST_OFFSET ;
@ -1243,7 +1239,7 @@ Slave_log_event::~Slave_log_event()
void Slave_log_event::print(FILE* file, bool short_form, char* last_db) void Slave_log_event::print(FILE* file, bool short_form, char* last_db)
{ {
char llbuff[22]; char llbuff[22];
if(short_form) if (short_form)
return; return;
print_header(file); print_header(file);
fputc('\n', file); fputc('\n', file);
@ -1275,7 +1271,7 @@ void Slave_log_event::init_from_mem_pool(int data_size)
master_host_len = strlen(master_host); master_host_len = strlen(master_host);
// safety // safety
master_log = master_host + master_host_len + 1; master_log = master_host + master_host_len + 1;
if(master_log > mem_pool + data_size) if (master_log > mem_pool + data_size)
{ {
master_host = 0; master_host = 0;
return; return;
@ -1287,9 +1283,9 @@ Slave_log_event::Slave_log_event(const char* buf, int event_len):
Log_event(buf,0),mem_pool(0),master_host(0) Log_event(buf,0),mem_pool(0),master_host(0)
{ {
event_len -= LOG_EVENT_HEADER_LEN; event_len -= LOG_EVENT_HEADER_LEN;
if(event_len < 0) if (event_len < 0)
return; return;
if(!(mem_pool = (char*)my_malloc(event_len + 1, MYF(MY_WME)))) if (!(mem_pool = (char*)my_malloc(event_len + 1, MYF(MY_WME))))
return; return;
memcpy(mem_pool, buf + LOG_EVENT_HEADER_LEN, event_len); memcpy(mem_pool, buf + LOG_EVENT_HEADER_LEN, event_len);
mem_pool[event_len] = 0; mem_pool[event_len] = 0;
@ -1396,7 +1392,7 @@ Append_block_log_event::Append_block_log_event(THD* thd_arg, char* block_arg,
Append_block_log_event::Append_block_log_event(const char* buf, int len): Append_block_log_event::Append_block_log_event(const char* buf, int len):
Log_event(buf, 0),block(0) Log_event(buf, 0),block(0)
{ {
if((uint)len < APPEND_BLOCK_EVENT_OVERHEAD) if ((uint)len < APPEND_BLOCK_EVENT_OVERHEAD)
return; return;
file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + AB_FILE_ID_OFFSET); file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + AB_FILE_ID_OFFSET);
block = (char*)buf + APPEND_BLOCK_EVENT_OVERHEAD; block = (char*)buf + APPEND_BLOCK_EVENT_OVERHEAD;
@ -1448,7 +1444,7 @@ Delete_file_log_event::Delete_file_log_event(THD* thd_arg):
Delete_file_log_event::Delete_file_log_event(const char* buf, int len): Delete_file_log_event::Delete_file_log_event(const char* buf, int len):
Log_event(buf, 0),file_id(0) Log_event(buf, 0),file_id(0)
{ {
if((uint)len < DELETE_FILE_EVENT_OVERHEAD) if ((uint)len < DELETE_FILE_EVENT_OVERHEAD)
return; return;
file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + AB_FILE_ID_OFFSET); file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + AB_FILE_ID_OFFSET);
} }
@ -1495,7 +1491,7 @@ Execute_load_log_event::Execute_load_log_event(THD* thd_arg):
Execute_load_log_event::Execute_load_log_event(const char* buf,int len): Execute_load_log_event::Execute_load_log_event(const char* buf,int len):
Log_event(buf, 0),file_id(0) Log_event(buf, 0),file_id(0)
{ {
if((uint)len < EXEC_LOAD_EVENT_OVERHEAD) if ((uint)len < EXEC_LOAD_EVENT_OVERHEAD)
return; return;
file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + EL_FILE_ID_OFFSET); file_id = uint4korr(buf + LOG_EVENT_HEADER_LEN + EL_FILE_ID_OFFSET);
} }
@ -1551,8 +1547,10 @@ int Query_log_event::exec_event(struct st_master_info* mi)
thd->net.last_error[0] = 0; thd->net.last_error[0] = 0;
thd->slave_proxy_id = thread_id; // for temp tables thd->slave_proxy_id = thread_id; // for temp tables
// sanity check to make sure the master did not get a really bad /*
// error on the query sanity check to make sure the master did not get a really bad
error on the query
*/
if (!check_expected_error(thd, (expected_error = error_code))) if (!check_expected_error(thd, (expected_error = error_code)))
{ {
mysql_parse(thd, thd->query, q_len); mysql_parse(thd, thd->query, q_len);
@ -1609,7 +1607,7 @@ int Load_log_event::exec_event(NET* net, struct st_master_info* mi)
thd->query = 0; thd->query = 0;
thd->query_error = 0; thd->query_error = 0;
if(db_ok(thd->db, replicate_do_db, replicate_ignore_db)) if (db_ok(thd->db, replicate_do_db, replicate_ignore_db))
{ {
thd->set_time((time_t)when); thd->set_time((time_t)when);
thd->current_tablenr = 0; thd->current_tablenr = 0;
@ -1623,7 +1621,7 @@ int Load_log_event::exec_event(NET* net, struct st_master_info* mi)
tables.name = tables.real_name = (char*)table_name; tables.name = tables.real_name = (char*)table_name;
tables.lock_type = TL_WRITE; tables.lock_type = TL_WRITE;
// the table will be opened in mysql_load // the table will be opened in mysql_load
if(table_rules_on && !tables_ok(thd, &tables)) if (table_rules_on && !tables_ok(thd, &tables))
{ {
if (net) if (net)
skip_load_data_infile(net); skip_load_data_infile(net);
@ -1632,7 +1630,7 @@ int Load_log_event::exec_event(NET* net, struct st_master_info* mi)
{ {
char llbuff[22]; char llbuff[22];
enum enum_duplicates handle_dup = DUP_IGNORE; enum enum_duplicates handle_dup = DUP_IGNORE;
if(sql_ex.opt_flags && REPLACE_FLAG) if (sql_ex.opt_flags && REPLACE_FLAG)
handle_dup = DUP_REPLACE; handle_dup = DUP_REPLACE;
sql_exchange ex((char*)fname, sql_ex.opt_flags && sql_exchange ex((char*)fname, sql_ex.opt_flags &&
DUMPFILE_FLAG ); DUMPFILE_FLAG );
@ -1658,14 +1656,14 @@ int Load_log_event::exec_event(NET* net, struct st_master_info* mi)
// about the packet sequence // about the packet sequence
thd->net.pkt_nr = net->pkt_nr; thd->net.pkt_nr = net->pkt_nr;
} }
if(mysql_load(thd, &ex, &tables, fields, handle_dup, net != 0, if (mysql_load(thd, &ex, &tables, fields, handle_dup, net != 0,
TL_WRITE)) TL_WRITE))
thd->query_error = 1; thd->query_error = 1;
if(thd->cuted_fields) if (thd->cuted_fields)
sql_print_error("Slave: load data infile at position %s in log \ sql_print_error("Slave: load data infile at position %s in log \
'%s' produced %d warning(s)", llstr(mi->pos,llbuff), RPL_LOG_NAME, '%s' produced %d warning(s)", llstr(mi->pos,llbuff), RPL_LOG_NAME,
thd->cuted_fields ); thd->cuted_fields );
if(net) if (net)
net->pkt_nr = thd->net.pkt_nr; net->pkt_nr = thd->net.pkt_nr;
} }
} }
@ -1680,10 +1678,10 @@ int Load_log_event::exec_event(NET* net, struct st_master_info* mi)
thd->net.vio = 0; thd->net.vio = 0;
thd->db = 0;// prevent db from being freed thd->db = 0;// prevent db from being freed
close_thread_tables(thd); close_thread_tables(thd);
if(thd->query_error) if (thd->query_error)
{ {
int sql_error = thd->net.last_errno; int sql_error = thd->net.last_errno;
if(!sql_error) if (!sql_error)
sql_error = ER_UNKNOWN_ERROR; sql_error = ER_UNKNOWN_ERROR;
slave_print_error(sql_error, "Slave: Error '%s' running load data infile ", slave_print_error(sql_error, "Slave: Error '%s' running load data infile ",
@ -1693,7 +1691,7 @@ int Load_log_event::exec_event(NET* net, struct st_master_info* mi)
} }
free_root(&thd->mem_root,0); free_root(&thd->mem_root,0);
if(thd->fatal_error) if (thd->fatal_error)
{ {
sql_print_error("Slave: Fatal error running LOAD DATA INFILE "); sql_print_error("Slave: Fatal error running LOAD DATA INFILE ");
return 1; return 1;
@ -1788,7 +1786,7 @@ int Intvar_log_event::exec_event(struct st_master_info* mi)
int Slave_log_event::exec_event(struct st_master_info* mi) int Slave_log_event::exec_event(struct st_master_info* mi)
{ {
if(mysql_bin_log.is_open()) if (mysql_bin_log.is_open())
mysql_bin_log.write(this); mysql_bin_log.write(this);
return Log_event::exec_event(mi); return Log_event::exec_event(mi);
} }

275
sql/log_event.h
View File

@ -244,42 +244,31 @@ public:
virtual bool is_valid() = 0; virtual bool is_valid() = 0;
virtual bool get_cache_stmt() { return 0; } virtual bool get_cache_stmt() { return 0; }
Log_event(const char* buf, bool old_format); Log_event(const char* buf, bool old_format);
#ifndef MYSQL_CLIENT
Log_event(THD* thd_arg, uint16 flags_arg = 0);
#endif
virtual ~Log_event() { free_temp_buf();} virtual ~Log_event() { free_temp_buf();}
void register_temp_buf(char* buf) { temp_buf = buf; } void register_temp_buf(char* buf) { temp_buf = buf; }
void free_temp_buf() void free_temp_buf()
{
if (temp_buf)
{ {
if (temp_buf) my_free(temp_buf, MYF(0));
{ temp_buf = 0;
my_free(temp_buf, MYF(0));
temp_buf = 0;
}
} }
}
virtual int get_data_size() { return 0;} virtual int get_data_size() { return 0;}
virtual int get_data_body_offset() { return 0; } virtual int get_data_body_offset() { return 0; }
int get_event_len() { return cached_event_len ? cached_event_len : int get_event_len() { return cached_event_len ? cached_event_len :
(cached_event_len = LOG_EVENT_HEADER_LEN + get_data_size()); } (cached_event_len = LOG_EVENT_HEADER_LEN + get_data_size()); }
#ifdef MYSQL_CLIENT
virtual void print(FILE* file, bool short_form = 0, char* last_db = 0) = 0;
void print_timestamp(FILE* file, time_t *ts = 0);
void print_header(FILE* file);
#endif
#ifndef MYSQL_CLIENT
// if mutex is 0, the read will proceed without mutex
static Log_event* read_log_event(IO_CACHE* file,
pthread_mutex_t* log_lock,
bool old_format);
#else // avoid having to link mysqlbinlog against libpthread
static Log_event* read_log_event(IO_CACHE* file, bool old_format);
#endif
static Log_event* read_log_event(const char* buf, int event_len, static Log_event* read_log_event(const char* buf, int event_len,
const char **error, bool old_format); const char **error, bool old_format);
const char* get_type_str(); const char* get_type_str();
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
// if mutex is 0, the read will proceed without mutex
Log_event(THD* thd_arg, uint16 flags_arg = 0);
static Log_event* read_log_event(IO_CACHE* file,
pthread_mutex_t* log_lock,
bool old_format);
static int read_log_event(IO_CACHE* file, String* packet, static int read_log_event(IO_CACHE* file, String* packet,
pthread_mutex_t* log_lock); pthread_mutex_t* log_lock);
void set_log_seq(THD* thd, MYSQL_LOG* log); void set_log_seq(THD* thd, MYSQL_LOG* log);
@ -291,6 +280,13 @@ public:
{ {
return thd ? thd->db : 0; return thd ? thd->db : 0;
} }
#else
// avoid having to link mysqlbinlog against libpthread
static Log_event* read_log_event(IO_CACHE* file, bool old_format);
virtual void print(FILE* file, bool short_form = 0, char* last_db = 0) = 0;
void print_timestamp(FILE* file, time_t *ts = 0);
void print_header(FILE* file);
#endif #endif
}; };
@ -303,13 +299,16 @@ protected:
public: public:
const char* query; const char* query;
const char* db; const char* db;
uint32 q_len; // if we already know the length of the query string /*
// we pass it here, so we would not have to call strlen() If we already know the length of the query string
// otherwise, set it to 0, in which case, we compute it with strlen() we pass it here, so we would not have to call strlen()
otherwise, set it to 0, in which case, we compute it with strlen()
*/
uint32 q_len;
uint32 db_len; uint32 db_len;
uint16 error_code; uint16 error_code;
ulong thread_id; ulong thread_id;
#if !defined(MYSQL_CLIENT) #ifndef MYSQL_CLIENT
bool cache_stmt; bool cache_stmt;
Query_log_event(THD* thd_arg, const char* query_arg, Query_log_event(THD* thd_arg, const char* query_arg,
@ -318,6 +317,8 @@ public:
void pack_info(String* packet); void pack_info(String* packet);
int exec_event(struct st_master_info* mi); int exec_event(struct st_master_info* mi);
bool get_cache_stmt() { return cache_stmt; } bool get_cache_stmt() { return cache_stmt; }
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
Query_log_event(const char* buf, int event_len, bool old_format); Query_log_event(const char* buf, int event_len, bool old_format);
@ -340,9 +341,6 @@ public:
+ 2 // error_code + 2 // error_code
; ;
} }
#ifdef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif
}; };
class Slave_log_event: public Log_event class Slave_log_event: public Log_event
@ -352,24 +350,22 @@ protected:
void init_from_mem_pool(int data_size); void init_from_mem_pool(int data_size);
public: public:
char* master_host; char* master_host;
int master_host_len;
uint16 master_port;
char* master_log; char* master_log;
int master_log_len;
ulonglong master_pos; ulonglong master_pos;
int master_host_len;
int master_log_len;
uint16 master_port;
#ifndef MYSQL_CLIENT
Slave_log_event(THD* thd_arg, struct st_master_info* mi);
void pack_info(String* packet);
int exec_event(struct st_master_info* mi);
#endif
Slave_log_event(const char* buf, int event_len); Slave_log_event(const char* buf, int event_len);
~Slave_log_event(); ~Slave_log_event();
int get_data_size(); int get_data_size();
bool is_valid() { return master_host != 0; } bool is_valid() { return master_host != 0; }
Log_event_type get_type_code() { return SLAVE_EVENT; } Log_event_type get_type_code() { return SLAVE_EVENT; }
#ifdef MYSQL_CLIENT #ifndef MYSQL_CLIENT
Slave_log_event(THD* thd_arg, struct st_master_info* mi);
void pack_info(String* packet);
int exec_event(struct st_master_info* mi);
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0); void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
int write_data(IO_CACHE* file ); int write_data(IO_CACHE* file );
@ -382,22 +378,21 @@ protected:
int copy_log_event(const char *buf, ulong event_len, bool old_format); int copy_log_event(const char *buf, ulong event_len, bool old_format);
public: public:
const char* fields;
const uchar* field_lens;
const char* table_name;
const char* db;
const char* fname;
ulong thread_id; ulong thread_id;
uint32 table_name_len; uint32 table_name_len;
uint32 db_len; uint32 db_len;
uint32 fname_len; uint32 fname_len;
uint32 num_fields; uint32 num_fields;
const char* fields;
const uchar* field_lens;
uint32 field_block_len; uint32 field_block_len;
const char* table_name;
const char* db;
const char* fname;
uint32 skip_lines; uint32 skip_lines;
sql_ex_info sql_ex; sql_ex_info sql_ex;
#if !defined(MYSQL_CLIENT) #ifndef MYSQL_CLIENT
String field_lens_buf; String field_lens_buf;
String fields_buf; String fields_buf;
@ -408,10 +403,12 @@ public:
void pack_info(String* packet); void pack_info(String* packet);
const char* get_db() { return db; } const char* get_db() { return db; }
int exec_event(struct st_master_info* mi) int exec_event(struct st_master_info* mi)
{ {
return exec_event(thd->slave_net,mi); return exec_event(thd->slave_net,mi);
} }
int exec_event(NET* net, struct st_master_info* mi); int exec_event(NET* net, struct st_master_info* mi);
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
Load_log_event(const char* buf, int event_len, bool old_format); Load_log_event(const char* buf, int event_len, bool old_format);
@ -434,9 +431,6 @@ public:
; ;
} }
int get_data_body_offset() { return LOAD_EVENT_OVERHEAD; } int get_data_body_offset() { return LOAD_EVENT_OVERHEAD; }
#ifdef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif
}; };
extern char server_version[SERVER_VERSION_LENGTH]; extern char server_version[SERVER_VERSION_LENGTH];
@ -447,13 +441,7 @@ public:
uint32 created; uint32 created;
uint16 binlog_version; uint16 binlog_version;
char server_version[ST_SERVER_VER_LEN]; char server_version[ST_SERVER_VER_LEN];
#ifndef MYSQL_CLIENT
Start_log_event() :Log_event((THD*)0),binlog_version(BINLOG_VERSION)
{
created = (uint32) when;
memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
}
#endif
Start_log_event(const char* buf, bool old_format); Start_log_event(const char* buf, bool old_format);
~Start_log_event() {} ~Start_log_event() {}
Log_event_type get_type_code() { return START_EVENT;} Log_event_type get_type_code() { return START_EVENT;}
@ -464,10 +452,14 @@ public:
return START_HEADER_LEN; return START_HEADER_LEN;
} }
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
Start_log_event() :Log_event((THD*)0),binlog_version(BINLOG_VERSION)
{
created = (uint32) when;
memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
}
void pack_info(String* packet); void pack_info(String* packet);
int exec_event(struct st_master_info* mi); int exec_event(struct st_master_info* mi);
#endif #else
#ifdef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0); void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
}; };
@ -477,11 +469,7 @@ class Intvar_log_event: public Log_event
public: public:
ulonglong val; ulonglong val;
uchar type; uchar type;
#ifndef MYSQL_CLIENT
Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
:Log_event(thd_arg),val(val_arg),type(type_arg)
{}
#endif
Intvar_log_event(const char* buf, bool old_format); Intvar_log_event(const char* buf, bool old_format);
~Intvar_log_event() {} ~Intvar_log_event() {}
Log_event_type get_type_code() { return INTVAR_EVENT;} Log_event_type get_type_code() { return INTVAR_EVENT;}
@ -490,11 +478,12 @@ public:
int write_data(IO_CACHE* file); int write_data(IO_CACHE* file);
bool is_valid() { return 1; } bool is_valid() { return 1; }
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
:Log_event(thd_arg),val(val_arg),type(type_arg)
{}
void pack_info(String* packet); void pack_info(String* packet);
int exec_event(struct st_master_info* mi); int exec_event(struct st_master_info* mi);
#endif #else
#ifdef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0); void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
}; };
@ -502,10 +491,6 @@ public:
class Stop_log_event: public Log_event class Stop_log_event: public Log_event
{ {
public: public:
#ifndef MYSQL_CLIENT
Stop_log_event() :Log_event((THD*)0)
{}
#endif
Stop_log_event(const char* buf, bool old_format):Log_event(buf, Stop_log_event(const char* buf, bool old_format):Log_event(buf,
old_format) old_format)
{ {
@ -513,11 +498,11 @@ public:
~Stop_log_event() {} ~Stop_log_event() {}
Log_event_type get_type_code() { return STOP_EVENT;} Log_event_type get_type_code() { return STOP_EVENT;}
bool is_valid() { return 1; } bool is_valid() { return 1; }
#ifdef MYSQL_CLIENT #ifndef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0); Stop_log_event() :Log_event((THD*)0) {}
#endif
#ifndef MYSQL_CLIENT
int exec_event(struct st_master_info* mi); int exec_event(struct st_master_info* mi);
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
}; };
@ -525,19 +510,10 @@ class Rotate_log_event: public Log_event
{ {
public: public:
const char* new_log_ident; const char* new_log_ident;
uchar ident_len;
ulonglong pos; ulonglong pos;
uint8 ident_len;
bool alloced; bool alloced;
#ifndef MYSQL_CLIENT
Rotate_log_event(THD* thd_arg, const char* new_log_ident_arg,
uint ident_len_arg = 0,ulonglong pos_arg = 4) :
Log_event(thd_arg),
new_log_ident(new_log_ident_arg),
ident_len(ident_len_arg ? ident_len_arg :
(uint) strlen(new_log_ident_arg)), pos(pos_arg),
alloced(0)
{}
#endif
Rotate_log_event(const char* buf, int event_len, bool old_format); Rotate_log_event(const char* buf, int event_len, bool old_format);
~Rotate_log_event() ~Rotate_log_event()
{ {
@ -548,64 +524,81 @@ public:
int get_data_size() { return ident_len + ROTATE_HEADER_LEN;} int get_data_size() { return ident_len + ROTATE_HEADER_LEN;}
bool is_valid() { return new_log_ident != 0; } bool is_valid() { return new_log_ident != 0; }
int write_data(IO_CACHE* file); int write_data(IO_CACHE* file);
#ifdef MYSQL_CLIENT #ifndef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0); Rotate_log_event(THD* thd_arg, const char* new_log_ident_arg,
#endif uint8 ident_len_arg = 0,ulonglong pos_arg = 4) :
#ifndef MYSQL_CLIENT Log_event(thd_arg), new_log_ident(new_log_ident_arg),
pos(pos_arg),
ident_len(ident_len_arg ? ident_len_arg :
(uint8) strlen(new_log_ident_arg)),
alloced(0)
{}
void pack_info(String* packet); void pack_info(String* packet);
int exec_event(struct st_master_info* mi); int exec_event(struct st_master_info* mi);
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
}; };
/* the classes below are for the new LOAD DATA INFILE logging */ /* the classes below are for the new LOAD DATA INFILE logging */
class Create_file_log_event: public Load_log_event class Create_file_log_event: public Load_log_event
{ {
protected: protected:
// pretend we are Load event, so we can write out just /*
// our Load part - used on the slave when writing event out to Pretend we are Load event, so we can write out just
// SQL_LOAD-*.info file our Load part - used on the slave when writing event out to
SQL_LOAD-*.info file
*/
bool fake_base; bool fake_base;
public: public:
char* block; char* block;
uint block_len; uint block_len;
uint file_id; uint file_id;
Create_file_log_event(const char* buf, int event_len);
~Create_file_log_event()
{
}
Log_event_type get_type_code()
{
return fake_base ? Load_log_event::get_type_code() : CREATE_FILE_EVENT;
}
int get_data_size()
{
return (fake_base ? Load_log_event::get_data_size() :
Load_log_event::get_data_size() +
4 + 1 + block_len);
}
int get_data_body_offset()
{
return (fake_base ? LOAD_EVENT_OVERHEAD:
LOAD_EVENT_OVERHEAD + CREATE_FILE_HEADER_LEN);
}
bool is_valid() { return block != 0; }
int write_data_header(IO_CACHE* file);
int write_data_body(IO_CACHE* file);
/*
Cut out Create_file extentions and write it as Load event - used on the
slave.
*/
int write_base(IO_CACHE* file);
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg, Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
const char* table_name_arg, const char* table_name_arg,
List<Item>& fields_arg, List<Item>& fields_arg,
enum enum_duplicates handle_dup, enum enum_duplicates handle_dup,
char* block_arg, uint block_len_arg); char* block_arg, uint block_len_arg);
#endif
Create_file_log_event(const char* buf, int event_len);
~Create_file_log_event()
{
}
Log_event_type get_type_code()
{
return fake_base ? Load_log_event::get_type_code() : CREATE_FILE_EVENT;
}
int get_data_size() { return fake_base ? Load_log_event::get_data_size() :
Load_log_event::get_data_size() +
4 + 1 + block_len;}
int get_data_body_offset() { return fake_base ? LOAD_EVENT_OVERHEAD:
LOAD_EVENT_OVERHEAD + CREATE_FILE_HEADER_LEN; }
bool is_valid() { return block != 0; }
int write_data_header(IO_CACHE* file);
int write_data_body(IO_CACHE* file);
int write_base(IO_CACHE* file); // cut out Create_file extentions and
// write it as Load event - used on the slave
#ifdef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif
#ifndef MYSQL_CLIENT
void pack_info(String* packet); void pack_info(String* packet);
int exec_event(struct st_master_info* mi); int exec_event(struct st_master_info* mi);
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
}; };
class Append_block_log_event: public Log_event class Append_block_log_event: public Log_event
{ {
public: public:
@ -613,12 +606,6 @@ public:
uint block_len; uint block_len;
uint file_id; uint file_id;
#ifndef MYSQL_CLIENT
Append_block_log_event(THD* thd, char* block_arg,
uint block_len_arg);
int exec_event(struct st_master_info* mi);
#endif
Append_block_log_event(const char* buf, int event_len); Append_block_log_event(const char* buf, int event_len);
~Append_block_log_event() ~Append_block_log_event()
{ {
@ -628,23 +615,22 @@ public:
bool is_valid() { return block != 0; } bool is_valid() { return block != 0; }
int write_data(IO_CACHE* file); int write_data(IO_CACHE* file);
#ifdef MYSQL_CLIENT #ifndef MYSQL_CLIENT
Append_block_log_event(THD* thd, char* block_arg,
uint block_len_arg);
int exec_event(struct st_master_info* mi);
void pack_info(String* packet);
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0); void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
#ifndef MYSQL_CLIENT
void pack_info(String* packet);
#endif
}; };
class Delete_file_log_event: public Log_event class Delete_file_log_event: public Log_event
{ {
public: public:
uint file_id; uint file_id;
#ifndef MYSQL_CLIENT
Delete_file_log_event(THD* thd);
#endif
Delete_file_log_event(const char* buf, int event_len); Delete_file_log_event(const char* buf, int event_len);
~Delete_file_log_event() ~Delete_file_log_event()
{ {
@ -654,12 +640,12 @@ public:
bool is_valid() { return file_id != 0; } bool is_valid() { return file_id != 0; }
int write_data(IO_CACHE* file); int write_data(IO_CACHE* file);
#ifdef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
Delete_file_log_event(THD* thd);
void pack_info(String* packet); void pack_info(String* packet);
int exec_event(struct st_master_info* mi); int exec_event(struct st_master_info* mi);
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
}; };
@ -668,10 +654,6 @@ class Execute_load_log_event: public Log_event
public: public:
uint file_id; uint file_id;
#ifndef MYSQL_CLIENT
Execute_load_log_event(THD* thd);
#endif
Execute_load_log_event(const char* buf, int event_len); Execute_load_log_event(const char* buf, int event_len);
~Execute_load_log_event() ~Execute_load_log_event()
{ {
@ -681,16 +663,13 @@ public:
bool is_valid() { return file_id != 0; } bool is_valid() { return file_id != 0; }
int write_data(IO_CACHE* file); int write_data(IO_CACHE* file);
#ifdef MYSQL_CLIENT
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif
#ifndef MYSQL_CLIENT #ifndef MYSQL_CLIENT
Execute_load_log_event(THD* thd);
void pack_info(String* packet); void pack_info(String* packet);
int exec_event(struct st_master_info* mi); int exec_event(struct st_master_info* mi);
#else
void print(FILE* file, bool short_form = 0, char* last_db = 0);
#endif #endif
}; };
#endif #endif /* _LOG_EVENT_H */

4
sql/mf_iocache.cc
View File

@ -50,14 +50,14 @@ extern "C" {
int _my_b_net_read(register IO_CACHE *info, byte *Buffer, int _my_b_net_read(register IO_CACHE *info, byte *Buffer,
uint Count __attribute__((unused))) uint Count __attribute__((unused)))
{ {
int read_length; ulong read_length;
NET *net= &(current_thd)->net; NET *net= &(current_thd)->net;
DBUG_ENTER("_my_b_net_read"); DBUG_ENTER("_my_b_net_read");
if (!info->end_of_file) if (!info->end_of_file)
DBUG_RETURN(1); /* because my_b_get (no _) takes 1 byte at a time */ DBUG_RETURN(1); /* because my_b_get (no _) takes 1 byte at a time */
read_length=my_net_read(net); read_length=my_net_read(net);
if (read_length == (int) packet_error) if (read_length == packet_error)
{ {
info->error= -1; info->error= -1;
DBUG_RETURN(1); DBUG_RETURN(1);

2
sql/mysql_priv.h
View File

@ -332,7 +332,7 @@ int mysql_select(THD *thd,TABLE_LIST *tables,List<Item> &list,COND *conds,
ORDER *order, ORDER *group,Item *having,ORDER *proc_param, ORDER *order, ORDER *group,Item *having,ORDER *proc_param,
ulong select_type,select_result *result); ulong select_type,select_result *result);
int mysql_union(THD *thd,LEX *lex,select_result *result); int mysql_union(THD *thd,LEX *lex,select_result *result);
Field *create_tmp_field(TABLE *table,Item *item, Item::Type type, Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
Item_result_field ***copy_func, Field **from_field, Item_result_field ***copy_func, Field **from_field,
bool group,bool modify_item); bool group,bool modify_item);
int mysql_create_table(THD *thd,const char *db, const char *table_name, int mysql_create_table(THD *thd,const char *db, const char *table_name,

12
sql/mysqld.cc
View File

@ -3091,8 +3091,8 @@ struct show_var_st init_vars[]= {
{"record_rnd_buffer", (char*) &record_rnd_cache_size, SHOW_LONG}, {"record_rnd_buffer", (char*) &record_rnd_cache_size, SHOW_LONG},
{"rpl_recovery_rank", (char*) &rpl_recovery_rank, SHOW_LONG}, {"rpl_recovery_rank", (char*) &rpl_recovery_rank, SHOW_LONG},
{"query_buffer_size", (char*) &query_buff_size, SHOW_LONG}, {"query_buffer_size", (char*) &query_buff_size, SHOW_LONG},
{"query_cache_limit", (char*) &query_cache_limit, SHOW_LONG}, {"query_cache_limit", (char*) &query_cache.query_cache_limit, SHOW_LONG},
{"query_cache_size", (char*) &query_cache_size, SHOW_LONG}, {"query_cache_size", (char*) &query_cache.query_cache_size, SHOW_LONG},
{"query_cache_startup_type",(char*) &query_cache_startup_type, SHOW_LONG}, {"query_cache_startup_type",(char*) &query_cache_startup_type, SHOW_LONG},
{"safe_show_database", (char*) &opt_safe_show_db, SHOW_BOOL}, {"safe_show_database", (char*) &opt_safe_show_db, SHOW_BOOL},
{"server_id", (char*) &server_id, SHOW_LONG}, {"server_id", (char*) &server_id, SHOW_LONG},
@ -3157,11 +3157,11 @@ struct show_var_st status_vars[]= {
{"Open_streams", (char*) &my_stream_opened, SHOW_INT_CONST}, {"Open_streams", (char*) &my_stream_opened, SHOW_INT_CONST},
{"Opened_tables", (char*) &opened_tables, SHOW_LONG}, {"Opened_tables", (char*) &opened_tables, SHOW_LONG},
{"Questions", (char*) 0, SHOW_QUESTION}, {"Questions", (char*) 0, SHOW_QUESTION},
{"Qcache_queries", (char*) &query_cache.queries_in_cache, {"Qcache_queries_in_cache", (char*) &query_cache.queries_in_cache,
SHOW_LONG}, SHOW_LONG},
{"Qcache_inserts", (char*) &query_cache.inserts, SHOW_LONG}, {"Qcache_inserts", (char*) &query_cache.inserts, SHOW_LONG},
{"Qcache_hits", (char*) &query_cache.hits, SHOW_LONG}, {"Qcache_hits", (char*) &query_cache.hits, SHOW_LONG},
{"Qcache_refused", (char*) &query_cache.refused, SHOW_LONG}, {"Qcache_not_cached", (char*) &query_cache.refused, SHOW_LONG},
{"Qcache_free_memory", (char*) &query_cache.free_memory,SHOW_LONG}, {"Qcache_free_memory", (char*) &query_cache.free_memory,SHOW_LONG},
{"Rpl_status", (char*) 0, SHOW_RPL_STATUS}, {"Rpl_status", (char*) 0, SHOW_RPL_STATUS},
{"Select_full_join", (char*) &select_full_join_count, SHOW_LONG}, {"Select_full_join", (char*) &select_full_join_count, SHOW_LONG},
@ -3726,12 +3726,11 @@ static void get_options(int argc,char **argv)
opt_slow_log=1; opt_slow_log=1;
opt_slow_logname=optarg; opt_slow_logname=optarg;
break; break;
case (int)OPT_SKIP_SLAVE_START: case (int) OPT_SKIP_SLAVE_START:
opt_skip_slave_start = 1; opt_skip_slave_start = 1;
break; break;
case (int) OPT_SKIP_NEW: case (int) OPT_SKIP_NEW:
opt_specialflag|= SPECIAL_NO_NEW_FUNC; opt_specialflag|= SPECIAL_NO_NEW_FUNC;
default_table_type=DB_TYPE_ISAM;
myisam_delay_key_write=0; myisam_delay_key_write=0;
myisam_concurrent_insert=0; myisam_concurrent_insert=0;
myisam_recover_options= HA_RECOVER_NONE; myisam_recover_options= HA_RECOVER_NONE;
@ -3739,6 +3738,7 @@ static void get_options(int argc,char **argv)
my_use_symdir=0; my_use_symdir=0;
have_symlink=SHOW_OPTION_DISABLED; have_symlink=SHOW_OPTION_DISABLED;
ha_open_options&= ~HA_OPEN_ABORT_IF_CRASHED; ha_open_options&= ~HA_OPEN_ABORT_IF_CRASHED;
query_cache_size=0;
break; break;
case (int) OPT_SAFE: case (int) OPT_SAFE:
opt_specialflag|= SPECIAL_SAFE_MODE; opt_specialflag|= SPECIAL_SAFE_MODE;

36
sql/net_serv.cc
View File

@ -109,7 +109,7 @@ static int net_write_buff(NET *net,const char *packet,ulong len);
int my_net_init(NET *net, Vio* vio) int my_net_init(NET *net, Vio* vio)
{ {
if (!(net->buff=(uchar*) my_malloc(net_buffer_length+ if (!(net->buff=(uchar*) my_malloc((uint32) net_buffer_length+
NET_HEADER_SIZE + COMP_HEADER_SIZE, NET_HEADER_SIZE + COMP_HEADER_SIZE,
MYF(MY_WME)))) MYF(MY_WME))))
return 1; return 1;
@ -162,7 +162,7 @@ static my_bool net_realloc(NET *net, ulong length)
pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1); pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1);
/* We must allocate some extra bytes for the end 0 and to be able to /* We must allocate some extra bytes for the end 0 and to be able to
read big compressed blocks */ read big compressed blocks */
if (!(buff=(uchar*) my_realloc((char*) net->buff, pkt_length + if (!(buff=(uchar*) my_realloc((char*) net->buff, (uint32) pkt_length +
NET_HEADER_SIZE + COMP_HEADER_SIZE, NET_HEADER_SIZE + COMP_HEADER_SIZE,
MYF(MY_WME)))) MYF(MY_WME))))
{ {
@ -189,7 +189,7 @@ void net_clear(NET *net)
if (!vio_is_blocking(net->vio)) /* Safety if SSL */ if (!vio_is_blocking(net->vio)) /* Safety if SSL */
{ {
while ( (count = vio_read(net->vio, (char*) (net->buff), while ( (count = vio_read(net->vio, (char*) (net->buff),
net->max_packet)) > 0) (uint32) net->max_packet)) > 0)
DBUG_PRINT("info",("skipped %d bytes from file: %s", DBUG_PRINT("info",("skipped %d bytes from file: %s",
count,vio_description(net->vio))); count,vio_description(net->vio)));
if (is_blocking) if (is_blocking)
@ -243,7 +243,7 @@ my_net_write(NET *net,const char *packet,ulong len)
{ {
const ulong z_size = MAX_THREE_BYTES; const ulong z_size = MAX_THREE_BYTES;
int3store(buff, z_size); int3store(buff, z_size);
buff[3]= net->pkt_nr++; buff[3]= (uchar) net->pkt_nr++;
if (net_write_buff(net, (char*) buff, NET_HEADER_SIZE) || if (net_write_buff(net, (char*) buff, NET_HEADER_SIZE) ||
net_write_buff(net, packet, z_size)) net_write_buff(net, packet, z_size))
return 1; return 1;
@ -252,7 +252,7 @@ my_net_write(NET *net,const char *packet,ulong len)
} }
/* Write last packet */ /* Write last packet */
int3store(buff,len); int3store(buff,len);
buff[3]= net->pkt_nr++; buff[3]= (uchar) net->pkt_nr++;
if (net_write_buff(net,(char*) buff,NET_HEADER_SIZE)) if (net_write_buff(net,(char*) buff,NET_HEADER_SIZE))
return 1; return 1;
return net_write_buff(net,packet,len); return net_write_buff(net,packet,len);
@ -282,7 +282,7 @@ net_write_command(NET *net,uchar command,const char *packet,ulong len)
do do
{ {
int3store(buff, MAX_THREE_BYTES); int3store(buff, MAX_THREE_BYTES);
buff[3]= net->pkt_nr++; buff[3]= (uchar) net->pkt_nr++;
if (net_write_buff(net,(char*) buff, header_size) || if (net_write_buff(net,(char*) buff, header_size) ||
net_write_buff(net,packet,len)) net_write_buff(net,packet,len))
return 1; return 1;
@ -294,7 +294,7 @@ net_write_command(NET *net,uchar command,const char *packet,ulong len)
len=length; /* Data left to be written */ len=length; /* Data left to be written */
} }
int3store(buff,length); int3store(buff,length);
buff[3]= net->pkt_nr++; buff[3]= (uchar) net->pkt_nr++;
return test(net_write_buff(net,(char*) buff,header_size) || return test(net_write_buff(net,(char*) buff,header_size) ||
net_write_buff(net,packet,len) || net_flush(net)); net_write_buff(net,packet,len) || net_flush(net));
} }
@ -357,8 +357,8 @@ net_real_write(NET *net,const char *packet,ulong len)
ulong complen; ulong complen;
uchar *b; uchar *b;
uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE; uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
if (!(b=(uchar*) my_malloc(len + NET_HEADER_SIZE + COMP_HEADER_SIZE, if (!(b=(uchar*) my_malloc((uint32) len + NET_HEADER_SIZE +
MYF(MY_WME)))) COMP_HEADER_SIZE, MYF(MY_WME))))
{ {
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
net->last_errno=ER_OUT_OF_RESOURCES; net->last_errno=ER_OUT_OF_RESOURCES;
@ -395,7 +395,7 @@ net_real_write(NET *net,const char *packet,ulong len)
pos=(char*) packet; end=pos+len; pos=(char*) packet; end=pos+len;
while (pos != end) while (pos != end)
{ {
if ((long) (length=vio_write(net->vio,pos,(ulong) (end-pos))) <= 0) if ((long) (length=vio_write(net->vio,pos,(uint32) (end-pos))) <= 0)
{ {
my_bool interrupted = vio_should_retry(net->vio); my_bool interrupted = vio_should_retry(net->vio);
#if (!defined(__WIN__) && !defined(__EMX__) && !defined(OS2)) #if (!defined(__WIN__) && !defined(__EMX__) && !defined(OS2))
@ -479,7 +479,7 @@ net_real_write(NET *net,const char *packet,ulong len)
big packet big packet
*/ */
static void my_net_skip_rest(NET *net, ulong remain, thr_alarm_t *alarmed) static void my_net_skip_rest(NET *net, uint32 remain, thr_alarm_t *alarmed)
{ {
ALARM alarm_buff; ALARM alarm_buff;
uint retry_count=0; uint retry_count=0;
@ -502,7 +502,7 @@ static void my_net_skip_rest(NET *net, ulong remain, thr_alarm_t *alarmed)
} }
return; return;
} }
remain -= length; remain -= (uint32) length;
statistic_add(bytes_received,length,&LOCK_bytes_received); statistic_add(bytes_received,length,&LOCK_bytes_received);
} }
} }
@ -527,8 +527,8 @@ my_real_read(NET *net, ulong *complen)
ALARM alarm_buff; ALARM alarm_buff;
#endif #endif
my_bool net_blocking=vio_is_blocking(net->vio); my_bool net_blocking=vio_is_blocking(net->vio);
ulong remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE : uint32 remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
NET_HEADER_SIZE); NET_HEADER_SIZE);
*complen = 0; *complen = 0;
net->reading_or_writing=1; net->reading_or_writing=1;
@ -605,7 +605,7 @@ my_real_read(NET *net, ulong *complen)
continue; continue;
} }
#endif #endif
DBUG_PRINT("error",("Couldn't read packet: remain: %d errno: %d length: %d alarmed: %d", remain,vio_errno(net->vio),length,alarmed)); DBUG_PRINT("error",("Couldn't read packet: remain: %lu errno: %d length: %ld alarmed: %d", remain,vio_errno(net->vio),length,alarmed));
len= packet_error; len= packet_error;
net->error=2; /* Close socket */ net->error=2; /* Close socket */
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
@ -614,7 +614,7 @@ my_real_read(NET *net, ulong *complen)
#endif #endif
goto end; goto end;
} }
remain -= (ulong) length; remain -= (uint32) length;
pos+= (ulong) length; pos+= (ulong) length;
statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received); statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received);
} }
@ -661,14 +661,14 @@ my_real_read(NET *net, ulong *complen)
{ {
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
if (i == 1) if (i == 1)
my_net_skip_rest(net, len, &alarmed); my_net_skip_rest(net, (uint32) len, &alarmed);
#endif #endif
len= packet_error; /* Return error */ len= packet_error; /* Return error */
goto end; goto end;
} }
} }
pos=net->buff + net->where_b; pos=net->buff + net->where_b;
remain = len; remain = (uint32) len;
} }
} }

6
sql/opt_range.h
View File

@ -48,9 +48,9 @@ class QUICK_RANGE :public Sql_alloc {
uint flag_arg) uint flag_arg)
: min_key((char*) sql_memdup(min_key_arg,min_length_arg+1)), : min_key((char*) sql_memdup(min_key_arg,min_length_arg+1)),
max_key((char*) sql_memdup(max_key_arg,max_length_arg+1)), max_key((char*) sql_memdup(max_key_arg,max_length_arg+1)),
min_length(min_length_arg), min_length((uint16) min_length_arg),
max_length(max_length_arg), max_length((uint16) max_length_arg),
flag(flag_arg) flag((uint16) flag_arg)
{} {}
}; };

2624
sql/sql_cache.cc
View File

File diff suppressed because it is too large Load Diff

198
sql/sql_cache.h
View File

@ -66,7 +66,7 @@ struct Query_cache_block_table
TABLE_COUNTER_TYPE n; // numbr in table (from 0) TABLE_COUNTER_TYPE n; // numbr in table (from 0)
Query_cache_block_table *next, *prev; Query_cache_block_table *next, *prev;
Query_cache_table *parent; Query_cache_table *parent;
inline Query_cache_block * block(); inline Query_cache_block *block();
}; };
@ -82,30 +82,28 @@ struct Query_cache_block
*pprev to join free blocks *pprev to join free blocks
*prev to access to opposite side of list in cyclic sorted list *prev to access to opposite side of list in cyclic sorted list
*/ */
Query_cache_block Query_cache_block *pnext,*pprev, // physical next/previous block
*pnext,*pprev, // physical next/previous block *next,*prev; // logical next/previous block
*next,*prev; // logical next/previous block
block_type type; block_type type;
TABLE_COUNTER_TYPE n_tables; // number of tables in query TABLE_COUNTER_TYPE n_tables; // number of tables in query
inline my_bool is_free(void) { return type == FREE; } inline my_bool is_free(void) { return type == FREE; }
void init(ulong length); void init(ulong length);
void destroy(); void destroy();
inline uint headers_len(); inline uint headers_len();
inline gptr data(void); inline gptr data(void);
inline Query_cache_query * query(); inline Query_cache_query *query();
inline Query_cache_table * table(); inline Query_cache_table *table();
inline Query_cache_result * result(); inline Query_cache_result *result();
inline Query_cache_block_table * table(TABLE_COUNTER_TYPE n); inline Query_cache_block_table *table(TABLE_COUNTER_TYPE n);
}; };
struct Query_cache_query struct Query_cache_query
{ {
ulonglong limit_found_rows; ulonglong limit_found_rows;
Query_cache_block * res; Query_cache_block *res;
NET * wri; NET *wri;
ulong len; ulong len;
sem_t lock; // R/W lock of block sem_t lock; // R/W lock of block
pthread_mutex_t clients_guard; pthread_mutex_t clients_guard;
@ -115,9 +113,9 @@ struct Query_cache_query
void unlock_n_destroy(); void unlock_n_destroy();
inline ulonglong found_rows() { return limit_found_rows; } inline ulonglong found_rows() { return limit_found_rows; }
inline void found_rows(ulonglong rows) { limit_found_rows = rows; } inline void found_rows(ulonglong rows) { limit_found_rows = rows; }
inline Query_cache_block * result() { return res; } inline Query_cache_block *result() { return res; }
inline void result(Query_cache_block *p) { res=p; } inline void result(Query_cache_block *p) { res=p; }
inline NET * writer() { return wri; } inline NET *writer() { return wri; }
inline void writer(NET *p) { wri=p; } inline void writer(NET *p) { wri=p; }
inline ulong length() { return len; } inline ulong length() { return len; }
inline ulong add(ulong packet_len) { return(len += packet_len); } inline ulong add(ulong packet_len) { return(len += packet_len); }
@ -132,9 +130,7 @@ struct Query_cache_query
my_bool try_lock_writing(); my_bool try_lock_writing();
void unlock_writing(); void unlock_writing();
void unlock_reading(); void unlock_reading();
static byte * cache_key(const byte *record, uint *length, static byte *cache_key(const byte *record, uint *length, my_bool not_used);
my_bool not_used);
static void free_cache(void *entry);
}; };
@ -146,44 +142,45 @@ struct Query_cache_table
return (type == DB_TYPE_INNODB ? INNODB : OTHER); return (type == DB_TYPE_INNODB ? INNODB : OTHER);
} }
char * tbl; char *tbl;
query_cache_table_type tp; query_cache_table_type tp;
inline query_cache_table_type type() { return tp; } inline query_cache_table_type type() { return tp; }
inline void type(query_cache_table_type t) { tp = t;} inline void type(query_cache_table_type t) { tp = t;}
inline char * db() { return (char *) data(); } inline char *db() { return (char *) data(); }
inline char * table() { return tbl; } inline char *table() { return tbl; }
inline void table(char * table) { tbl = table; } inline void table(char *table) { tbl = table; }
inline gptr data() inline gptr data()
{ {
return (gptr)(((byte*)this)+ return (gptr)(((byte*)this)+
ALIGN_SIZE(sizeof(Query_cache_table))); ALIGN_SIZE(sizeof(Query_cache_table)));
} }
static byte * cache_key(const byte *record, uint *length,
my_bool not_used);
static void free_cache(void *entry);
}; };
struct Query_cache_result struct Query_cache_result
{ {
Query_cache_block *query; Query_cache_block *query;
inline gptr data(){return (gptr)(((byte*)this)+ inline gptr data()
ALIGN_SIZE(sizeof(Query_cache_result)));} {
return (gptr)(((byte*) this)+
ALIGN_SIZE(sizeof(Query_cache_result)));
}
/* data_continue (if not whole packet contained by this block) */ /* data_continue (if not whole packet contained by this block) */
inline Query_cache_block * parent() { return query; } inline Query_cache_block *parent() { return query; }
inline void parent (Query_cache_block *p) { query=p; } inline void parent (Query_cache_block *p) { query=p; }
}; };
extern "C" { extern "C" {
byte *query_cache_query_get_key(const byte *record, uint *length,
my_bool not_used);
byte *query_cache_table_get_key(const byte *record, uint *length,
my_bool not_used);
void query_cache_insert(THD *thd, const char *packet, ulong length); void query_cache_insert(THD *thd, const char *packet, ulong length);
void query_cache_end_of_result(THD *thd); void query_cache_end_of_result(THD *thd);
void query_cache_abort(THD *thd); void query_cache_abort(THD *thd);
void query_cache_invalidate_by_MyISAM_filename(char* filename); void query_cache_invalidate_by_MyISAM_filename(const char* filename);
} }
struct Query_cache_memory_bin struct Query_cache_memory_bin
@ -192,7 +189,7 @@ struct Query_cache_memory_bin
ulong size; ulong size;
#endif #endif
uint number; uint number;
Query_cache_block * free_blocks; Query_cache_block *free_blocks;
inline void init(ulong size) inline void init(ulong size)
{ {
@ -219,94 +216,92 @@ struct Query_cache_memory_bin_step
class Query_cache class Query_cache
{ {
protected:
byte * cache; // cache memory
Query_cache_block *first_block; // physical location block list
Query_cache_block *queries_blocks; // query list (LIFO)
Query_cache_block *tables_blocks[Query_cache_table::TYPES_NUMBER];
Query_cache_memory_bin * bins; // free block lists
Query_cache_memory_bin_step * steps; // bins spacing info
uint mem_bin_num, mem_bin_steps; // See at init_cache & find_bin
/* options */
ulong query_cache_size, query_cache_limit,
min_allocation_unit, min_result_data_size;
uint def_query_hash_size, def_table_hash_size;
/* statistics */
public: public:
/* Info */
ulong query_cache_size, query_cache_limit;
/* statistics */
ulong free_memory, queries_in_cache, hits, inserts, refused; ulong free_memory, queries_in_cache, hits, inserts, refused;
protected:
my_bool initialized;
protected:
/* /*
Locked when searched or changed global query or The following mutex is locked when searching or changing global
tables lists or hashes. When operate inside query, tables lists or hashes. When we are operating inside the
query structure locked own query block mutex query structure we locked an internal query block mutex.
LOCK SEQUENCE (to prevent clinch): LOCK SEQUENCE (to prevent deadlocks):
1. structure_guard_mutex 1. structure_guard_mutex
2. query block / table block / free block 2. query block / table block / free block
3. results blocks (only when must become free). 3. results blocks (only when must become free).
*/ */
pthread_mutex_t structure_guard_mutex; pthread_mutex_t structure_guard_mutex;
byte *cache; // cache memory
Query_cache_block *first_block; // physical location block list
Query_cache_block *queries_blocks; // query list (LIFO)
Query_cache_block *tables_blocks[Query_cache_table::TYPES_NUMBER];
Query_cache_memory_bin *bins; // free block lists
Query_cache_memory_bin_step *steps; // bins spacing info
HASH queries, tables; HASH queries, tables;
uint mem_bin_num, mem_bin_steps; // See at init_cache & find_bin
my_bool initialized;
/* options */
ulong min_allocation_unit, min_result_data_size;
uint def_query_hash_size, def_table_hash_size;
/* Exclude/include from cyclic double linked list */ /* Exclude/include from cyclic double linked list */
static void double_linked_list_exclude(Query_cache_block * point, static void double_linked_list_exclude(Query_cache_block *point,
Query_cache_block * &list_pointer); Query_cache_block **list_pointer);
static void double_linked_list_simple_include(Query_cache_block * point, static void double_linked_list_simple_include(Query_cache_block *point,
Query_cache_block * Query_cache_block **
&list_pointer); list_pointer);
static void double_linked_list_join(Query_cache_block *head_tail, static void double_linked_list_join(Query_cache_block *head_tail,
Query_cache_block *tail_head); Query_cache_block *tail_head);
/* Table key generation */ /* Table key generation */
static uint filename_2_table_key (char * key, char *filename); static uint filename_2_table_key (char *key, const char *filename);
/* Following function work properly only when structure_guard_mutex locked */ /* The following functions require that structure_guard_mutex is locked */
void flush_cache(); void flush_cache();
my_bool free_old_query(); my_bool free_old_query();
void free_query(Query_cache_block * point); void free_query(Query_cache_block *point);
my_bool allocate_data_chain(Query_cache_block * &result_block, my_bool allocate_data_chain(Query_cache_block **result_block,
ulong data_len, ulong data_len,
Query_cache_block * query_block); Query_cache_block *query_block);
void invalidate_table(TABLE_LIST *table); void invalidate_table(TABLE_LIST *table);
void invalidate_table(TABLE *table); void invalidate_table(TABLE *table);
void invalidate_table_in_db(Query_cache_block *table_block, void invalidate_table_in_db(Query_cache_block *table_block,
char * db); char *db);
void invalidate_table(Query_cache_block *table_block); void invalidate_table(Query_cache_block *table_block);
my_bool register_all_tables(Query_cache_block * block, my_bool register_all_tables(Query_cache_block *block,
TABLE_LIST * tables_used, TABLE_LIST *tables_used,
TABLE_COUNTER_TYPE tables); TABLE_COUNTER_TYPE tables);
my_bool insert_table(uint key_len, char * key, my_bool insert_table(uint key_len, char *key,
Query_cache_block_table * node, Query_cache_block_table *node,
Query_cache_table::query_cache_table_type type); Query_cache_table::query_cache_table_type type);
void unlink_table(Query_cache_block_table * node); void unlink_table(Query_cache_block_table *node);
Query_cache_block * get_free_block (ulong len, my_bool not_less, Query_cache_block *get_free_block (ulong len, my_bool not_less,
ulong min); ulong min);
void free_memory_block(Query_cache_block * point); void free_memory_block(Query_cache_block *point);
void split_block(Query_cache_block *block, ulong len); void split_block(Query_cache_block *block, ulong len);
Query_cache_block * join_free_blocks(Query_cache_block *first_block, Query_cache_block *join_free_blocks(Query_cache_block *first_block,
Query_cache_block * block_in_list); Query_cache_block *block_in_list);
my_bool append_next_free_block(Query_cache_block * block, my_bool append_next_free_block(Query_cache_block *block,
ulong add_size); ulong add_size);
void exclude_from_free_memory_list(Query_cache_block * free_block); void exclude_from_free_memory_list(Query_cache_block *free_block);
void insert_into_free_memory_list(Query_cache_block * new_block); void insert_into_free_memory_list(Query_cache_block *new_block);
my_bool move_by_type(byte * &border, Query_cache_block * &before, my_bool move_by_type(byte **border, Query_cache_block **before,
ulong &gap, Query_cache_block * i); ulong *gap, Query_cache_block *i);
uint find_bin(ulong size); uint find_bin(ulong size);
void move_to_query_list_end(Query_cache_block * block); void move_to_query_list_end(Query_cache_block *block);
void insert_into_free_memory_sorted_list(Query_cache_block * new_block, void insert_into_free_memory_sorted_list(Query_cache_block *new_block,
Query_cache_block * &list); Query_cache_block **list);
void pack_cache(); void pack_cache();
void relink(Query_cache_block * oblock, void relink(Query_cache_block *oblock,
Query_cache_block * nblock, Query_cache_block *nblock,
Query_cache_block * next, Query_cache_block *next,
Query_cache_block * prev, Query_cache_block *prev,
Query_cache_block * pnext, Query_cache_block *pnext,
Query_cache_block * pprev); Query_cache_block *pprev);
my_bool join_results(ulong join_limit); my_bool join_results(ulong join_limit);
/* /*
@ -317,38 +312,35 @@ protected:
ulong init_cache(); ulong init_cache();
void make_disabled(); void make_disabled();
void free_cache(my_bool destruction); void free_cache(my_bool destruction);
Query_cache_block * write_block_data(ulong data_len, gptr data, Query_cache_block *write_block_data(ulong data_len, gptr data,
ulong header_len, ulong header_len,
Query_cache_block::block_type type, Query_cache_block::block_type type,
TABLE_COUNTER_TYPE ntab = 0, TABLE_COUNTER_TYPE ntab = 0,
my_bool under_guard=0); my_bool under_guard=0);
my_bool append_result_data(Query_cache_block * &result, my_bool append_result_data(Query_cache_block **result,
ulong data_len, gptr data, ulong data_len, gptr data,
Query_cache_block * parent, Query_cache_block *parent);
Query_cache_block * first_data_block); my_bool write_result_data(Query_cache_block **result,
my_bool write_result_data(Query_cache_block * &result,
ulong data_len, gptr data, ulong data_len, gptr data,
Query_cache_block * parent, Query_cache_block *parent,
Query_cache_block::block_type Query_cache_block::block_type
type=Query_cache_block::RESULT); type=Query_cache_block::RESULT);
Query_cache_block * allocate_block(ulong len, my_bool not_less, Query_cache_block *allocate_block(ulong len, my_bool not_less,
ulong min, ulong min,
my_bool under_guard=0); my_bool under_guard=0);
/* /*
If query is cachable return numder tables in query If query is cacheable return number tables in query
(query without tables not cached) (query without tables not cached)
*/ */
TABLE_COUNTER_TYPE is_cachable(THD *thd, uint query_len, char *query, TABLE_COUNTER_TYPE is_cacheable(THD *thd, uint32 query_len, char *query,
LEX *lex, LEX *lex, TABLE_LIST *tables_used);
TABLE_LIST *tables_used);
public: public:
Query_cache(ulong query_cache_limit = ULONG_MAX, Query_cache(ulong query_cache_limit = ULONG_MAX,
ulong min_allocation_unit = QUERY_CACHE_MIN_ALLOCATION_UNIT, ulong min_allocation_unit = QUERY_CACHE_MIN_ALLOCATION_UNIT,
ulong min_result_data_size = QUERY_CACHE_MIN_RESULT_DATA_SIZE, ulong min_result_data_size = QUERY_CACHE_MIN_RESULT_DATA_SIZE,
uint def_query_hash_size = QUERY_CACHE_DEF_QUERY_HASH_SIZE, uint def_query_hash_size = QUERY_CACHE_DEF_QUERY_HASH_SIZE,
uint def_table_hash_size = QUERY_CACHE_DEF_TABLE_HASH_SIZE uint def_table_hash_size = QUERY_CACHE_DEF_TABLE_HASH_SIZE);
);
/* resize query cache (return real query size, 0 if disabled) */ /* resize query cache (return real query size, 0 if disabled) */
ulong resize(ulong query_cache_size); ulong resize(ulong query_cache_size);
@ -371,10 +363,10 @@ protected:
void invalidate(Query_cache_table::query_cache_table_type type); void invalidate(Query_cache_table::query_cache_table_type type);
/* Remove all queries that uses any of the tables in following database */ /* Remove all queries that uses any of the tables in following database */
void invalidate(char * db); void invalidate(char *db);
/* Remove all queries that uses any of the listed following table */ /* Remove all queries that uses any of the listed following table */
void invalidate_by_MyISAM_filename(char * filename); void invalidate_by_MyISAM_filename(const char *filename);
/* Remove all queries from cache */ /* Remove all queries from cache */
void flush(); void flush();
@ -386,7 +378,7 @@ protected:
void destroy(); void destroy();
#ifndef DBUG_OFF #ifndef DBUG_OFF
void wreck(uint line, const char * message); void wreck(uint line, const char *message);
void bins_dump(); void bins_dump();
void cache_dump(); void cache_dump();
void queries_dump(); void queries_dump();

83
sql/sql_class.h
View File

@ -236,35 +236,35 @@ class delayed_insert;
class THD :public ilink { class THD :public ilink {
public: public:
NET net; NET net;
LEX lex; LEX lex;
MEM_ROOT mem_root; MEM_ROOT mem_root;
HASH user_vars; HASH user_vars;
String packet; /* Room for 1 row */ String packet; /* Room for 1 row */
struct sockaddr_in remote; struct sockaddr_in remote;
struct rand_struct rand; struct rand_struct rand;
char *query,*thread_stack; char *query,*thread_stack;
char *host,*user,*priv_user,*db,*ip; char *host,*user,*priv_user,*db,*ip;
const char *proc_info, *host_or_ip; const char *proc_info, *host_or_ip;
uint client_capabilities,sql_mode,max_packet_length; uint client_capabilities,sql_mode,max_packet_length;
uint master_access,db_access; uint master_access,db_access;
TABLE *open_tables,*temporary_tables, *handler_tables; TABLE *open_tables,*temporary_tables, *handler_tables;
MYSQL_LOCK *lock,*locked_tables; MYSQL_LOCK *lock,*locked_tables;
ULL *ull; ULL *ull;
struct st_my_thread_var *mysys_var; struct st_my_thread_var *mysys_var;
enum enum_server_command command; enum enum_server_command command;
uint32 server_id; uint32 server_id;
uint32 log_seq; uint32 log_seq;
uint32 file_id; // for LOAD DATA INFILE uint32 file_id; // for LOAD DATA INFILE
const char *where; const char *where;
time_t start_time,time_after_lock,user_time; time_t start_time,time_after_lock,user_time;
time_t connect_time,thr_create_time; // track down slow pthread_create time_t connect_time,thr_create_time; // track down slow pthread_create
thr_lock_type update_lock_default; thr_lock_type update_lock_default;
delayed_insert *di; delayed_insert *di;
struct st_transactions { struct st_transactions {
IO_CACHE trans_log; IO_CACHE trans_log;
THD_TRANS all; /* Trans since BEGIN WORK */ THD_TRANS all; // Trans since BEGIN WORK
THD_TRANS stmt; /* Trans for current statement */ THD_TRANS stmt; // Trans for current statement
uint bdb_lock_count; uint bdb_lock_count;
} transaction; } transaction;
Item *free_list, *handler_items; Item *free_list, *handler_items;
@ -277,17 +277,20 @@ public:
Vio* active_vio; Vio* active_vio;
pthread_mutex_t active_vio_lock; pthread_mutex_t active_vio_lock;
#endif #endif
ulonglong next_insert_id,last_insert_id,current_insert_id, limit_found_rows; ulonglong next_insert_id,last_insert_id,current_insert_id,
ha_rows select_limit,offset_limit,default_select_limit,cuted_fields, limit_found_rows;
max_join_size, sent_row_count, examined_row_count; ha_rows select_limit,offset_limit,default_select_limit,cuted_fields,
table_map used_tables; max_join_size, sent_row_count, examined_row_count;
ulong query_id,version, inactive_timeout,options,thread_id; table_map used_tables;
long dbug_thread_id; ulong query_id,version, inactive_timeout,options,thread_id;
long dbug_thread_id;
pthread_t real_id; pthread_t real_id;
uint current_tablenr,tmp_table,cond_count,col_access,query_length; uint current_tablenr,tmp_table,cond_count,col_access;
uint server_status,open_options; uint server_status,open_options;
uint32 query_length;
enum_tx_isolation tx_isolation, session_tx_isolation; enum_tx_isolation tx_isolation, session_tx_isolation;
char scramble[9]; char scramble[9];
uint8 query_cache_type; // type of query cache processing
bool slave_thread; bool slave_thread;
bool set_query_id,locked,count_cuted_fields,some_tables_deleted; bool set_query_id,locked,count_cuted_fields,some_tables_deleted;
bool no_errors, allow_sum_func, password, fatal_error; bool no_errors, allow_sum_func, password, fatal_error;
@ -296,18 +299,18 @@ public:
bool query_error, bootstrap, cleanup_done; bool query_error, bootstrap, cleanup_done;
bool safe_to_cache_query; bool safe_to_cache_query;
bool volatile killed; bool volatile killed;
//type of query cache processing /*
byte query_cache_type; If we do a purge of binary logs, log index info of the threads
that are currently reading it needs to be adjusted. To do that
each thread that is using LOG_INFO needs to adjust the pointer to it
*/
LOG_INFO* current_linfo; LOG_INFO* current_linfo;
// if we do a purge of binary logs, log index info of the threads /*
// that are currently reading it needs to be adjusted. To do that In slave thread we need to know in behalf of which
// each thread that is using LOG_INFO needs to adjust the pointer to it thread the query is being run to replicate temp tables properly
*/
ulong slave_proxy_id; // in slave thread we need to know in behalf of which ulong slave_proxy_id;
// thread the query is being run to replicate temp tables properly NET* slave_net; // network connection from slave -> m.
NET* slave_net; // network connection from slave to master
THD(); THD();
~THD(); ~THD();
void cleanup(void); void cleanup(void);

8
sql/sql_insert.cc
View File

@ -739,9 +739,9 @@ TABLE *delayed_insert::get_local_table(THD* client_thd)
} }
client_thd->proc_info="allocating local table"; client_thd->proc_info="allocating local table";
copy= (TABLE*) sql_alloc(sizeof(*copy)+ copy= (TABLE*) client_thd->alloc(sizeof(*copy)+
(table->fields+1)*sizeof(Field**)+ (table->fields+1)*sizeof(Field**)+
table->reclength); table->reclength);
if (!copy) if (!copy)
goto error; goto error;
*copy= *table; *copy= *table;
@ -759,7 +759,7 @@ TABLE *delayed_insert::get_local_table(THD* client_thd)
found_next_number_field=table->found_next_number_field; found_next_number_field=table->found_next_number_field;
for (org_field=table->field ; *org_field ; org_field++,field++) for (org_field=table->field ; *org_field ; org_field++,field++)
{ {
if (!(*field= (*org_field)->new_field(copy))) if (!(*field= (*org_field)->new_field(&client_thd->mem_root,copy)))
return 0; return 0;
(*field)->move_field(adjust_ptrs); // Point at copy->record[0] (*field)->move_field(adjust_ptrs); // Point at copy->record[0]
if (*org_field == found_next_number_field) if (*org_field == found_next_number_field)

110
sql/sql_parse.cc
View File

@ -29,25 +29,42 @@
#include <my_dir.h> #include <my_dir.h>
#include <assert.h> #include <assert.h>
#ifdef HAVE_OPENSSL
/*
Without SSL the handshake consists of one packet. This packet
has both client capabilites and scrambled password.
With SSL the handshake might consist of two packets. If the first
packet (client capabilities) has CLIENT_SSL flag set, we have to
switch to SSL and read the second packet. The scrambled password
is in the second packet and client_capabilites field will be ignored.
Maybe it is better to accept flags other than CLIENT_SSL from the
second packet?
*/
#define SSL_HANDSHAKE_SIZE 2
#define NORMAL_HANDSHAKE_SIZE 6
#define MIN_HANDSHAKE_SIZE 2
#else
#define MIN_HANDSHAKE_SIZE 6
#endif /* HAVE_OPENSSL */
#define SCRAMBLE_LENGTH 8 #define SCRAMBLE_LENGTH 8
extern int yyparse(void); extern int yyparse(void);
extern "C" pthread_mutex_t THR_LOCK_keycache; extern "C" pthread_mutex_t THR_LOCK_keycache;
#ifdef SOLARIS #ifdef SOLARIS
extern "C" int gethostname(char *name, int namelen); extern "C" int gethostname(char *name, int namelen);
#endif #endif
static int check_for_max_user_connections(const char *user, int u_length, static int check_for_max_user_connections(const char *user, const char *host);
const char *host);
static void decrease_user_connections(const char *user, const char *host); static void decrease_user_connections(const char *user, const char *host);
static bool check_db_used(THD *thd,TABLE_LIST *tables); static bool check_db_used(THD *thd,TABLE_LIST *tables);
static bool check_merge_table_access(THD *thd, char *db, TABLE_LIST *tables); static bool check_merge_table_access(THD *thd, char *db, TABLE_LIST *tables);
static bool check_dup(THD *thd,const char *db,const char *name, static bool check_dup(const char *db, const char *name, TABLE_LIST *tables);
TABLE_LIST *tables);
static void mysql_init_query(THD *thd); static void mysql_init_query(THD *thd);
static void remove_escape(char *name); static void remove_escape(char *name);
static void refresh_status(void); static void refresh_status(void);
static bool append_file_to_dir(char **filename_ptr, char *table_name); static bool append_file_to_dir(THD *thd, char **filename_ptr,
char *table_name);
static bool create_total_list(THD *thd, LEX *lex, TABLE_LIST **result); static bool create_total_list(THD *thd, LEX *lex, TABLE_LIST **result);
const char *any_db="*any*"; // Special symbol for check_access const char *any_db="*any*"; // Special symbol for check_access
@ -160,7 +177,7 @@ static bool check_user(THD *thd,enum_server_command command, const char *user,
db ? db : (char*) ""); db ? db : (char*) "");
thd->db_access=0; thd->db_access=0;
if (max_user_connections && if (max_user_connections &&
check_for_max_user_connections(user, strlen(user), thd->host)) check_for_max_user_connections(user, thd->host))
return -1; return -1;
if (db && db[0]) if (db && db[0])
{ {
@ -210,8 +227,7 @@ void init_max_user_conn(void)
} }
static int check_for_max_user_connections(const char *user, int u_length, static int check_for_max_user_connections(const char *user, const char *host)
const char *host)
{ {
int error=1; int error=1;
uint temp_len; uint temp_len;
@ -363,51 +379,35 @@ check_connections(THD *thd)
} }
vio_keepalive(net->vio, TRUE); vio_keepalive(net->vio, TRUE);
/* nasty, but any other way? */ ulong pkt_len=0;
uint pkt_len = 0;
{ {
/* buff[] needs to big enough to hold the server_version variable */ /* buff[] needs to big enough to hold the server_version variable */
char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH+32],*end; char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH+32],*end;
int client_flags = CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB; int client_flags = CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB;
if (opt_using_transactions) if (opt_using_transactions)
client_flags|=CLIENT_TRANSACTIONS; client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS #ifdef HAVE_COMPRESS
client_flags |= CLIENT_COMPRESS; client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */ #endif /* HAVE_COMPRESS */
#ifdef HAVE_OPENSSL
if (ssl_acceptor_fd)
client_flags |= CLIENT_SSL; /* Wow, SSL is avalaible! */
#endif /* HAVE_OPENSSL */
end=strmov(buff,server_version)+1; end=strnmov(buff,server_version,SERVER_VERSION_LENGTH)+1;
int4store((uchar*) end,thd->thread_id); int4store((uchar*) end,thd->thread_id);
end+=4; end+=4;
memcpy(end,thd->scramble,SCRAMBLE_LENGTH+1); memcpy(end,thd->scramble,SCRAMBLE_LENGTH+1);
end+=SCRAMBLE_LENGTH +1; end+=SCRAMBLE_LENGTH +1;
#ifdef HAVE_OPENSSL
if (ssl_acceptor_fd)
client_flags |= CLIENT_SSL; /* Wow, SSL is avalaible! */
/*
* Without SSL the handshake consists of one packet. This packet
* has both client capabilites and scrambled password.
* With SSL the handshake might consist of two packets. If the first
* packet (client capabilities) has CLIENT_SSL flag set, we have to
* switch to SSL and read the second packet. The scrambled password
* is in the second packet and client_capabilites field will be ignored.
* Maybe it is better to accept flags other than CLIENT_SSL from the
* second packet?
*/
#define SSL_HANDSHAKE_SIZE 2
#define NORMAL_HANDSHAKE_SIZE 6
#define MIN_HANDSHAKE_SIZE 2
#else
#define MIN_HANDSHAKE_SIZE 6
#endif /* HAVE_OPENSSL */
int2store(end,client_flags); int2store(end,client_flags);
end[2]=MY_CHARSET_CURRENT; end[2]=(char) MY_CHARSET_CURRENT;
int2store(end+3,thd->server_status); int2store(end+3,thd->server_status);
bzero(end+5,13); bzero(end+5,13);
end+=18; end+=18;
if (net_write_command(net,protocol_version, buff, if (net_write_command(net,(uchar) protocol_version, buff,
(uint) (end-buff)) || (uint) (end-buff)) ||
(pkt_len=my_net_read(net)) == packet_error || (pkt_len= my_net_read(net)) == packet_error ||
pkt_len < MIN_HANDSHAKE_SIZE) pkt_len < MIN_HANDSHAKE_SIZE)
{ {
inc_host_errors(&thd->remote.sin_addr); inc_host_errors(&thd->remote.sin_addr);
@ -426,12 +426,9 @@ check_connections(THD *thd)
if (thd->client_capabilities & CLIENT_IGNORE_SPACE) if (thd->client_capabilities & CLIENT_IGNORE_SPACE)
thd->sql_mode|= MODE_IGNORE_SPACE; thd->sql_mode|= MODE_IGNORE_SPACE;
#ifdef HAVE_OPENSSL #ifdef HAVE_OPENSSL
DBUG_PRINT("info", DBUG_PRINT("info", ("client capabilities: %d", thd->client_capabilities));
("pkt_len:%d, client capabilities: %d",
pkt_len, thd->client_capabilities) );
if (thd->client_capabilities & CLIENT_SSL) if (thd->client_capabilities & CLIENT_SSL)
{ {
DBUG_PRINT("info", ("Agreed to change IO layer to SSL") );
/* Do the SSL layering. */ /* Do the SSL layering. */
DBUG_PRINT("info", ("IO layer change in progress...")); DBUG_PRINT("info", ("IO layer change in progress..."));
sslaccept(ssl_acceptor_fd, net->vio, thd->inactive_timeout); sslaccept(ssl_acceptor_fd, net->vio, thd->inactive_timeout);
@ -439,8 +436,8 @@ check_connections(THD *thd)
if ((pkt_len=my_net_read(net)) == packet_error || if ((pkt_len=my_net_read(net)) == packet_error ||
pkt_len < NORMAL_HANDSHAKE_SIZE) pkt_len < NORMAL_HANDSHAKE_SIZE)
{ {
DBUG_PRINT("info", ("pkt_len:%d", pkt_len)); DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
DBUG_PRINT("error", ("Failed to read user information")); pkt_len));
inc_host_errors(&thd->remote.sin_addr); inc_host_errors(&thd->remote.sin_addr);
return(ER_HANDSHAKE_ERROR); return(ER_HANDSHAKE_ERROR);
} }
@ -469,7 +466,7 @@ check_connections(THD *thd)
if ((thd->client_capabilities & CLIENT_TRANSACTIONS) && if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
opt_using_transactions) opt_using_transactions)
thd->net.return_status= &thd->server_status; thd->net.return_status= &thd->server_status;
net->timeout=net_read_timeout; net->timeout=(uint) net_read_timeout;
if (check_user(thd,COM_CONNECT, user, passwd, db, 1)) if (check_user(thd,COM_CONNECT, user, passwd, db, 1))
return (-1); return (-1);
thd->password=test(passwd[0]); thd->password=test(passwd[0]);
@ -693,8 +690,8 @@ int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd)
goto err; goto err;
thd->free_list = 0; thd->free_list = 0;
thd->query_length=(uint) strlen(tbl_name);
thd->query = tbl_name; thd->query = tbl_name;
thd->query_length=strlen(tbl_name);
if ((error = mysqld_dump_create_info(thd, table, -1))) if ((error = mysqld_dump_create_info(thd, table, -1)))
{ {
my_error(ER_GET_ERRNO, MYF(0)); my_error(ER_GET_ERRNO, MYF(0));
@ -715,7 +712,8 @@ err:
bool do_command(THD *thd) bool do_command(THD *thd)
{ {
char *packet; char *packet;
uint old_timeout,packet_length; uint old_timeout;
ulong packet_length;
NET *net; NET *net;
enum enum_server_command command; enum enum_server_command command;
DBUG_ENTER("do_command"); DBUG_ENTER("do_command");
@ -725,7 +723,7 @@ bool do_command(THD *thd)
packet=0; packet=0;
old_timeout=net->timeout; old_timeout=net->timeout;
net->timeout=thd->inactive_timeout; /* Wait max for 8 hours */ net->timeout=(uint) thd->inactive_timeout; // Wait max for 8 hours
net->last_error[0]=0; // Clear error message net->last_error[0]=0; // Clear error message
net->last_errno=0; net->last_errno=0;
@ -745,7 +743,7 @@ bool do_command(THD *thd)
command_name[command])); command_name[command]));
} }
net->timeout=old_timeout; // Timeout for writing net->timeout=old_timeout; // Timeout for writing
DBUG_RETURN(dispatch_command(command,thd, packet+1, packet_length)); DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
} }
@ -842,6 +840,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
pos--; pos--;
packet_length--; packet_length--;
} }
thd->query_length= packet_length;
if (!(thd->query= (char*) thd->memdup((gptr) (packet),packet_length+1))) if (!(thd->query= (char*) thd->memdup((gptr) (packet),packet_length+1)))
break; break;
thd->query[packet_length]=0; thd->query[packet_length]=0;
@ -872,8 +871,8 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
} }
thd->free_list=0; thd->free_list=0;
table_list.name=table_list.real_name=thd->strdup(packet); table_list.name=table_list.real_name=thd->strdup(packet);
thd->query=fields=thd->strdup(strend(packet)+1);
thd->query_length=strlen(thd->query); thd->query_length=strlen(thd->query);
thd->query=fields=thd->strdup(strend(packet)+1);
mysql_log.write(thd,command,"%s %s",table_list.real_name,fields); mysql_log.write(thd,command,"%s %s",table_list.real_name,fields);
remove_escape(table_list.real_name); // This can't have wildcards remove_escape(table_list.real_name); // This can't have wildcards
@ -1302,8 +1301,10 @@ mysql_execute_command(void)
lex->create_info.data_file_name=lex->create_info.index_file_name=0; lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else #else
/* Fix names if symlinked tables */ /* Fix names if symlinked tables */
if (append_file_to_dir(&lex->create_info.data_file_name, tables->name) || if (append_file_to_dir(thd, &lex->create_info.data_file_name,
append_file_to_dir(&lex->create_info.index_file_name, tables->name)) tables->name) ||
append_file_to_dir(thd,&lex->create_info.index_file_name,
tables->name))
{ {
res=-1; res=-1;
break; break;
@ -1314,7 +1315,7 @@ mysql_execute_command(void)
select_result *result; select_result *result;
if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) && if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
check_dup(thd,tables->db,tables->real_name,tables->next)) check_dup(tables->db, tables->real_name, tables->next))
{ {
net_printf(&thd->net,ER_INSERT_TABLE_USED,tables->real_name); net_printf(&thd->net,ER_INSERT_TABLE_USED,tables->real_name);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
@ -1618,7 +1619,7 @@ mysql_execute_command(void)
if (thd->select_limit < select_lex->select_limit) if (thd->select_limit < select_lex->select_limit)
thd->select_limit= HA_POS_ERROR; // No limit thd->select_limit= HA_POS_ERROR; // No limit
if (check_dup(thd,tables->db,tables->real_name,tables->next)) if (check_dup(tables->db, tables->real_name, tables->next))
{ {
net_printf(&thd->net,ER_INSERT_TABLE_USED,tables->real_name); net_printf(&thd->net,ER_INSERT_TABLE_USED,tables->real_name);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
@ -1906,7 +1907,7 @@ mysql_execute_command(void)
} }
case SQLCOM_SET_OPTION: case SQLCOM_SET_OPTION:
{ {
uint org_options=thd->options; ulong org_options=thd->options;
thd->options=select_lex->options; thd->options=select_lex->options;
thd->update_lock_default= ((thd->options & OPTION_LOW_PRIORITY_UPDATES) ? thd->update_lock_default= ((thd->options & OPTION_LOW_PRIORITY_UPDATES) ?
TL_WRITE_LOW_PRIORITY : TL_WRITE); TL_WRITE_LOW_PRIORITY : TL_WRITE);
@ -2975,8 +2976,7 @@ void add_join_natural(TABLE_LIST *a,TABLE_LIST *b)
/* Check if name is used in table list */ /* Check if name is used in table list */
static bool check_dup(THD *thd,const char *db,const char *name, static bool check_dup(const char *db, const char *name, TABLE_LIST *tables)
TABLE_LIST *tables)
{ {
for (; tables ; tables=tables->next) for (; tables ; tables=tables->next)
if (!strcmp(name,tables->real_name) && !strcmp(db,tables->db)) if (!strcmp(name,tables->real_name) && !strcmp(db,tables->db))
@ -3083,7 +3083,7 @@ static void refresh_status(void)
/* If pointer is not a null pointer, append filename to it */ /* If pointer is not a null pointer, append filename to it */
static bool append_file_to_dir(char **filename_ptr, char *table_name) static bool append_file_to_dir(THD *thd, char **filename_ptr, char *table_name)
{ {
char buff[FN_REFLEN],*ptr, *end; char buff[FN_REFLEN],*ptr, *end;
if (!*filename_ptr) if (!*filename_ptr)
@ -3099,7 +3099,7 @@ static bool append_file_to_dir(char **filename_ptr, char *table_name)
/* Fix is using unix filename format on dos */ /* Fix is using unix filename format on dos */
strmov(buff,*filename_ptr); strmov(buff,*filename_ptr);
end=convert_dirname(buff, *filename_ptr, NullS); end=convert_dirname(buff, *filename_ptr, NullS);
if (!(ptr=sql_alloc((uint) (end-buff)+strlen(table_name)+1))) if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
return 1; // End of memory return 1; // End of memory
*filename_ptr=ptr; *filename_ptr=ptr;
strxmov(ptr,buff,table_name,NullS); strxmov(ptr,buff,table_name,NullS);

43
sql/sql_select.cc
View File

@ -47,7 +47,8 @@ static void find_best(JOIN *join,table_map rest_tables,uint index,
static uint cache_record_length(JOIN *join,uint index); static uint cache_record_length(JOIN *join,uint index);
static double prev_record_reads(JOIN *join,table_map found_ref); static double prev_record_reads(JOIN *join,table_map found_ref);
static bool get_best_combination(JOIN *join); static bool get_best_combination(JOIN *join);
static store_key *get_store_key(KEYUSE *keyuse, table_map used_tables, static store_key *get_store_key(THD *thd,
KEYUSE *keyuse, table_map used_tables,
KEY_PART_INFO *key_part, char *key_buff, KEY_PART_INFO *key_part, char *key_buff,
uint maybe_null); uint maybe_null);
static bool make_simple_join(JOIN *join,TABLE *tmp_table); static bool make_simple_join(JOIN *join,TABLE *tmp_table);
@ -795,7 +796,7 @@ mysql_select(THD *thd,TABLE_LIST *tables,List<Item> &fields,COND *conds,
(procedure && (procedure->flags & PROC_GROUP))) (procedure && (procedure->flags & PROC_GROUP)))
{ {
alloc_group_fields(&join,group); alloc_group_fields(&join,group);
setup_copy_fields(&join.tmp_table_param,all_fields); setup_copy_fields(thd, &join.tmp_table_param,all_fields);
if (make_sum_func_list(&join,all_fields) || thd->fatal_error) if (make_sum_func_list(&join,all_fields) || thd->fatal_error)
goto err; /* purecov: inspected */ goto err; /* purecov: inspected */
} }
@ -2152,7 +2153,8 @@ get_best_combination(JOIN *join)
if (!keyuse->used_tables && if (!keyuse->used_tables &&
!(join->select_options & SELECT_DESCRIBE)) !(join->select_options & SELECT_DESCRIBE))
{ // Compare against constant { // Compare against constant
store_key_item *tmp=new store_key_item(keyinfo->key_part[i].field, store_key_item *tmp=new store_key_item(thd,
keyinfo->key_part[i].field,
(char*)key_buff + (char*)key_buff +
maybe_null, maybe_null,
maybe_null ? maybe_null ?
@ -2166,7 +2168,8 @@ get_best_combination(JOIN *join)
tmp->copy(); tmp->copy();
} }
else else
*ref_key++= get_store_key(keyuse,join->const_table_map, *ref_key++= get_store_key(join->thd,
keyuse,join->const_table_map,
&keyinfo->key_part[i], &keyinfo->key_part[i],
(char*) key_buff,maybe_null); (char*) key_buff,maybe_null);
key_buff+=keyinfo->key_part[i].store_length; key_buff+=keyinfo->key_part[i].store_length;
@ -2208,25 +2211,28 @@ get_best_combination(JOIN *join)
static store_key * static store_key *
get_store_key(KEYUSE *keyuse, table_map used_tables, KEY_PART_INFO *key_part, get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,
char *key_buff, uint maybe_null) KEY_PART_INFO *key_part, char *key_buff, uint maybe_null)
{ {
if (!((~used_tables) & keyuse->used_tables)) // if const item if (!((~used_tables) & keyuse->used_tables)) // if const item
{ {
return new store_key_const_item(key_part->field, return new store_key_const_item(thd,
key_part->field,
key_buff + maybe_null, key_buff + maybe_null,
maybe_null ? key_buff : 0, maybe_null ? key_buff : 0,
key_part->length, key_part->length,
keyuse->val); keyuse->val);
} }
else if (keyuse->val->type() == Item::FIELD_ITEM) else if (keyuse->val->type() == Item::FIELD_ITEM)
return new store_key_field(key_part->field, return new store_key_field(thd,
key_part->field,
key_buff + maybe_null, key_buff + maybe_null,
maybe_null ? key_buff : 0, maybe_null ? key_buff : 0,
key_part->length, key_part->length,
((Item_field*) keyuse->val)->field, ((Item_field*) keyuse->val)->field,
keyuse->val->full_name()); keyuse->val->full_name());
return new store_key_item(key_part->field, return new store_key_item(thd,
key_part->field,
key_buff + maybe_null, key_buff + maybe_null,
maybe_null ? key_buff : 0, maybe_null ? key_buff : 0,
key_part->length, key_part->length,
@ -3272,7 +3278,7 @@ const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)
** for send_fields ** for send_fields
****************************************************************************/ ****************************************************************************/
Field *create_tmp_field(TABLE *table,Item *item, Item::Type type, Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
Item_result_field ***copy_func, Field **from_field, Item_result_field ***copy_func, Field **from_field,
bool group, bool modify_item) bool group, bool modify_item)
{ {
@ -3314,7 +3320,7 @@ Field *create_tmp_field(TABLE *table,Item *item, Item::Type type,
item->name,table,item->binary); item->name,table,item->binary);
} }
} }
current_thd->fatal_error=1; thd->fatal_error=1;
return 0; // Error return 0; // Error
} }
case Item::FIELD_ITEM: case Item::FIELD_ITEM:
@ -3322,7 +3328,8 @@ Field *create_tmp_field(TABLE *table,Item *item, Item::Type type,
Field *org_field=((Item_field*) item)->field,*new_field; Field *org_field=((Item_field*) item)->field,*new_field;
*from_field=org_field; *from_field=org_field;
if ((new_field= org_field->new_field(table))) // Should always be true // The following should always be true
if ((new_field= org_field->new_field(&thd->mem_root,table)))
{ {
if (modify_item) if (modify_item)
((Item_field*) item)->result_field= new_field; ((Item_field*) item)->result_field= new_field;
@ -3510,8 +3517,8 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
if (!arg->const_item()) if (!arg->const_item())
{ {
Field *new_field= Field *new_field=
create_tmp_field(table,arg,arg->type(),&copy_func,tmp_from_field, create_tmp_field(thd, table,arg,arg->type(),&copy_func,
group != 0,not_all_columns); tmp_from_field, group != 0,not_all_columns);
if (!new_field) if (!new_field)
goto err; // Should be OOM goto err; // Should be OOM
tmp_from_field++; tmp_from_field++;
@ -3527,7 +3534,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
} }
else else
{ {
Field *new_field=create_tmp_field(table,item,type,&copy_func, Field *new_field=create_tmp_field(thd, table, item,type, &copy_func,
tmp_from_field, group != 0, tmp_from_field, group != 0,
not_all_columns); not_all_columns);
if (!new_field) if (!new_field)
@ -3708,7 +3715,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
if (!using_unique_constraint) if (!using_unique_constraint)
{ {
group->buff=(char*) group_buff; group->buff=(char*) group_buff;
if (!(group->field=field->new_field(table))) if (!(group->field=field->new_field(&thd->mem_root,table)))
goto err; /* purecov: inspected */ goto err; /* purecov: inspected */
if (maybe_null) if (maybe_null)
{ {
@ -6410,7 +6417,7 @@ test_if_group_changed(List<Item_buff> &list)
*/ */
bool bool
setup_copy_fields(TMP_TABLE_PARAM *param,List<Item> &fields) setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields)
{ {
Item *pos; Item *pos;
List_iterator<Item> li(fields); List_iterator<Item> li(fields);
@ -6438,7 +6445,7 @@ setup_copy_fields(TMP_TABLE_PARAM *param,List<Item> &fields)
/* set up save buffer and change result_field to point at saved value */ /* set up save buffer and change result_field to point at saved value */
Field *field= item->field; Field *field= item->field;
item->result_field=field->new_field(field->table); item->result_field=field->new_field(&thd->mem_root,field->table);
char *tmp=(char*) sql_alloc(field->pack_length()+1); char *tmp=(char*) sql_alloc(field->pack_length()+1);
if (!tmp) if (!tmp)
goto err; goto err;

18
sql/sql_select.h
View File

@ -190,7 +190,7 @@ TABLE *create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
void free_tmp_table(THD *thd, TABLE *entry); void free_tmp_table(THD *thd, TABLE *entry);
void count_field_types(TMP_TABLE_PARAM *param, List<Item> &fields, void count_field_types(TMP_TABLE_PARAM *param, List<Item> &fields,
bool reset_with_sum_func); bool reset_with_sum_func);
bool setup_copy_fields(TMP_TABLE_PARAM *param,List<Item> &fields); bool setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,List<Item> &fields);
void copy_fields(TMP_TABLE_PARAM *param); void copy_fields(TMP_TABLE_PARAM *param);
void copy_funcs(Item_result_field **func_ptr); void copy_funcs(Item_result_field **func_ptr);
bool create_myisam_from_heap(TABLE *table, TMP_TABLE_PARAM *param, int error, bool create_myisam_from_heap(TABLE *table, TMP_TABLE_PARAM *param, int error,
@ -210,7 +210,7 @@ class store_key :public Sql_alloc
char *null_ptr; char *null_ptr;
char err; char err;
public: public:
store_key(Field *field_arg, char *ptr, char *null, uint length) store_key(THD *thd, Field *field_arg, char *ptr, char *null, uint length)
:null_ptr(null),err(0) :null_ptr(null),err(0)
{ {
if (field_arg->type() == FIELD_TYPE_BLOB) if (field_arg->type() == FIELD_TYPE_BLOB)
@ -219,7 +219,7 @@ class store_key :public Sql_alloc
field_arg->table, field_arg->binary()); field_arg->table, field_arg->binary());
else else
{ {
to_field=field_arg->new_field(field_arg->table); to_field=field_arg->new_field(&thd->mem_root,field_arg->table);
if (to_field) if (to_field)
to_field->move_field(ptr, (uchar*) null, 1); to_field->move_field(ptr, (uchar*) null, 1);
} }
@ -235,9 +235,9 @@ class store_key_field: public store_key
Copy_field copy_field; Copy_field copy_field;
const char *field_name; const char *field_name;
public: public:
store_key_field(Field *to_field_arg, char *ptr, char *null_ptr_arg, store_key_field(THD *thd, Field *to_field_arg, char *ptr, char *null_ptr_arg,
uint length, Field *from_field, const char *name_arg) uint length, Field *from_field, const char *name_arg)
:store_key(to_field_arg,ptr, :store_key(thd, to_field_arg,ptr,
null_ptr_arg ? null_ptr_arg : from_field->maybe_null() ? &err null_ptr_arg ? null_ptr_arg : from_field->maybe_null() ? &err
: NullS,length), field_name(name_arg) : NullS,length), field_name(name_arg)
{ {
@ -260,9 +260,9 @@ class store_key_item :public store_key
protected: protected:
Item *item; Item *item;
public: public:
store_key_item(Field *to_field_arg, char *ptr, char *null_ptr_arg, store_key_item(THD *thd, Field *to_field_arg, char *ptr, char *null_ptr_arg,
uint length, Item *item_arg) uint length, Item *item_arg)
:store_key(to_field_arg,ptr, :store_key(thd, to_field_arg,ptr,
null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ? null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
&err : NullS, length), item(item_arg) &err : NullS, length), item(item_arg)
{} {}
@ -279,10 +279,10 @@ class store_key_const_item :public store_key_item
{ {
bool inited; bool inited;
public: public:
store_key_const_item(Field *to_field_arg, char *ptr, store_key_const_item(THD *thd, Field *to_field_arg, char *ptr,
char *null_ptr_arg, uint length, char *null_ptr_arg, uint length,
Item *item_arg) Item *item_arg)
:store_key_item(to_field_arg,ptr, :store_key_item(thd, to_field_arg,ptr,
null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ? null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
&err : NullS, length, item_arg), inited(0) &err : NullS, length, item_arg), inited(0)
{ {

5
sql/sql_show.cc
View File

@ -1054,9 +1054,8 @@ void mysqld_list_processes(THD *thd,const char *user, bool verbose)
thd_info->query=0; thd_info->query=0;
if (tmp->query) if (tmp->query)
{ {
uint length=(uint) strlen(tmp->query); /* query_length is always set before tmp->query */
if (length > max_query_length) uint length= min(max_query_length, tmp->query_length);
length=max_query_length;
thd_info->query=(char*) thd->memdup(tmp->query,length+1); thd_info->query=(char*) thd->memdup(tmp->query,length+1);
thd_info->query[length]=0; thd_info->query[length]=0;
} }

2
sql/sql_table.cc
View File

@ -704,7 +704,7 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
DBUG_RETURN(0); DBUG_RETURN(0);
} }
Field *field=create_tmp_field(&tmp_table,item,item->type(), Field *field=create_tmp_field(thd, &tmp_table, item, item->type(),
(Item_result_field***) 0, &tmp_field,0,0); (Item_result_field***) 0, &tmp_field,0,0);
if (!field || if (!field ||
!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ? !(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?

3
sql/table.cc
View File

@ -467,7 +467,8 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
key_part->key_part_flag|= HA_PART_KEY; key_part->key_part_flag|= HA_PART_KEY;
if (field->type() != FIELD_TYPE_BLOB) if (field->type() != FIELD_TYPE_BLOB)
{ // Create a new field { // Create a new field
field=key_part->field=field->new_field(outparam); field=key_part->field=field->new_field(&outparam->mem_root,
outparam);
field->field_length=key_part->length; field->field_length=key_part->length;
} }
} }