diff options
Diffstat (limited to 'sql/field.cc')
| -rw-r--r-- | sql/field.cc | 2852 |
1 files changed, 1971 insertions, 881 deletions
diff --git a/sql/field.cc b/sql/field.cc index f8ab4b852ec..973170223e4 100644 --- a/sql/field.cc +++ b/sql/field.cc @@ -1,4 +1,4 @@ -/* Copyright (C) 2000-2006 MySQL AB +/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -14,9 +14,12 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -/***************************************************************************** -** This file implements classes defined in field.h -*****************************************************************************/ +/** + @file + + @brief + This file implements classes defined in field.h +*/ #ifdef USE_PRAGMA_IMPLEMENTATION #pragma implementation // gcc: Class implementation @@ -24,6 +27,8 @@ #include "mysql_priv.h" #include "sql_select.h" +#include "rpl_rli.h" // Pull in Relay_log_info +#include "slave.h" // Pull in rpl_master_has_bug() #include <m_ctype.h> #include <errno.h> #ifdef HAVE_FCONVERT @@ -38,8 +43,8 @@ *****************************************************************************/ #ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION -template class List<create_field>; -template class List_iterator<create_field>; +template class List<Create_field>; +template class List_iterator<Create_field>; #endif uchar Field_null::null[1]={1}; @@ -51,6 +56,9 @@ const char field_separator=','; #define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) \ ((ulong) ((LL(1) << min(arg, 4) * 8) - LL(1))) +#define ASSERT_COLUMN_MARKED_FOR_READ DBUG_ASSERT(!table || (!table->read_set || bitmap_is_set(table->read_set, field_index))) +#define ASSERT_COLUMN_MARKED_FOR_WRITE DBUG_ASSERT(!table || (!table->write_set || bitmap_is_set(table->write_set, field_index))) + /* Rules for merging different types of fields in UNION @@ -68,6 +76,7 @@ inline int field_type2index (enum_field_types field_type) ((int)FIELDTYPE_TEAR_FROM) + (field_type - FIELDTYPE_TEAR_TO) - 1); } + static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]= { /* MYSQL_TYPE_DECIMAL -> */ @@ -909,14 +918,13 @@ static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]= } }; -/* - Return type of which can carry value of both given types in UNION result +/** + Return type of which can carry value of both given types in UNION result. - SYNOPSIS - Field::field_type_merge() - a, b types for merging + @param a type for merging + @param b type for merging - RETURN + @return type of field */ @@ -988,14 +996,12 @@ test_if_important_data(CHARSET_INFO *cs, const char *str, const char *strend) } -/* - Detect Item_result by given field type of UNION merge result +/** + Detect Item_result by given field type of UNION merge result. - SYNOPSIS - Field::result_merge_type() - field_type given field type + @param field_type given field type - RETURN + @return Item_result (type of internal MySQL expression result) */ @@ -1011,18 +1017,17 @@ Item_result Field::result_merge_type(enum_field_types field_type) *****************************************************************************/ -/* - Check whether a field type can be partially indexed by a key +/** + Check whether a field type can be partially indexed by a key. This is a static method, rather than a virtual function, because we need to check the type of a non-Field in mysql_alter_table(). - SYNOPSIS - type_can_have_key_part() - type field type + @param type field type - RETURN + @retval TRUE Type can have a prefixed key + @retval FALSE Type can not have a prefixed key */ @@ -1044,16 +1049,15 @@ bool Field::type_can_have_key_part(enum enum_field_types type) } -/* - Numeric fields base class constructor +/** + Numeric fields base class constructor. */ -Field_num::Field_num(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, +Field_num::Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, uchar null_bit_arg, utype unireg_check_arg, const char *field_name_arg, - struct st_table *table_arg, uint8 dec_arg, bool zero_arg, bool unsigned_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), dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg) { if (zerofill) @@ -1068,31 +1072,34 @@ void Field_num::prepend_zeros(String *value) int diff; if ((diff= (int) (field_length - value->length())) > 0) { - bmove_upp((char*) value->ptr()+field_length,value->ptr()+value->length(), + bmove_upp((uchar*) value->ptr()+field_length, + (uchar*) value->ptr()+value->length(), value->length()); - bfill((char*) value->ptr(),diff,'0'); + bfill((uchar*) value->ptr(),diff,'0'); value->length(field_length); (void) value->c_ptr_quick(); // Avoid warnings in purify } } -/* +/** Test if given number is a int. - SYNOPSIS - Field_num::check_int - cs Character set - str String to test - end Pointer to char after last used digit - length String length - error Error returned by strntoull10rnd() + @todo + Make this multi-byte-character safe - NOTE + @param str String to test + @param length Length of 'str' + @param int_end Pointer to char after last used digit + @param cs Character set + + @note This is called after one has called strntoull10rnd() function. - RETURN - 0 ok + @retval + 0 OK + @retval 1 error: empty string or wrong integer. + @retval 2 error: garbage at the end of string. */ @@ -1152,7 +1159,8 @@ bool Field_num::get_int(CHARSET_INFO *cs, const char *from, uint len, char *end; int error; - *rnd= (longlong) cs->cset->strntoull10rnd(cs, from, len, unsigned_flag, &end, + *rnd= (longlong) cs->cset->strntoull10rnd(cs, from, len, + unsigned_flag, &end, &error); if (unsigned_flag) { @@ -1176,7 +1184,8 @@ bool Field_num::get_int(CHARSET_INFO *cs, const char *from, uint len, goto out_of_range; } } - if (table->in_use->count_cuted_fields && check_int(cs, from, len, end, error)) + if (table->in_use->count_cuted_fields && + check_int(cs, from, len, end, error)) return 1; return 0; @@ -1185,16 +1194,15 @@ out_of_range: return 1; } -/* +/** Process decimal library return codes and issue warnings for overflow and truncation. - SYNOPSIS - Field::warn_if_overflow() - op_result decimal library return code (E_DEC_* see include/decimal.h) + @param op_result decimal library return code (E_DEC_* see include/decimal.h) - RETURN + @retval 1 there was overflow + @retval 0 no error or some other errors except overflow */ @@ -1269,17 +1277,19 @@ static bool test_if_real(const char *str,int length, CHARSET_INFO *cs) #endif -/* +/** Interpret field value as an integer but return the result as a string. - This is used for printing bit_fields as numbers while debugging + This is used for printing bit_fields as numbers while debugging. */ String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_READ; CHARSET_INFO *cs= &my_charset_bin; uint length; longlong value= val_int(); + if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS)) return 0; length= (uint) (*cs->cset->longlong10_to_str)(cs, (char*) val_buffer->ptr(), @@ -1291,30 +1301,46 @@ String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_val) } -/* This is used as a table name when the table structure is not set up */ -const char *unknown_table_name= 0; - -Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg, +/// This is used as a table name when the table structure is not set up +Field::Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg, uchar null_bit_arg, - utype unireg_check_arg, const char *field_name_arg, - struct st_table *table_arg) + utype unireg_check_arg, const char *field_name_arg) :ptr(ptr_arg), null_ptr(null_ptr_arg), - table(table_arg),orig_table(table_arg), - table_name(table_arg ? &table_arg->alias : &unknown_table_name), + table(0), orig_table(0), table_name(0), field_name(field_name_arg), - query_id(0), key_start(0), part_of_key(0), part_of_sortkey(0), - unireg_check(unireg_check_arg), + key_start(0), part_of_key(0), part_of_key_not_clustered(0), + part_of_sortkey(0), unireg_check(unireg_check_arg), field_length(length_arg), null_bit(null_bit_arg), is_created_from_null_item(FALSE) { flags=null_ptr ? 0: NOT_NULL_FLAG; comment.str= (char*) ""; comment.length=0; + field_index= 0; +} + + +void Field::hash(ulong *nr, ulong *nr2) +{ + if (is_null()) + { + *nr^= (*nr << 1) | 1; + } + else + { + uint len= pack_length(); + CHARSET_INFO *cs= charset(); + cs->coll->hash_sort(cs, ptr, len, nr, nr2); + } } -uint Field::offset() +size_t +Field::do_last_null_byte() const { - return (uint) (ptr - (char*) table->record[0]); + DBUG_ASSERT(null_ptr == NULL || null_ptr >= table->record[0]); + if (null_ptr) + return (size_t) (null_ptr - table->record[0]) + 1; + return LAST_NULL_BYTE_UNDEF; } @@ -1338,6 +1364,149 @@ bool Field::send_binary(Protocol *protocol) } +/** + Check to see if field size is compatible with destination. + + This method is used in row-based replication to verify that the slave's + field size is less than or equal to the master's field size. The + encoded field metadata (from the master or source) is decoded and compared + to the size of this field (the slave or destination). + + @param field_metadata Encoded size in field metadata + + @retval 0 if this field's size is < the source field's size + @retval 1 if this field's size is >= the source field's size +*/ +int Field::compatible_field_size(uint field_metadata, + const Relay_log_info *rli_arg __attribute__((unused))) +{ + uint const source_size= pack_length_from_metadata(field_metadata); + uint const destination_size= row_pack_length(); + return (source_size <= destination_size); +} + + +int Field::store(const char *to, uint length, CHARSET_INFO *cs, + enum_check_fields check_level) +{ + int res; + enum_check_fields old_check_level= table->in_use->count_cuted_fields; + table->in_use->count_cuted_fields= check_level; + res= store(to, length, cs); + table->in_use->count_cuted_fields= old_check_level; + return res; +} + + +/** + Pack the field into a format suitable for storage and transfer. + + To implement packing functionality, only the virtual function + should be overridden. The other functions are just convenience + functions and hence should not be overridden. + + The value of <code>low_byte_first</code> is dependent on how the + packed data is going to be used: for local use, e.g., temporary + store on disk or in memory, use the native format since that is + faster. For data that is going to be transfered to other machines + (e.g., when writing data to the binary log), data should always be + stored in little-endian format. + + @note The default method for packing fields just copy the raw bytes + of the record into the destination, but never more than + <code>max_length</code> characters. + + @param to + Pointer to memory area where representation of field should be put. + + @param from + Pointer to memory area where record representation of field is + stored. + + @param max_length + Maximum length of the field, as given in the column definition. For + example, for <code>CHAR(1000)</code>, the <code>max_length</code> + is 1000. This information is sometimes needed to decide how to pack + the data. + + @param low_byte_first + @c TRUE if integers should be stored little-endian, @c FALSE if + native format should be used. Note that for little-endian machines, + the value of this flag is a moot point since the native format is + little-endian. +*/ +uchar * +Field::pack(uchar *to, const uchar *from, uint max_length, + bool low_byte_first __attribute__((unused))) +{ + uint32 length= pack_length(); + set_if_smaller(length, max_length); + memcpy(to, from, length); + return to+length; +} + +/** + Unpack a field from row data. + + This method is used to unpack a field from a master whose size of + the field is less than that of the slave. + + The <code>param_data</code> parameter is a two-byte integer (stored + in the least significant 16 bits of the unsigned integer) usually + consisting of two parts: the real type in the most significant byte + and a original pack length in the least significant byte. + + The exact layout of the <code>param_data</code> field is given by + the <code>Table_map_log_event::save_field_metadata()</code>. + + This is the default method for unpacking a field. It just copies + the memory block in byte order (of original pack length bytes or + length of field, whichever is smaller). + + @param to Destination of the data + @param from Source of the data + @param param_data Real type and original pack length of the field + data + + @param low_byte_first + If this flag is @c true, all composite entities (e.g., lengths) + should be unpacked in little-endian format; otherwise, the entities + are unpacked in native order. + + @return New pointer into memory based on from + length of the data +*/ +const uchar * +Field::unpack(uchar* to, const uchar *from, uint param_data, + bool low_byte_first __attribute__((unused))) +{ + uint length=pack_length(); + int from_type= 0; + /* + If from length is > 255, it has encoded data in the upper bits. Need + to mask it out. + */ + if (param_data > 255) + { + from_type= (param_data & 0xff00) >> 8U; // real_type. + param_data= param_data & 0x00ff; // length. + } + + if ((param_data == 0) || + (length == param_data) || + (from_type != real_type())) + { + memcpy(to, from, length); + return from+length; + } + + uint len= (param_data && (param_data < length)) ? + param_data : length; + + memcpy(to, from, param_data > length ? length : len); + return from+len; +} + + my_decimal *Field::val_decimal(my_decimal *decimal) { /* This never have to be called */ @@ -1357,11 +1526,10 @@ void Field_num::add_zerofill_and_unsigned(String &res) const void Field::make_field(Send_field *field) { - if (orig_table && orig_table->s->table_cache_key && - *(orig_table->s->table_cache_key)) + if (orig_table && orig_table->s->db.str && *orig_table->s->db.str) { - field->org_table_name= orig_table->s->table_name; - field->db_name= orig_table->s->table_cache_key; + field->db_name= orig_table->s->db.str; + field->org_table_name= orig_table->s->table_name.str; } else field->org_table_name= field->db_name= ""; @@ -1384,17 +1552,15 @@ void Field::make_field(Send_field *field) } -/* +/** Conversion from decimal to longlong with checking overflow and - setting correct value (min/max) in case of overflow + setting correct value (min/max) in case of overflow. - SYNOPSIS - Field::convert_decimal2longlong() - val value which have to be converted - unsigned_flag type of integer in which we convert val - err variable to pass error code + @param val value which have to be converted + @param unsigned_flag type of integer in which we convert val + @param err variable to pass error code - RETURN + @return value converted from val */ longlong Field::convert_decimal2longlong(const my_decimal *val, @@ -1428,47 +1594,46 @@ longlong Field::convert_decimal2longlong(const my_decimal *val, } -/* +/** Storing decimal in integer fields. - SYNOPSIS - Field_num::store_decimal() - val value for storing + @param val value for storing - NOTE + @note This method is used by all integer fields, real/decimal redefine it - RETURN + @retval 0 OK - != 0 error + @retval + !=0 error */ int Field_num::store_decimal(const my_decimal *val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int err= 0; longlong i= convert_decimal2longlong(val, unsigned_flag, &err); return test(err | store(i, unsigned_flag)); } -/* - Return decimal value of integer field +/** + Return decimal value of integer field. - SYNOPSIS - Field_num::val_decimal() - decimal_value buffer for storing decimal value + @param decimal_value buffer for storing decimal value - NOTE - This method is used by all integer fields, real/decimal redefine it + @note + This method is used by all integer fields, real/decimal redefine it. All longlong values fit in our decimal buffer which cal store 8*9=72 digits of integer number - RETURN + @return pointer to decimal buffer with value of field */ my_decimal* Field_num::val_decimal(my_decimal *decimal_value) { + ASSERT_COLUMN_MARKED_FOR_READ; DBUG_ASSERT(result_type() == INT_RESULT); longlong nr= val_int(); int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value); @@ -1476,12 +1641,11 @@ my_decimal* Field_num::val_decimal(my_decimal *decimal_value) } -Field_str::Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, +Field_str::Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg, uchar null_bit_arg, utype unireg_check_arg, - const char *field_name_arg, - struct st_table *table_arg, CHARSET_INFO *charset_arg) + const char *field_name_arg, CHARSET_INFO *charset_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) { field_charset= charset_arg; if (charset_arg->state & MY_CS_BINSORT) @@ -1496,26 +1660,29 @@ void Field_num::make_field(Send_field *field) field->decimals= dec; } -/* - Decimal representation of Field_str +/** + Decimal representation of Field_str. - SYNOPSIS - Field_str::store_decimal() - d value for storing + @param d value for storing - NOTE - Field_str is the base class for fields like Field_enum, Field_date and some - similar. Some dates use fraction and also string value should be - converted to floating point value according our rules, so we use double - to store value of decimal in string + @note + Field_str is the base class for fields like Field_enum, + Field_date and some similar. Some dates use fraction and also + string value should be converted to floating point value according + our rules, so we use double to store value of decimal in string. - RETURN + @todo + use decimal2string? + + @retval 0 OK - != 0 error + @retval + !=0 error */ int Field_str::store_decimal(const my_decimal *d) { + ASSERT_COLUMN_MARKED_FOR_WRITE; double val; /* TODO: use decimal2string? */ int err= warn_if_overflow(my_decimal2double(E_DEC_FATAL_ERROR & @@ -1526,6 +1693,7 @@ int Field_str::store_decimal(const my_decimal *d) my_decimal *Field_str::val_decimal(my_decimal *decimal_value) { + ASSERT_COLUMN_MARKED_FOR_READ; longlong nr= val_int(); int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value); return decimal_value; @@ -1582,15 +1750,16 @@ bool Field::get_time(MYSQL_TIME *ltime) return 0; } -/* - This is called when storing a date in a string +/** + This is called when storing a date in a string. - NOTES - Needs to be changed if/when we want to support different time formats + @note + Needs to be changed if/when we want to support different time formats. */ int Field::store_time(MYSQL_TIME *ltime, timestamp_type type_arg) { + ASSERT_COLUMN_MARKED_FOR_WRITE; char buff[MAX_DATE_STRING_REP_LENGTH]; uint length= (uint) my_TIME_to_str(ltime, buff); return store(buff, length, &my_charset_bin); @@ -1616,7 +1785,7 @@ Field *Field::new_field(MEM_ROOT *root, struct st_table *new_table, tmp->key_start.init(0); tmp->part_of_key.init(0); tmp->part_of_sortkey.init(0); - tmp->unireg_check=Field::NONE; + 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(); @@ -1625,7 +1794,7 @@ Field *Field::new_field(MEM_ROOT *root, struct st_table *new_table, Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table, - char *new_ptr, uchar *new_null_ptr, + uchar *new_ptr, uchar *new_null_ptr, uint new_null_bit) { Field *tmp; @@ -1639,6 +1808,21 @@ Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table, } +/* This is used to generate a field in TABLE from TABLE_SHARE */ + +Field *Field::clone(MEM_ROOT *root, struct st_table *new_table) +{ + Field *tmp; + if ((tmp= (Field*) memdup_root(root,(char*) this,size_of()))) + { + tmp->init(new_table); + tmp->move_field_offset((my_ptrdiff_t) (new_table->record[0] - + new_table->s->default_values)); + } + return tmp; +} + + /**************************************************************************** Field_null, a field that always return NULL ****************************************************************************/ @@ -1664,7 +1848,7 @@ Field_decimal::reset(void) void Field_decimal::overflow(bool negative) { uint len=field_length; - char *to=ptr, filler= '9'; + uchar *to=ptr, filler= '9'; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); if (negative) @@ -1700,35 +1884,37 @@ void Field_decimal::overflow(bool negative) } -int Field_decimal::store(const char *from, uint len, CHARSET_INFO *cs) +int Field_decimal::store(const char *from_arg, uint len, CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; char buff[STRING_BUFFER_USUAL_SIZE]; String tmp(buff,sizeof(buff), &my_charset_bin); + const uchar *from= (uchar*) from_arg; - /* Convert character set if the old one is multi byte */ + /* Convert character set if the old one is multi uchar */ if (cs->mbmaxlen > 1) { uint dummy_errors; - tmp.copy(from, len, cs, &my_charset_bin, &dummy_errors); - from= tmp.ptr(); + tmp.copy((char*) from, len, cs, &my_charset_bin, &dummy_errors); + from= (uchar*) tmp.ptr(); len= tmp.length(); } - const char *end= from+len; + const uchar *end= from+len; /* The pointer where the field value starts (i.e., "where to write") */ - char *to=ptr; + uchar *to= ptr; uint tmp_dec, tmp_uint; /* The sign of the number : will be 0 (means positive but sign not specified), '+' or '-' */ - char sign_char=0; + uchar sign_char=0; /* The pointers where prezeros start and stop */ - const char *pre_zeros_from, *pre_zeros_end; + const uchar *pre_zeros_from, *pre_zeros_end; /* The pointers where digits at the left of '.' start and stop */ - const char *int_digits_from, *int_digits_end; + const uchar *int_digits_from, *int_digits_end; /* The pointers where digits at the right of '.' start and stop */ - const char *frac_digits_from, *frac_digits_end; + const uchar *frac_digits_from, *frac_digits_end; /* The sign of the exponent : will be 0 (means no exponent), '+' or '-' */ char expo_sign_char=0; uint exponent=0; // value of the exponent @@ -1736,20 +1922,20 @@ int Field_decimal::store(const char *from, uint len, CHARSET_INFO *cs) Pointers used when digits move from the left of the '.' to the right of the '.' (explained below) */ - const char *int_digits_tail_from; + const uchar *int_digits_tail_from; /* Number of 0 that need to be added at the left of the '.' (1E3: 3 zeros) */ uint int_digits_added_zeros; /* Pointer used when digits move from the right of the '.' to the left of the '.' */ - const char *frac_digits_head_end; + const uchar *frac_digits_head_end; /* Number of 0 that need to be added at the right of the '.' (for 1E-3) */ uint frac_digits_added_zeros; - char *pos,*tmp_left_pos,*tmp_right_pos; + uchar *pos,*tmp_left_pos,*tmp_right_pos; /* Pointers that are used as limits (begin and end of the field buffer) */ - char *left_wall,*right_wall; - char tmp_char; + uchar *left_wall,*right_wall; + uchar tmp_char; /* To remember if table->in_use->cuted_fields has already been incremented, to do that only once @@ -2071,31 +2257,31 @@ int Field_decimal::store(const char *from, uint len, CHARSET_INFO *cs) int Field_decimal::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; if (unsigned_flag && nr < 0) { overflow(1); return 1; } -#ifdef HAVE_FINITE - if (!finite(nr)) // Handle infinity as special case + if (!isfinite(nr)) // Handle infinity as special case { overflow(nr < 0.0); return 1; } -#endif - reg4 uint i,length; - char fyllchar,*to; + reg4 uint i; + size_t length; + uchar fyllchar,*to; char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE]; fyllchar = zerofill ? (char) '0' : (char) ' '; #ifdef HAVE_SNPRINTF buff[sizeof(buff)-1]=0; // Safety snprintf(buff,sizeof(buff)-1, "%.*f",(int) dec,nr); - length=(uint) strlen(buff); + length= strlen(buff); #else - length=(uint) my_sprintf(buff,(buff,"%.*f",dec,nr)); + length= my_sprintf(buff,(buff,"%.*f",dec,nr)); #endif if (length > field_length) @@ -2116,9 +2302,11 @@ int Field_decimal::store(double nr) int Field_decimal::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; char buff[22]; uint length, int_part; - char fyllchar, *to; + char fyllchar; + uchar *to; if (nr < 0 && unsigned_flag && !unsigned_val) { @@ -2150,31 +2338,35 @@ int Field_decimal::store(longlong nr, bool unsigned_val) double Field_decimal::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int not_used; char *end_not_used; - return my_strntod(&my_charset_bin, ptr, field_length, &end_not_used, + return my_strntod(&my_charset_bin, (char*) ptr, field_length, &end_not_used, ¬_used); } longlong Field_decimal::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int not_used; if (unsigned_flag) - return my_strntoull(&my_charset_bin, ptr, field_length, 10, NULL, - ¬_used); - else - return my_strntoll(&my_charset_bin, ptr, field_length, 10, NULL, + return my_strntoull(&my_charset_bin, (char*) ptr, field_length, 10, NULL, ¬_used); + return my_strntoll(&my_charset_bin, (char*) ptr, field_length, 10, NULL, + ¬_used); } String *Field_decimal::val_str(String *val_buffer __attribute__((unused)), String *val_ptr) { - char *str; + ASSERT_COLUMN_MARKED_FOR_READ; + uchar *str; + size_t tmp_length; + for (str=ptr ; *str == ' ' ; str++) ; - uint tmp_length=(uint) (str-ptr); val_ptr->set_charset(&my_charset_bin); + tmp_length= (size_t) (str-ptr); if (field_length < tmp_length) // Error in data val_ptr->length(0); else @@ -2182,14 +2374,14 @@ String *Field_decimal::val_str(String *val_buffer __attribute__((unused)), return val_ptr; } -/* -** Should be able to handle at least the following fixed decimal formats: -** 5.00 , -1.0, 05, -05, +5 with optional pre/end space +/** + Should be able to handle at least the following fixed decimal formats: + 5.00 , -1.0, 05, -05, +5 with optional pre/end space */ -int Field_decimal::cmp(const char *a_ptr,const char *b_ptr) +int Field_decimal::cmp(const uchar *a_ptr,const uchar *b_ptr) { - const char *end; + const uchar *end; int swap=0; /* First remove prefixes '0', ' ', and '-' */ for (end=a_ptr+field_length; @@ -2220,9 +2412,9 @@ int Field_decimal::cmp(const char *a_ptr,const char *b_ptr) } -void Field_decimal::sort_string(char *to,uint length) +void Field_decimal::sort_string(uchar *to,uint length) { - char *str,*end; + uchar *str,*end; for (str=ptr,end=ptr+length; str != end && ((my_isspace(&my_charset_bin,*str) || *str == '+' || @@ -2264,18 +2456,15 @@ void Field_decimal::sql_type(String &res) const ** Field_new_decimal ****************************************************************************/ -Field_new_decimal::Field_new_decimal(char *ptr_arg, +Field_new_decimal::Field_new_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, uchar null_bit_arg, enum utype unireg_check_arg, const char *field_name_arg, - struct st_table *table_arg, uint8 dec_arg,bool zero_arg, bool unsigned_arg) - :Field_num(ptr_arg, len_arg, - null_ptr_arg, null_bit_arg, - unireg_check_arg, field_name_arg, table_arg, - dec_arg, zero_arg, unsigned_arg) + :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, + unireg_check_arg, field_name_arg, dec_arg, zero_arg, unsigned_arg) { precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg); set_if_smaller(precision, DECIMAL_MAX_PRECISION); @@ -2288,14 +2477,11 @@ Field_new_decimal::Field_new_decimal(char *ptr_arg, Field_new_decimal::Field_new_decimal(uint32 len_arg, bool maybe_null_arg, const char *name, - struct st_table *t_arg, uint8 dec_arg, bool unsigned_arg) - :Field_num((char*) 0, len_arg, + :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0, - NONE, name, t_arg, - dec_arg, - 0, unsigned_arg) + NONE, name, dec_arg, 0, unsigned_arg) { precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg); set_if_smaller(precision, DECIMAL_MAX_PRECISION); @@ -2312,13 +2498,11 @@ int Field_new_decimal::reset(void) } -/* +/** Generate max/min decimal value in case of overflow. - SYNOPSIS - Field_new_decimal::set_value_on_overflow(); - decimal_value buffer for value - sign sign of value which caused overflow + @param decimal_value buffer for value + @param sign sign of value which caused overflow */ void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value, @@ -2337,25 +2521,24 @@ void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value, } -/* - Store decimal value in the binary buffer +/** + Store decimal value in the binary buffer. - SYNOPSIS - store_value(const my_decimal *decimal_value) - decimal_value my_decimal + Checks if decimal_value fits into field size. + If it does, stores the decimal in the buffer using binary format. + Otherwise sets maximal number that can be stored in the field. - DESCRIPTION - checks if decimal_value fits into field size. - if it does, stores the decimal in the buffer using binary format. - Otherwise sets maximal number that can be stored in the field. + @param decimal_value my_decimal - RETURN - 0 ok - 1 error + @retval + 0 ok + @retval + 1 error */ bool Field_new_decimal::store_value(const my_decimal *decimal_value) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; DBUG_ENTER("Field_new_decimal::store_value"); #ifndef DBUG_OFF @@ -2376,7 +2559,7 @@ bool Field_new_decimal::store_value(const my_decimal *decimal_value) #ifndef DBUG_OFF { char dbug_buff[DECIMAL_MAX_STR_LENGTH+1]; - DBUG_PRINT("info", ("saving with precision %d, scale: %d, value %s", + DBUG_PRINT("info", ("saving with precision %d scale: %d value %s", (int)precision, (int)dec, dbug_decimal_as_string(dbug_buff, decimal_value))); } @@ -2391,7 +2574,8 @@ bool Field_new_decimal::store_value(const my_decimal *decimal_value) my_decimal2binary(E_DEC_FATAL_ERROR, &buff, ptr, precision, dec); error= 1; } - DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (byte *) ptr, bin_size);); + DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (uchar *) ptr, + bin_size);); DBUG_RETURN(error); } @@ -2399,13 +2583,15 @@ bool Field_new_decimal::store_value(const my_decimal *decimal_value) int Field_new_decimal::store(const char *from, uint length, CHARSET_INFO *charset_arg) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int err; my_decimal decimal_value; DBUG_ENTER("Field_new_decimal::store(char*)"); if ((err= str2my_decimal(E_DEC_FATAL_ERROR & - ~(E_DEC_OVERFLOW | E_DEC_BAD_NUM), - from, length, charset_arg, &decimal_value)) && + ~(E_DEC_OVERFLOW | E_DEC_BAD_NUM), + from, length, charset_arg, + &decimal_value)) && table->in_use->abort_on_warning) { /* Because "from" is not NUL-terminated and we use %s in the ER() */ @@ -2456,8 +2642,15 @@ int Field_new_decimal::store(const char *from, uint length, } +/** + @todo + Fix following when double2my_decimal when double2decimal + will return E_DEC_TRUNCATED always correctly +*/ + int Field_new_decimal::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; my_decimal decimal_value; int err; DBUG_ENTER("Field_new_decimal::store(double)"); @@ -2492,6 +2685,7 @@ int Field_new_decimal::store(double nr) int Field_new_decimal::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; my_decimal decimal_value; int err; @@ -2513,6 +2707,7 @@ int Field_new_decimal::store(longlong nr, bool unsigned_val) int Field_new_decimal::store_decimal(const my_decimal *decimal_value) { + ASSERT_COLUMN_MARKED_FOR_WRITE; return store_value(decimal_value); } @@ -2526,6 +2721,7 @@ int Field_new_decimal::store_time(MYSQL_TIME *ltime, timestamp_type t_type) double Field_new_decimal::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; double dbl; my_decimal decimal_value; my_decimal2double(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), &dbl); @@ -2535,6 +2731,7 @@ double Field_new_decimal::val_real(void) longlong Field_new_decimal::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; longlong i; my_decimal decimal_value; my_decimal2int(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), @@ -2545,10 +2742,11 @@ longlong Field_new_decimal::val_int(void) my_decimal* Field_new_decimal::val_decimal(my_decimal *decimal_value) { + ASSERT_COLUMN_MARKED_FOR_READ; DBUG_ENTER("Field_new_decimal::val_decimal"); binary2my_decimal(E_DEC_FATAL_ERROR, ptr, decimal_value, precision, dec); - DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (byte *) ptr, + DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (uchar *) ptr, bin_size);); DBUG_RETURN(decimal_value); } @@ -2557,6 +2755,7 @@ my_decimal* Field_new_decimal::val_decimal(my_decimal *decimal_value) String *Field_new_decimal::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; my_decimal decimal_value; uint fixed_precision= zerofill ? precision : 0; my_decimal2string(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), @@ -2565,13 +2764,13 @@ String *Field_new_decimal::val_str(String *val_buffer, } -int Field_new_decimal::cmp(const char *a,const char*b) +int Field_new_decimal::cmp(const uchar *a,const uchar*b) { return memcmp(a, b, bin_size); } -void Field_new_decimal::sort_string(char *buff, +void Field_new_decimal::sort_string(uchar *buff, uint length __attribute__((unused))) { memcpy(buff, ptr, bin_size); @@ -2587,12 +2786,149 @@ void Field_new_decimal::sql_type(String &str) const } +/** + Save the field metadata for new decimal fields. + + Saves the precision in the first byte and decimals() in the second + byte of the field metadata array at index of *metadata_ptr and + *(metadata_ptr + 1). + + @param metadata_ptr First byte of field metadata + + @returns number of bytes written to metadata_ptr +*/ +int Field_new_decimal::do_save_field_metadata(uchar *metadata_ptr) +{ + *metadata_ptr= precision; + *(metadata_ptr + 1)= decimals(); + return 2; +} + + +/** + Returns the number of bytes field uses in row-based replication + row packed size. + + This method is used in row-based replication to determine the number + of bytes that the field consumes in the row record format. This is + used to skip fields in the master that do not exist on the slave. + + @param field_metadata Encoded size in field metadata + + @returns The size of the field based on the field metadata. +*/ +uint Field_new_decimal::pack_length_from_metadata(uint field_metadata) +{ + uint const source_precision= (field_metadata >> 8U) & 0x00ff; + uint const source_decimal= field_metadata & 0x00ff; + uint const source_size= my_decimal_get_binary_size(source_precision, + source_decimal); + return (source_size); +} + + +/** + Check to see if field size is compatible with destination. + + This method is used in row-based replication to verify that the slave's + field size is less than or equal to the master's field size. The + encoded field metadata (from the master or source) is decoded and compared + to the size of this field (the slave or destination). + + @param field_metadata Encoded size in field metadata + + @retval 0 if this field's size is < the source field's size + @retval 1 if this field's size is >= the source field's size +*/ +int Field_new_decimal::compatible_field_size(uint field_metadata, + const Relay_log_info * __attribute__((unused))) +{ + int compatible= 0; + uint const source_precision= (field_metadata >> 8U) & 0x00ff; + uint const source_decimal= field_metadata & 0x00ff; + uint const source_size= my_decimal_get_binary_size(source_precision, + source_decimal); + uint const destination_size= row_pack_length(); + compatible= (source_size <= destination_size); + if (compatible) + compatible= (source_precision <= precision) && + (source_decimal <= decimals()); + return (compatible); +} + + +uint Field_new_decimal::is_equal(Create_field *new_field) +{ + return ((new_field->sql_type == real_type()) && + ((new_field->flags & UNSIGNED_FLAG) == + (uint) (flags & UNSIGNED_FLAG)) && + ((new_field->flags & AUTO_INCREMENT_FLAG) == + (uint) (flags & AUTO_INCREMENT_FLAG)) && + (new_field->length == max_display_length()) && + (new_field->decimals == dec)); +} + + +/** + Unpack a decimal field from row data. + + This method is used to unpack a decimal or numeric field from a master + whose size of the field is less than that of the slave. + + @param to Destination of the data + @param from Source of the data + @param param_data Precision (upper) and decimal (lower) values + + @return New pointer into memory based on from + length of the data +*/ +const uchar * +Field_new_decimal::unpack(uchar* to, + const uchar *from, + uint param_data, + bool low_byte_first) +{ + if (param_data == 0) + return Field::unpack(to, from, param_data, low_byte_first); + + uint from_precision= (param_data & 0xff00) >> 8U; + uint from_decimal= param_data & 0x00ff; + uint length=pack_length(); + uint from_pack_len= my_decimal_get_binary_size(from_precision, from_decimal); + uint len= (param_data && (from_pack_len < length)) ? + from_pack_len : length; + if ((from_pack_len && (from_pack_len < length)) || + (from_precision < precision) || + (from_decimal < decimals())) + { + /* + If the master's data is smaller than the slave, we need to convert + the binary to decimal then resize the decimal converting it back to + a decimal and write that to the raw data buffer. + */ + decimal_digit_t dec_buf[DECIMAL_MAX_PRECISION]; + decimal_t dec; + dec.len= from_precision; + dec.buf= dec_buf; + /* + Note: bin2decimal does not change the length of the field. So it is + just the first step the resizing operation. The second step does the + resizing using the precision and decimals from the slave. + */ + bin2decimal((uchar *)from, &dec, from_precision, from_decimal); + decimal2bin(&dec, to, precision, decimals()); + } + else + memcpy(to, from, len); // Sizes are the same, just copy the data. + return from+len; +} + /**************************************************************************** ** tiny int ****************************************************************************/ int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error; longlong rnd; @@ -2604,6 +2940,7 @@ int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs) int Field_tiny::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; nr=rint(nr); if (unsigned_flag) @@ -2646,6 +2983,7 @@ int Field_tiny::store(double nr) int Field_tiny::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; if (unsigned_flag) @@ -2690,7 +3028,8 @@ int Field_tiny::store(longlong nr, bool unsigned_val) double Field_tiny::val_real(void) { - int tmp= unsigned_flag ? (int) ((uchar*) ptr)[0] : + ASSERT_COLUMN_MARKED_FOR_READ; + int tmp= unsigned_flag ? (int) ptr[0] : (int) ((signed char*) ptr)[0]; return (double) tmp; } @@ -2698,7 +3037,8 @@ double Field_tiny::val_real(void) longlong Field_tiny::val_int(void) { - int tmp= unsigned_flag ? (int) ((uchar*) ptr)[0] : + ASSERT_COLUMN_MARKED_FOR_READ; + int tmp= unsigned_flag ? (int) ptr[0] : (int) ((signed char*) ptr)[0]; return (longlong) tmp; } @@ -2707,6 +3047,7 @@ longlong Field_tiny::val_int(void) String *Field_tiny::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; CHARSET_INFO *cs= &my_charset_bin; uint length; uint mlength=max(field_length+1,5*cs->mbmaxlen); @@ -2715,7 +3056,7 @@ String *Field_tiny::val_str(String *val_buffer, if (unsigned_flag) length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10, - (long) *((uchar*) ptr)); + (long) *ptr); else length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10, (long) *((signed char*) ptr)); @@ -2731,7 +3072,7 @@ bool Field_tiny::send_binary(Protocol *protocol) return protocol->store_tiny((longlong) (int8) ptr[0]); } -int Field_tiny::cmp(const char *a_ptr, const char *b_ptr) +int Field_tiny::cmp(const uchar *a_ptr, const uchar *b_ptr) { signed char a,b; a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0]; @@ -2740,12 +3081,12 @@ int Field_tiny::cmp(const char *a_ptr, const char *b_ptr) return (a < b) ? -1 : (a > b) ? 1 : 0; } -void Field_tiny::sort_string(char *to,uint length __attribute__((unused))) +void Field_tiny::sort_string(uchar *to,uint length __attribute__((unused))) { if (unsigned_flag) *to= *ptr; else - to[0] = (char) ((uchar) ptr[0] ^ (uchar) 128); /* Revers signbit */ + to[0] = (char) (ptr[0] ^ (uchar) 128); /* Revers signbit */ } void Field_tiny::sql_type(String &res) const @@ -2762,6 +3103,7 @@ void Field_tiny::sql_type(String &res) const int Field_short::store(const char *from,uint len,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int store_tmp; int error; longlong rnd; @@ -2782,6 +3124,7 @@ int Field_short::store(const char *from,uint len,CHARSET_INFO *cs) int Field_short::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; int16 res; nr=rint(nr); @@ -2833,6 +3176,7 @@ int Field_short::store(double nr) int Field_short::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; int16 res; @@ -2887,6 +3231,7 @@ int Field_short::store(longlong nr, bool unsigned_val) double Field_short::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; short j; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -2899,6 +3244,7 @@ double Field_short::val_real(void) longlong Field_short::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; short j; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -2913,6 +3259,7 @@ longlong Field_short::val_int(void) String *Field_short::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; CHARSET_INFO *cs= &my_charset_bin; uint length; uint mlength=max(field_length+1,7*cs->mbmaxlen); @@ -2944,7 +3291,7 @@ bool Field_short::send_binary(Protocol *protocol) } -int Field_short::cmp(const char *a_ptr, const char *b_ptr) +int Field_short::cmp(const uchar *a_ptr, const uchar *b_ptr) { short a,b; #ifdef WORDS_BIGENDIAN @@ -2966,7 +3313,7 @@ int Field_short::cmp(const char *a_ptr, const char *b_ptr) return (a < b) ? -1 : (a > b) ? 1 : 0; } -void Field_short::sort_string(char *to,uint length __attribute__((unused))) +void Field_short::sort_string(uchar *to,uint length __attribute__((unused))) { #ifdef WORDS_BIGENDIAN if (!table->s->db_low_byte_first) @@ -3003,6 +3350,7 @@ void Field_short::sql_type(String &res) const int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int store_tmp; int error; longlong rnd; @@ -3016,6 +3364,7 @@ int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs) int Field_medium::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; nr=rint(nr); if (unsigned_flag) @@ -3061,6 +3410,7 @@ int Field_medium::store(double nr) int Field_medium::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; if (unsigned_flag) @@ -3109,6 +3459,7 @@ int Field_medium::store(longlong nr, bool unsigned_val) double Field_medium::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr); return (double) j; } @@ -3116,6 +3467,7 @@ double Field_medium::val_real(void) longlong Field_medium::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr); return (longlong) j; } @@ -3124,6 +3476,7 @@ longlong Field_medium::val_int(void) String *Field_medium::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; CHARSET_INFO *cs= &my_charset_bin; uint length; uint mlength=max(field_length+1,10*cs->mbmaxlen); @@ -3141,11 +3494,12 @@ String *Field_medium::val_str(String *val_buffer, bool Field_medium::send_binary(Protocol *protocol) { + ASSERT_COLUMN_MARKED_FOR_READ; return protocol->store_long(Field_medium::val_int()); } -int Field_medium::cmp(const char *a_ptr, const char *b_ptr) +int Field_medium::cmp(const uchar *a_ptr, const uchar *b_ptr) { long a,b; if (unsigned_flag) @@ -3161,7 +3515,7 @@ int Field_medium::cmp(const char *a_ptr, const char *b_ptr) return (a < b) ? -1 : (a > b) ? 1 : 0; } -void Field_medium::sort_string(char *to,uint length __attribute__((unused))) +void Field_medium::sort_string(uchar *to,uint length __attribute__((unused))) { if (unsigned_flag) to[0] = ptr[2]; @@ -3186,6 +3540,7 @@ void Field_medium::sql_type(String &res) const int Field_long::store(const char *from,uint len,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; long store_tmp; int error; longlong rnd; @@ -3206,6 +3561,7 @@ int Field_long::store(const char *from,uint len,CHARSET_INFO *cs) int Field_long::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; int32 res; nr=rint(nr); @@ -3257,10 +3613,10 @@ int Field_long::store(double nr) int Field_long::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; int32 res; - DBUG_ASSERT(table->in_use == current_thd); // General safety - + if (unsigned_flag) { if (nr < 0 && !unsigned_val) @@ -3310,6 +3666,7 @@ int Field_long::store(longlong nr, bool unsigned_val) double Field_long::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int32 j; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -3322,6 +3679,7 @@ double Field_long::val_real(void) longlong Field_long::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int32 j; /* See the comment in Field_long::store(long long) */ DBUG_ASSERT(table->in_use == current_thd); @@ -3337,6 +3695,7 @@ longlong Field_long::val_int(void) String *Field_long::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; CHARSET_INFO *cs= &my_charset_bin; uint length; uint mlength=max(field_length+1,12*cs->mbmaxlen); @@ -3363,10 +3722,11 @@ String *Field_long::val_str(String *val_buffer, bool Field_long::send_binary(Protocol *protocol) { + ASSERT_COLUMN_MARKED_FOR_READ; return protocol->store_long(Field_long::val_int()); } -int Field_long::cmp(const char *a_ptr, const char *b_ptr) +int Field_long::cmp(const uchar *a_ptr, const uchar *b_ptr) { int32 a,b; #ifdef WORDS_BIGENDIAN @@ -3386,7 +3746,7 @@ int Field_long::cmp(const char *a_ptr, const char *b_ptr) return (a < b) ? -1 : (a > b) ? 1 : 0; } -void Field_long::sort_string(char *to,uint length __attribute__((unused))) +void Field_long::sort_string(uchar *to,uint length __attribute__((unused))) { #ifdef WORDS_BIGENDIAN if (!table->s->db_low_byte_first) @@ -3427,7 +3787,8 @@ void Field_long::sql_type(String &res) const int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs) { - int error; + ASSERT_COLUMN_MARKED_FOR_WRITE; + int error= 0; char *end; ulonglong tmp; @@ -3456,6 +3817,7 @@ int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs) int Field_longlong::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; longlong res; @@ -3507,6 +3869,7 @@ int Field_longlong::store(double nr) int Field_longlong::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; if (nr < 0) // Only possible error @@ -3537,6 +3900,7 @@ int Field_longlong::store(longlong nr, bool unsigned_val) double Field_longlong::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; longlong j; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -3558,6 +3922,7 @@ double Field_longlong::val_real(void) longlong Field_longlong::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; longlong j; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -3596,11 +3961,12 @@ String *Field_longlong::val_str(String *val_buffer, bool Field_longlong::send_binary(Protocol *protocol) { + ASSERT_COLUMN_MARKED_FOR_READ; return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag); } -int Field_longlong::cmp(const char *a_ptr, const char *b_ptr) +int Field_longlong::cmp(const uchar *a_ptr, const uchar *b_ptr) { longlong a,b; #ifdef WORDS_BIGENDIAN @@ -3621,7 +3987,7 @@ int Field_longlong::cmp(const char *a_ptr, const char *b_ptr) return (a < b) ? -1 : (a > b) ? 1 : 0; } -void Field_longlong::sort_string(char *to,uint length __attribute__((unused))) +void Field_longlong::sort_string(uchar *to,uint length __attribute__((unused))) { #ifdef WORDS_BIGENDIAN if (!table->s->db_low_byte_first) @@ -3665,6 +4031,47 @@ void Field_longlong::sql_type(String &res) const } +/* + Floating-point numbers + */ + +uchar * +Field_real::pack(uchar *to, const uchar *from, + uint max_length, bool low_byte_first) +{ + DBUG_ENTER("Field_real::pack"); + DBUG_ASSERT(max_length >= pack_length()); +#ifdef WORDS_BIGENDIAN + if (low_byte_first != table->s->db_low_byte_first) + { + const uchar *dptr= from + pack_length(); + while (dptr-- > from) + *to++ = *dptr; + DBUG_RETURN(to); + } + else +#endif + DBUG_RETURN(Field::pack(to, from, max_length, low_byte_first)); +} + +const uchar * +Field_real::unpack(uchar *to, const uchar *from, + uint param_data, bool low_byte_first) +{ + DBUG_ENTER("Field_real::unpack"); +#ifdef WORDS_BIGENDIAN + if (low_byte_first != table->s->db_low_byte_first) + { + const uchar *dptr= from + pack_length(); + while (dptr-- > from) + *to++ = *dptr; + DBUG_RETURN(from + pack_length()); + } + else +#endif + DBUG_RETURN(Field::unpack(to, from, param_data, low_byte_first)); +} + /**************************************************************************** single precision float ****************************************************************************/ @@ -3688,6 +4095,7 @@ int Field_float::store(const char *from,uint len,CHARSET_INFO *cs) int Field_float::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= truncate(&nr, FLT_MAX); float j= (float)nr; @@ -3698,19 +4106,21 @@ int Field_float::store(double nr) } else #endif - memcpy_fixed(ptr,(byte*) &j,sizeof(j)); + memcpy_fixed(ptr,(uchar*) &j,sizeof(j)); return error; } int Field_float::store(longlong nr, bool unsigned_val) { - return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr); + return Field_float::store(unsigned_val ? ulonglong2double((ulonglong) nr) : + (double) nr); } double Field_float::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; float j; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -3719,7 +4129,7 @@ double Field_float::val_real(void) } else #endif - memcpy_fixed((byte*) &j,ptr,sizeof(j)); + memcpy_fixed((uchar*) &j,ptr,sizeof(j)); return ((double) j); } @@ -3733,7 +4143,7 @@ longlong Field_float::val_int(void) } else #endif - memcpy_fixed((byte*) &j,ptr,sizeof(j)); + memcpy_fixed((uchar*) &j,ptr,sizeof(j)); return (longlong) rint(j); } @@ -3741,6 +4151,7 @@ longlong Field_float::val_int(void) String *Field_float::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; float nr; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -3749,7 +4160,7 @@ String *Field_float::val_str(String *val_buffer, } else #endif - memcpy_fixed((byte*) &nr,ptr,sizeof(nr)); + memcpy_fixed((uchar*) &nr,ptr,sizeof(nr)); uint to_length=max(field_length,70); val_buffer->alloc(to_length); @@ -3821,7 +4232,7 @@ String *Field_float::val_str(String *val_buffer, } -int Field_float::cmp(const char *a_ptr, const char *b_ptr) +int Field_float::cmp(const uchar *a_ptr, const uchar *b_ptr) { float a,b; #ifdef WORDS_BIGENDIAN @@ -3841,7 +4252,7 @@ int Field_float::cmp(const char *a_ptr, const char *b_ptr) #define FLT_EXP_DIG (sizeof(float)*8-FLT_MANT_DIG) -void Field_float::sort_string(char *to,uint length __attribute__((unused))) +void Field_float::sort_string(uchar *to,uint length __attribute__((unused))) { float nr; #ifdef WORDS_BIGENDIAN @@ -3853,7 +4264,7 @@ void Field_float::sort_string(char *to,uint length __attribute__((unused))) #endif memcpy_fixed(&nr,ptr,sizeof(float)); - uchar *tmp= (uchar*) to; + uchar *tmp= to; if (nr == (float) 0.0) { /* Change to zero string */ tmp[0]=(uchar) 128; @@ -3886,10 +4297,27 @@ void Field_float::sort_string(char *to,uint length __attribute__((unused))) bool Field_float::send_binary(Protocol *protocol) { + ASSERT_COLUMN_MARKED_FOR_READ; return protocol->store((float) Field_float::val_real(), dec, (String*) 0); } +/** + Save the field metadata for float fields. + + Saves the pack length in the first byte. + + @param metadata_ptr First byte of field metadata + + @returns number of bytes written to metadata_ptr +*/ +int Field_float::do_save_field_metadata(uchar *metadata_ptr) +{ + *metadata_ptr= pack_length(); + return 1; +} + + void Field_float::sql_type(String &res) const { if (dec == NOT_FIXED_DEC) @@ -3929,6 +4357,7 @@ int Field_double::store(const char *from,uint len,CHARSET_INFO *cs) int Field_double::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= truncate(&nr, DBL_MAX); #ifdef WORDS_BIGENDIAN @@ -3945,7 +4374,8 @@ int Field_double::store(double nr) int Field_double::store(longlong nr, bool unsigned_val) { - return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr); + return Field_double::store(unsigned_val ? ulonglong2double((ulonglong) nr) : + (double) nr); } /* @@ -4015,6 +4445,7 @@ int Field_real::store_decimal(const my_decimal *dm) double Field_double::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; double j; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -4029,6 +4460,7 @@ double Field_double::val_real(void) longlong Field_double::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; double j; longlong res; #ifdef WORDS_BIGENDIAN @@ -4068,6 +4500,7 @@ warn: my_decimal *Field_real::val_decimal(my_decimal *decimal_value) { + ASSERT_COLUMN_MARKED_FOR_READ; double2my_decimal(E_DEC_FATAL_ERROR, val_real(), decimal_value); return decimal_value; } @@ -4076,6 +4509,7 @@ my_decimal *Field_real::val_decimal(my_decimal *decimal_value) String *Field_double::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; double nr; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -4162,8 +4596,9 @@ bool Field_double::send_binary(Protocol *protocol) } -int Field_double::cmp(const char *a_ptr, const char *b_ptr) +int Field_double::cmp(const uchar *a_ptr, const uchar *b_ptr) { + ASSERT_COLUMN_MARKED_FOR_READ; double a,b; #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) @@ -4185,7 +4620,7 @@ int Field_double::cmp(const char *a_ptr, const char *b_ptr) /* The following should work for IEEE */ -void Field_double::sort_string(char *to,uint length __attribute__((unused))) +void Field_double::sort_string(uchar *to,uint length __attribute__((unused))) { double nr; #ifdef WORDS_BIGENDIAN @@ -4196,7 +4631,24 @@ void Field_double::sort_string(char *to,uint length __attribute__((unused))) else #endif doubleget(nr,ptr); - change_double_for_sort(nr, (byte*) to); + change_double_for_sort(nr, to); +} + + +/** + Save the field metadata for double fields. + + Saves the pack length in the first byte of the field metadata array + at index of *metadata_ptr. + + @param metadata_ptr First byte of field metadata + + @returns number of bytes written to metadata_ptr +*/ +int Field_double::do_save_field_metadata(uchar *metadata_ptr) +{ + *metadata_ptr= pack_length(); + return 1; } @@ -4216,9 +4668,8 @@ void Field_double::sql_type(String &res) const } -/* - TIMESTAMP type. - Holds datetime values in range from 1970-01-01 00:00:01 UTC to +/** + TIMESTAMP type holds datetime values in range from 1970-01-01 00:00:01 UTC to 2038-01-01 00:00:00 UTC stored as number of seconds since Unix Epoch in UTC. @@ -4251,7 +4702,7 @@ void Field_double::sql_type(String &res) const NONE - field which is not auto-set on update with some other than NOW() default value (TIMESTAMP DEFAULT 0). - Note that TIMESTAMP_OLD_FIELD's are never created explicitly now, they are + Note that TIMESTAMP_OLD_FIELDs are never created explicitly now, they are left only for preserving ability to read old tables. Such fields replaced with their newer analogs in CREATE TABLE and in SHOW CREATE TABLE. This is because we want to prefer NONE unireg_check before TIMESTAMP_OLD_FIELD for @@ -4261,55 +4712,47 @@ void Field_double::sql_type(String &res) const exception is different behavior of old/new timestamps during ALTER TABLE. */ -Field_timestamp::Field_timestamp(char *ptr_arg, uint32 len_arg, +Field_timestamp::Field_timestamp(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, uchar null_bit_arg, enum utype unireg_check_arg, const char *field_name_arg, - struct st_table *table_arg, + TABLE_SHARE *share, CHARSET_INFO *cs) :Field_str(ptr_arg, MAX_DATETIME_WIDTH, null_ptr_arg, null_bit_arg, - unireg_check_arg, field_name_arg, table_arg, cs) + unireg_check_arg, field_name_arg, cs) { /* For 4.0 MYD and 4.0 InnoDB compatibility */ flags|= ZEROFILL_FLAG | UNSIGNED_FLAG; - if (table && !table->timestamp_field && - unireg_check != NONE) + if (!share->timestamp_field && unireg_check != NONE) { /* This timestamp has auto-update */ - table->timestamp_field= this; - flags|=TIMESTAMP_FLAG; + share->timestamp_field= this; + flags|= TIMESTAMP_FLAG; + if (unireg_check != TIMESTAMP_DN_FIELD) + flags|= ON_UPDATE_NOW_FLAG; } } Field_timestamp::Field_timestamp(bool maybe_null_arg, const char *field_name_arg, - struct st_table *table_arg, CHARSET_INFO *cs) - :Field_str((char*) 0, MAX_DATETIME_WIDTH, + CHARSET_INFO *cs) + :Field_str((uchar*) 0, MAX_DATETIME_WIDTH, maybe_null_arg ? (uchar*) "": 0, 0, - NONE, field_name_arg, table_arg, cs) + NONE, field_name_arg, cs) { /* For 4.0 MYD and 4.0 InnoDB compatibility */ flags|= ZEROFILL_FLAG | UNSIGNED_FLAG; - if (table && !table->timestamp_field && - unireg_check != NONE) - { - /* This timestamp has auto-update */ - table->timestamp_field= this; - flags|=TIMESTAMP_FLAG; - } + if (unireg_check != TIMESTAMP_DN_FIELD) + flags|= ON_UPDATE_NOW_FLAG; } -/* +/** Get auto-set type for TIMESTAMP field. - SYNOPSIS - get_auto_set_type() - - DESCRIPTION - Returns value indicating during which operations this TIMESTAMP field - should be auto-set to current timestamp. + Returns value indicating during which operations this TIMESTAMP field + should be auto-set to current timestamp. */ timestamp_auto_set_type Field_timestamp::get_auto_set_type() const { @@ -4342,7 +4785,7 @@ timestamp_auto_set_type Field_timestamp::get_auto_set_type() const int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs) { - + ASSERT_COLUMN_MARKED_FOR_WRITE; MYSQL_TIME l_time; my_time_t tmp= 0; int error; @@ -4382,15 +4825,7 @@ int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs) error= 1; } } - -#ifdef WORDS_BIGENDIAN - if (table && table->s->db_low_byte_first) - { - int4store(ptr,tmp); - } - else -#endif - longstore(ptr,tmp); + store_timestamp(tmp); return error; } @@ -4413,6 +4848,7 @@ int Field_timestamp::store(double nr) int Field_timestamp::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; MYSQL_TIME l_time; my_time_t timestamp= 0; int error; @@ -4449,26 +4885,19 @@ int Field_timestamp::store(longlong nr, bool unsigned_val) WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATETIME, 1); -#ifdef WORDS_BIGENDIAN - if (table && table->s->db_low_byte_first) - { - int4store(ptr,timestamp); - } - else -#endif - longstore(ptr,(uint32) timestamp); - + store_timestamp(timestamp); return error; } - double Field_timestamp::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; return (double) Field_timestamp::val_int(); } longlong Field_timestamp::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; uint32 temp; MYSQL_TIME time_tmp; THD *thd= table ? table->in_use : current_thd; @@ -4494,6 +4923,7 @@ longlong Field_timestamp::val_int(void) String *Field_timestamp::val_str(String *val_buffer, String *val_ptr) { + ASSERT_COLUMN_MARKED_FOR_READ; uint32 temp, temp2; MYSQL_TIME time_tmp; THD *thd= table ? table->in_use : current_thd; @@ -4602,7 +5032,7 @@ bool Field_timestamp::send_binary(Protocol *protocol) } -int Field_timestamp::cmp(const char *a_ptr, const char *b_ptr) +int Field_timestamp::cmp(const uchar *a_ptr, const uchar *b_ptr) { int32 a,b; #ifdef WORDS_BIGENDIAN @@ -4621,7 +5051,7 @@ int Field_timestamp::cmp(const char *a_ptr, const char *b_ptr) } -void Field_timestamp::sort_string(char *to,uint length __attribute__((unused))) +void Field_timestamp::sort_string(uchar *to,uint length __attribute__((unused))) { #ifdef WORDS_BIGENDIAN if (!table || !table->s->db_low_byte_first) @@ -4653,14 +5083,7 @@ void Field_timestamp::set_time() THD *thd= table ? table->in_use : current_thd; long tmp= (long) thd->query_start(); set_notnull(); -#ifdef WORDS_BIGENDIAN - if (table && table->s->db_low_byte_first) - { - int4store(ptr,tmp); - } - else -#endif - longstore(ptr,tmp); + store_timestamp(tmp); } /**************************************************************************** @@ -4724,12 +5147,13 @@ int Field_time::store_time(MYSQL_TIME *ltime, timestamp_type time_type) int Field_time::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; long tmp; int error= 0; if (nr > (double)TIME_MAX_VALUE) { tmp= TIME_MAX_VALUE; - set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, + set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME); error= 1; } @@ -4761,6 +5185,7 @@ int Field_time::store(double nr) int Field_time::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; long tmp; int error= 0; if (nr < (longlong) -TIME_MAX_VALUE && !unsigned_val) @@ -4798,17 +5223,20 @@ int Field_time::store(longlong nr, bool unsigned_val) double Field_time::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; uint32 j= (uint32) uint3korr(ptr); return (double) j; } longlong Field_time::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; return (longlong) sint3korr(ptr); } -/* +/** + @note This function is multi-byte safe as the result string is always of type my_charset_bin */ @@ -4816,6 +5244,7 @@ longlong Field_time::val_int(void) String *Field_time::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; MYSQL_TIME ltime; val_buffer->alloc(MAX_DATE_STRING_REP_LENGTH); long tmp=(long) sint3korr(ptr); @@ -4834,7 +5263,8 @@ String *Field_time::val_str(String *val_buffer, } -/* +/** + @note Normally we would not consider 'time' as a valid date, but we allow get_date() here to be able to do things like DATE_FORMAT(time, "%l.%i %p") @@ -4898,7 +5328,7 @@ bool Field_time::send_binary(Protocol *protocol) } -int Field_time::cmp(const char *a_ptr, const char *b_ptr) +int Field_time::cmp(const uchar *a_ptr, const uchar *b_ptr) { int32 a,b; a=(int32) sint3korr(a_ptr); @@ -4906,7 +5336,7 @@ int Field_time::cmp(const char *a_ptr, const char *b_ptr) return (a < b) ? -1 : (a > b) ? 1 : 0; } -void Field_time::sort_string(char *to,uint length __attribute__((unused))) +void Field_time::sort_string(uchar *to,uint length __attribute__((unused))) { to[0] = (uchar) (ptr[2] ^ 128); to[1] = ptr[1]; @@ -4926,6 +5356,7 @@ void Field_time::sql_type(String &res) const int Field_year::store(const char *from, uint len,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; char *end; int error; longlong nr= cs->cset->strntoull10rnd(cs, from, len, 0, &end, &error); @@ -4955,7 +5386,7 @@ int Field_year::store(const char *from, uint len,CHARSET_INFO *cs) else if (nr > 1900) nr-= 1900; } - *ptr= (char) (unsigned char) nr; + *ptr= (char) (uchar) nr; return error; } @@ -4973,6 +5404,7 @@ int Field_year::store(double nr) int Field_year::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155) { *ptr= 0; @@ -4986,13 +5418,14 @@ int Field_year::store(longlong nr, bool unsigned_val) else if (nr > 1900) nr-= 1900; } - *ptr= (char) (unsigned char) nr; + *ptr= (char) (uchar) nr; return 0; } bool Field_year::send_binary(Protocol *protocol) { + ASSERT_COLUMN_MARKED_FOR_READ; ulonglong tmp= Field_year::val_int(); return protocol->store_short(tmp); } @@ -5006,7 +5439,8 @@ double Field_year::val_real(void) longlong Field_year::val_int(void) { - int tmp= (int) ((uchar*) ptr)[0]; + ASSERT_COLUMN_MARKED_FOR_READ; + int tmp= (int) ptr[0]; if (field_length != 4) tmp%=100; // Return last 2 char else if (tmp) @@ -5043,6 +5477,7 @@ void Field_year::sql_type(String &res) const int Field_date::store(const char *from, uint len,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; MYSQL_TIME l_time; uint32 tmp; int error; @@ -5099,6 +5534,7 @@ int Field_date::store(double nr) int Field_date::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; MYSQL_TIME not_used; int error; longlong initial_nr= nr; @@ -5150,6 +5586,7 @@ bool Field_date::send_binary(Protocol *protocol) double Field_date::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int32 j; #ifdef WORDS_BIGENDIAN if (table && table->s->db_low_byte_first) @@ -5163,6 +5600,7 @@ double Field_date::val_real(void) longlong Field_date::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int32 j; #ifdef WORDS_BIGENDIAN if (table && table->s->db_low_byte_first) @@ -5177,6 +5615,7 @@ longlong Field_date::val_int(void) String *Field_date::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; MYSQL_TIME ltime; val_buffer->alloc(field_length); int32 tmp; @@ -5202,7 +5641,7 @@ bool Field_date::get_time(MYSQL_TIME *ltime) } -int Field_date::cmp(const char *a_ptr, const char *b_ptr) +int Field_date::cmp(const uchar *a_ptr, const uchar *b_ptr) { int32 a,b; #ifdef WORDS_BIGENDIAN @@ -5221,7 +5660,7 @@ int Field_date::cmp(const char *a_ptr, const char *b_ptr) } -void Field_date::sort_string(char *to,uint length __attribute__((unused))) +void Field_date::sort_string(uchar *to,uint length __attribute__((unused))) { #ifdef WORDS_BIGENDIAN if (!table || !table->s->db_low_byte_first) @@ -5274,6 +5713,7 @@ void Field_date::sql_type(String &res) const int Field_newdate::store(const char *from,uint len,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; long tmp; MYSQL_TIME l_time; int error; @@ -5323,6 +5763,7 @@ int Field_newdate::store(double nr) int Field_newdate::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; MYSQL_TIME l_time; longlong tmp; int error; @@ -5356,8 +5797,9 @@ int Field_newdate::store(longlong nr, bool unsigned_val) } -int Field_newdate::store_time(MYSQL_TIME *ltime, timestamp_type time_type) +int Field_newdate::store_time(MYSQL_TIME *ltime,timestamp_type time_type) { + ASSERT_COLUMN_MARKED_FOR_WRITE; long tmp; int error= 0; if (time_type == MYSQL_TIMESTAMP_DATE || @@ -5410,12 +5852,14 @@ bool Field_newdate::send_binary(Protocol *protocol) double Field_newdate::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; return (double) Field_newdate::val_int(); } longlong Field_newdate::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; ulong j= uint3korr(ptr); j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L; return (longlong) j; @@ -5425,6 +5869,7 @@ longlong Field_newdate::val_int(void) String *Field_newdate::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; val_buffer->alloc(field_length); val_buffer->length(field_length); uint32 tmp=(uint32) uint3korr(ptr); @@ -5469,7 +5914,7 @@ bool Field_newdate::get_time(MYSQL_TIME *ltime) } -int Field_newdate::cmp(const char *a_ptr, const char *b_ptr) +int Field_newdate::cmp(const uchar *a_ptr, const uchar *b_ptr) { uint32 a,b; a=(uint32) uint3korr(a_ptr); @@ -5478,7 +5923,7 @@ int Field_newdate::cmp(const char *a_ptr, const char *b_ptr) } -void Field_newdate::sort_string(char *to,uint length __attribute__((unused))) +void Field_newdate::sort_string(uchar *to,uint length __attribute__((unused))) { to[0] = ptr[2]; to[1] = ptr[1]; @@ -5501,6 +5946,7 @@ void Field_newdate::sql_type(String &res) const int Field_datetime::store(const char *from,uint len,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; MYSQL_TIME time_tmp; int error; ulonglong tmp= 0; @@ -5553,6 +5999,7 @@ int Field_datetime::store(double nr) int Field_datetime::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; MYSQL_TIME not_used; int error; longlong initial_nr= nr; @@ -5590,10 +6037,11 @@ int Field_datetime::store(longlong nr, bool unsigned_val) int Field_datetime::store_time(MYSQL_TIME *ltime,timestamp_type time_type) { + ASSERT_COLUMN_MARKED_FOR_WRITE; longlong tmp; int error= 0; /* - We don't perform range checking here since values stored in MYSQL_TIME + We don't perform range checking here since values stored in TIME structure always fit into DATETIME range. */ if (time_type == MYSQL_TIMESTAMP_DATE || @@ -5647,6 +6095,7 @@ double Field_datetime::val_real(void) longlong Field_datetime::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; longlong j; #ifdef WORDS_BIGENDIAN if (table && table->s->db_low_byte_first) @@ -5661,6 +6110,7 @@ longlong Field_datetime::val_int(void) String *Field_datetime::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; val_buffer->alloc(field_length); val_buffer->length(field_length); ulonglong tmp; @@ -5682,7 +6132,7 @@ String *Field_datetime::val_str(String *val_buffer, part1=(long) (tmp/LL(1000000)); part2=(long) (tmp - (ulonglong) part1*LL(1000000)); - pos= (char*) val_buffer->ptr() + MAX_DATETIME_WIDTH; + pos=(char*) val_buffer->ptr() + MAX_DATETIME_WIDTH; *pos--=0; *pos--= (char) ('0'+(char) (part2%10)); part2/=10; *pos--= (char) ('0'+(char) (part2%10)); part3= (int) (part2 / 10); @@ -5730,7 +6180,7 @@ bool Field_datetime::get_time(MYSQL_TIME *ltime) return Field_datetime::get_date(ltime,0); } -int Field_datetime::cmp(const char *a_ptr, const char *b_ptr) +int Field_datetime::cmp(const uchar *a_ptr, const uchar *b_ptr) { longlong a,b; #ifdef WORDS_BIGENDIAN @@ -5749,7 +6199,7 @@ int Field_datetime::cmp(const char *a_ptr, const char *b_ptr) ((ulonglong) a > (ulonglong) b) ? 1 : 0; } -void Field_datetime::sort_string(char *to,uint length __attribute__((unused))) +void Field_datetime::sort_string(uchar *to,uint length __attribute__((unused))) { #ifdef WORDS_BIGENDIAN if (!table || !table->s->db_low_byte_first) @@ -5798,6 +6248,7 @@ void Field_datetime::sql_type(String &res) const well_formed_error_pos - where not well formed data was first met cannot_convert_error_pos - where a not-convertable character was first met end - end of the string + cs - character set of the string NOTES As of version 5.0 both cases return the same error: @@ -5817,7 +6268,8 @@ static bool check_string_copy_error(Field_str *field, const char *well_formed_error_pos, const char *cannot_convert_error_pos, - const char *end) + const char *end, + CHARSET_INFO *cs) { const char *pos, *end_orig; char tmp[64], *t; @@ -5831,8 +6283,18 @@ check_string_copy_error(Field_str *field, for (t= tmp; pos < end; pos++) { + /* + If the source string is ASCII compatible (mbminlen==1) + and the source character is in ASCII printable range (0x20..0x7F), + then display the character as is. + + Otherwise, if the source string is not ASCII compatible (e.g. UCS2), + or the source character is not in the printable range, + then print the character using HEX notation. + */ if (((unsigned char) *pos) >= 0x20 && - ((unsigned char) *pos) <= 0x7F) + ((unsigned char) *pos) <= 0x7F && + cs->mbminlen == 1) { *t++= *pos; } @@ -5911,6 +6373,7 @@ Field_longstr::report_if_important_data(const char *ptr, const char *end, int Field_string::store(const char *from,uint length,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; uint copy_length; const char *well_formed_error_pos; const char *cannot_convert_error_pos; @@ -5920,7 +6383,7 @@ int Field_string::store(const char *from,uint length,CHARSET_INFO *cs) DBUG_ASSERT(table->in_use == current_thd); copy_length= well_formed_copy_nchars(field_charset, - ptr, field_length, + (char*) ptr, field_length, cs, from, length, field_length / field_charset->mbmaxlen, &well_formed_error_pos, @@ -5929,31 +6392,29 @@ int Field_string::store(const char *from,uint length,CHARSET_INFO *cs) /* Append spaces if the string was shorter than the field. */ if (copy_length < field_length) - field_charset->cset->fill(field_charset,ptr+copy_length, + field_charset->cset->fill(field_charset,(char*) ptr+copy_length, field_length-copy_length, field_charset->pad_char); if (check_string_copy_error(this, well_formed_error_pos, - cannot_convert_error_pos, from + length)) + cannot_convert_error_pos, from + length, cs)) return 2; return report_if_important_data(from_end_pos, from + length, FALSE); } -/* +/** Store double value in Field_string or Field_varstring. - SYNOPSIS - store(double nr) - nr number + Pretty prints double number into field_length characters buffer. - DESCRIPTION - Pretty prints double number into field_length characters buffer. + @param nr number */ int Field_str::store(double nr) { + ASSERT_COLUMN_MARKED_FOR_WRITE; char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE]; uint length; uint local_char_length= field_length / charset()->mbmaxlen; @@ -6033,7 +6494,35 @@ int Field_str::store(double nr) like inserting 500.0 in char(1) */ DBUG_ASSERT(local_char_length < 5 || length <= local_char_length+1); - return store((const char *) buff, length, charset()); + return store(buff, length, charset()); +} + + +uint Field::is_equal(Create_field *new_field) +{ + return (new_field->sql_type == real_type()); +} + + +/* If one of the fields is binary and the other one isn't return 1 else 0 */ + +bool Field_str::compare_str_field_flags(Create_field *new_field, uint32 flag_arg) +{ + return (((new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) && + !(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) || + (!(new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) && + (flag_arg & (BINCMP_FLAG | BINARY_FLAG)))); +} + + +uint Field_str::is_equal(Create_field *new_field) +{ + if (compare_str_field_flags(new_field, flags)) + return 0; + + return ((new_field->sql_type == real_type()) && + new_field->charset == field_charset && + new_field->length == max_display_length()); } @@ -6056,22 +6545,29 @@ int Field_longstr::store_decimal(const my_decimal *d) return store(str.ptr(), str.length(), str.charset()); } +uint32 Field_longstr::max_data_length() const +{ + return field_length + (field_length > 255 ? 2 : 1); +} + double Field_string::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int error; char *end; CHARSET_INFO *cs= charset(); double result; - result= my_strntod(cs,ptr,field_length,&end,&error); + result= my_strntod(cs,(char*) ptr,field_length,&end,&error); if (!table->in_use->no_errors && - (error || (field_length != (uint32)(end - ptr) && - !check_if_only_end_space(cs, end, ptr + field_length)))) + (error || (field_length != (uint32)(end - (char*) ptr) && + !check_if_only_end_space(cs, end, + (char*) ptr + field_length)))) { char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE]; String tmp(buf, sizeof(buf), cs); - tmp.copy(ptr, field_length, cs); + tmp.copy((char*) ptr, field_length, cs); push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_TRUNCATED_WRONG_VALUE, ER(ER_TRUNCATED_WRONG_VALUE), @@ -6083,19 +6579,21 @@ double Field_string::val_real(void) longlong Field_string::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int error; char *end; CHARSET_INFO *cs= charset(); longlong result; - result= my_strntoll(cs,ptr,field_length,10,&end,&error); + result= my_strntoll(cs, (char*) ptr,field_length,10,&end,&error); if (!table->in_use->no_errors && - (error || (field_length != (uint32)(end - ptr) && - !check_if_only_end_space(cs, end, ptr + field_length)))) + (error || (field_length != (uint32)(end - (char*) ptr) && + !check_if_only_end_space(cs, end, + (char*) ptr + field_length)))) { char buf[LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE]; String tmp(buf, sizeof(buf), cs); - tmp.copy(ptr, field_length, cs); + tmp.copy((char*) ptr, field_length, cs); push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_TRUNCATED_WRONG_VALUE, ER(ER_TRUNCATED_WRONG_VALUE), @@ -6108,9 +6606,17 @@ longlong Field_string::val_int(void) String *Field_string::val_str(String *val_buffer __attribute__((unused)), String *val_ptr) { - uint length= field_charset->cset->lengthsp(field_charset, ptr, field_length); + ASSERT_COLUMN_MARKED_FOR_READ; /* See the comment for Field_long::store(long long) */ DBUG_ASSERT(table->in_use == current_thd); + uint length; + if (table->in_use->variables.sql_mode & + MODE_PAD_CHAR_TO_FULL_LENGTH) + length= my_charpos(field_charset, ptr, ptr + field_length, + field_length / field_charset->mbmaxlen); + else + length= field_charset->cset->lengthsp(field_charset, (const char*) ptr, + field_length); val_ptr->set((const char*) ptr, length, field_charset); return val_ptr; } @@ -6118,14 +6624,15 @@ String *Field_string::val_str(String *val_buffer __attribute__((unused)), my_decimal *Field_string::val_decimal(my_decimal *decimal_value) { - int err= str2my_decimal(E_DEC_FATAL_ERROR, ptr, field_length, charset(), - decimal_value); + ASSERT_COLUMN_MARKED_FOR_READ; + int err= str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr, field_length, + charset(), decimal_value); if (!table->in_use->no_errors && err) { char buf[DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE]; CHARSET_INFO *cs= charset(); String tmp(buf, sizeof(buf), cs); - tmp.copy(ptr, field_length, cs); + tmp.copy((char*) ptr, field_length, cs); push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_TRUNCATED_WRONG_VALUE, ER(ER_TRUNCATED_WRONG_VALUE), @@ -6136,7 +6643,38 @@ my_decimal *Field_string::val_decimal(my_decimal *decimal_value) } -int Field_string::cmp(const char *a_ptr, const char *b_ptr) +struct Check_field_param { + Field *field; +}; + +#ifdef HAVE_REPLICATION +static bool +check_field_for_37426(const void *param_arg) +{ + Check_field_param *param= (Check_field_param*) param_arg; + DBUG_ASSERT(param->field->real_type() == MYSQL_TYPE_STRING); + DBUG_PRINT("debug", ("Field %s - type: %d, size: %d", + param->field->field_name, + param->field->real_type(), + param->field->row_pack_length())); + return param->field->row_pack_length() > 255; +} +#endif + +int Field_string::compatible_field_size(uint field_metadata, + const Relay_log_info *rli_arg) +{ +#ifdef HAVE_REPLICATION + const Check_field_param check_param = { this }; + if (rpl_master_has_bug(rli_arg, 37426, TRUE, + check_field_for_37426, &check_param)) + return FALSE; // Not compatible field sizes +#endif + return Field::compatible_field_size(field_metadata, rli_arg); +} + + +int Field_string::cmp(const uchar *a_ptr, const uchar *b_ptr) { uint a_len, b_len; @@ -6153,17 +6691,17 @@ int Field_string::cmp(const char *a_ptr, const char *b_ptr) like in latin_de 'ae' and 0xe4 */ return field_charset->coll->strnncollsp(field_charset, - (const uchar*) a_ptr, a_len, - (const uchar*) b_ptr, b_len, + a_ptr, a_len, + b_ptr, b_len, 0); } -void Field_string::sort_string(char *to,uint length) +void Field_string::sort_string(uchar *to,uint length) { IF_DBUG(uint tmp=) my_strnxfrm(field_charset, - (unsigned char *) to, length, - (unsigned char *) ptr, field_length); + to, length, + ptr, field_length); DBUG_ASSERT(tmp == length); } @@ -6188,7 +6726,9 @@ void Field_string::sql_type(String &res) const } -char *Field_string::pack(char *to, const char *from, uint max_length) +uchar *Field_string::pack(uchar *to, const uchar *from, + uint max_length, + bool low_byte_first __attribute__((unused))) { uint length= min(field_length,max_length); uint local_char_length= max_length/field_charset->mbmaxlen; @@ -6196,32 +6736,120 @@ char *Field_string::pack(char *to, const char *from, uint max_length) local_char_length= my_charpos(field_charset, from, from+length, local_char_length); set_if_smaller(length, local_char_length); - while (length && from[length-1] == ' ') + while (length && from[length-1] == field_charset->pad_char) length--; - *to++= (char) (uchar) length; + + // Length always stored little-endian + *to++= (uchar) length; if (field_length > 255) - *to++= (char) (uchar) (length >> 8); + *to++= (uchar) (length >> 8); + + // Store the actual bytes of the string memcpy(to, from, length); return to+length; } -const char *Field_string::unpack(char *to, const char *from) +/** + Unpack a string field from row data. + + This method is used to unpack a string field from a master whose size + of the field is less than that of the slave. Note that there can be a + variety of field types represented with this class. Certain types like + ENUM or SET are processed differently. Hence, the upper byte of the + @c param_data argument contains the result of field->real_type() from + the master. + + @note For information about how the length is packed, see @c + Field_string::do_save_field_metadata + + @param to Destination of the data + @param from Source of the data + @param param_data Real type (upper) and length (lower) values + + @return New pointer into memory based on from + length of the data +*/ +const uchar * +Field_string::unpack(uchar *to, + const uchar *from, + uint param_data, + bool low_byte_first __attribute__((unused))) { - uint length; - if (field_length > 255) + uint from_length, length; + + /* + Compute the declared length of the field on the master. This is + used to decide if one or two bytes should be read as length. + */ + if (param_data) + from_length= (((param_data >> 4) & 0x300) ^ 0x300) + (param_data & 0x00ff); + else + from_length= field_length; + + DBUG_PRINT("debug", + ("param_data: 0x%x, field_length: %u, from_length: %u", + param_data, field_length, from_length)); + /* + Compute the actual length of the data by reading one or two bits + (depending on the declared field length on the master). + */ + if (from_length > 255) { length= uint2korr(from); from+= 2; } else - length= (uint) (uchar) *from++; - memcpy(to, from, (int) length); - bfill(to+length, field_length - length, ' '); + length= (uint) *from++; + + memcpy(to, from, length); + // Pad the string with the pad character of the fields charset + bfill(to + length, field_length - length, field_charset->pad_char); return from+length; } +/** + Save the field metadata for string fields. + + Saves the real type in the first byte and the field length in the + second byte of the field metadata array at index of *metadata_ptr and + *(metadata_ptr + 1). + + @note In order to be able to handle lengths exceeding 255 and be + backwards-compatible with pre-5.1.26 servers, an extra two bits of + the length has been added to the metadata in such a way that if + they are set, a new unrecognized type is generated. This will + cause pre-5.1-26 servers to stop due to a field type mismatch, + while new servers will be able to extract the extra bits. If the + length is <256, there will be no difference and both a new and an + old server will be able to handle it. + + @note The extra two bits are added to bits 13 and 14 of the + parameter data (with 1 being the least siginficant bit and 16 the + most significant bit of the word) by xoring the extra length bits + with the real type. Since all allowable types have 0xF as most + significant bits of the metadata word, lengths <256 will not affect + the real type at all, while all other values will result in a + non-existant type in the range 17-244. + + @see Field_string::unpack + + @param metadata_ptr First byte of field metadata + + @returns number of bytes written to metadata_ptr +*/ +int Field_string::do_save_field_metadata(uchar *metadata_ptr) +{ + DBUG_ASSERT(field_length < 1024); + DBUG_ASSERT((real_type() & 0xF0) == 0xF0); + DBUG_PRINT("debug", ("field_length: %u, real_type: %u", + field_length, real_type())); + *metadata_ptr= (real_type() ^ ((field_length & 0x300) >> 4)); + *(metadata_ptr + 1)= field_length & 0xFF; + return 2; +} + + /* Compare two packed keys @@ -6238,7 +6866,7 @@ const char *Field_string::unpack(char *to, const char *from) > 0 a > b */ -int Field_string::pack_cmp(const char *a, const char *b, uint length, +int Field_string::pack_cmp(const uchar *a, const uchar *b, uint length, my_bool insert_or_update) { uint a_length, b_length; @@ -6251,43 +6879,43 @@ int Field_string::pack_cmp(const char *a, const char *b, uint length, } else { - a_length= (uint) (uchar) *a++; - b_length= (uint) (uchar) *b++; + a_length= (uint) *a++; + b_length= (uint) *b++; } return field_charset->coll->strnncollsp(field_charset, - (const uchar*) a, a_length, - (const uchar*) b, b_length, + a, a_length, + b, b_length, insert_or_update); } -/* - Compare a packed key against row +/** + Compare a packed key against row. - SYNOPSIS - pack_cmp() - key Original key - length Key length. (May be less than field length) - insert_or_update 1 if this is an insert or update + @param key Original key + @param length Key length. (May be less than field length) + @param insert_or_update 1 if this is an insert or update - RETURN + @return < 0 row < key + @return 0 row = key + @return > 0 row > key */ -int Field_string::pack_cmp(const char *key, uint length, +int Field_string::pack_cmp(const uchar *key, uint length, my_bool insert_or_update) { uint row_length, local_key_length; - char *end; + uchar *end; if (length > 255) { local_key_length= uint2korr(key); key+= 2; } else - local_key_length= (uint) (uchar) *key++; + local_key_length= (uint) *key++; /* Only use 'length' of key, not field_length */ end= ptr + length; @@ -6296,17 +6924,17 @@ int Field_string::pack_cmp(const char *key, uint length, row_length= (uint) (end - ptr); return field_charset->coll->strnncollsp(field_charset, - (const uchar*) ptr, row_length, - (const uchar*) key, local_key_length, + ptr, row_length, + key, local_key_length, insert_or_update); } -uint Field_string::packed_col_length(const char *data_ptr, uint length) +uint Field_string::packed_col_length(const uchar *data_ptr, uint length) { if (length > 255) return uint2korr(data_ptr)+2; - return (uint) ((uchar) *data_ptr)+1; + return (uint) *data_ptr + 1; } @@ -6315,34 +6943,35 @@ uint Field_string::max_packed_col_length(uint max_length) return (max_length > 255 ? 2 : 1)+max_length; } -uint Field_string::get_key_image(char *buff, uint length, imagetype type_arg) + +uint Field_string::get_key_image(uchar *buff, uint length, imagetype type_arg) { - uint bytes = my_charpos(field_charset, ptr, ptr + field_length, + uint bytes = my_charpos(field_charset, (char*) ptr, + (char*) ptr + field_length, length / field_charset->mbmaxlen); memcpy(buff, ptr, bytes); if (bytes < length) - field_charset->cset->fill(field_charset, buff + bytes, length - bytes, - field_charset->pad_char); + field_charset->cset->fill(field_charset, (char*) buff + bytes, + length - bytes, field_charset->pad_char); return bytes; } + Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table, bool keep_type) { Field *field; - if (type() != MYSQL_TYPE_VAR_STRING || keep_type) field= Field::new_field(root, new_table, keep_type); - else + else if ((field= new Field_varstring(field_length, maybe_null(), field_name, + new_table->s, charset()))) { - /* Old VARCHAR field which should be modified to a VARCHAR on copy This is done to ensure that ALTER TABLE will convert old VARCHAR fields to now VARCHAR fields. */ - field= new Field_varstring(field_length, maybe_null(), - field_name, new_table, charset()); + field->init(new_table); /* Normally orig_table is different from table only if field was created via ::new_field. Here we alter the type of field, so ::new_field is @@ -6354,6 +6983,7 @@ Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table, return field; } + /**************************************************************************** VARCHAR type Data in field->ptr is stored as: @@ -6372,15 +7002,36 @@ Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table, const uint Field_varstring::MAX_SIZE= UINT_MAX16; +/** + Save the field metadata for varstring fields. + + Saves the field length in the first byte. Note: may consume + 2 bytes. Caller must ensure second byte is contiguous with + first byte (e.g. array index 0,1). + + @param metadata_ptr First byte of field metadata + + @returns number of bytes written to metadata_ptr +*/ +int Field_varstring::do_save_field_metadata(uchar *metadata_ptr) +{ + char *ptr= (char *)metadata_ptr; + DBUG_ASSERT(field_length <= 65535); + int2store(ptr, field_length); + return 2; +} + int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; uint copy_length; const char *well_formed_error_pos; const char *cannot_convert_error_pos; const char *from_end_pos; copy_length= well_formed_copy_nchars(field_charset, - ptr + length_bytes, field_length, + (char*) ptr + length_bytes, + field_length, cs, from, length, field_length / field_charset->mbmaxlen, &well_formed_error_pos, @@ -6393,7 +7044,7 @@ int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs) int2store(ptr, copy_length); if (check_string_copy_error(this, well_formed_error_pos, - cannot_convert_error_pos, from + length)) + cannot_convert_error_pos, from + length, cs)) return 2; return report_if_important_data(from_end_pos, from + length, TRUE); @@ -6416,27 +7067,30 @@ int Field_varstring::store(longlong nr, bool unsigned_val) double Field_varstring::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int not_used; char *end_not_used; - uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); - return my_strntod(field_charset, ptr+length_bytes, length, &end_not_used, - ¬_used); + uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); + return my_strntod(field_charset, (char*) ptr+length_bytes, length, + &end_not_used, ¬_used); } longlong Field_varstring::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int not_used; char *end_not_used; - uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); - return my_strntoll(field_charset, ptr+length_bytes, length, 10, + uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); + return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10, &end_not_used, ¬_used); } String *Field_varstring::val_str(String *val_buffer __attribute__((unused)), String *val_ptr) { - uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); + ASSERT_COLUMN_MARKED_FOR_READ; + uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); val_ptr->set((const char*) ptr+length_bytes, length, field_charset); return val_ptr; } @@ -6444,84 +7098,87 @@ String *Field_varstring::val_str(String *val_buffer __attribute__((unused)), my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value) { - uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); - str2my_decimal(E_DEC_FATAL_ERROR, ptr+length_bytes, length, charset(), - decimal_value); + ASSERT_COLUMN_MARKED_FOR_READ; + uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); + str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length, + charset(), decimal_value); return decimal_value; } -int Field_varstring::cmp(const char *a_ptr, const char *b_ptr) +int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr, + uint max_len) { uint a_length, b_length; int diff; if (length_bytes == 1) { - a_length= (uint) (uchar) *a_ptr; - b_length= (uint) (uchar) *b_ptr; + a_length= (uint) *a_ptr; + b_length= (uint) *b_ptr; } else { a_length= uint2korr(a_ptr); b_length= uint2korr(b_ptr); } + set_if_smaller(a_length, max_len); + set_if_smaller(b_length, max_len); diff= field_charset->coll->strnncollsp(field_charset, - (const uchar*) a_ptr+ + a_ptr+ length_bytes, a_length, - (const uchar*) b_ptr+ + b_ptr+ length_bytes, b_length,0); return diff; } -/* - NOTE: varstring and blob keys are ALWAYS stored with a 2 byte length prefix +/** + @note + varstring and blob keys are ALWAYS stored with a 2 byte length prefix */ -int Field_varstring::key_cmp(const byte *key_ptr, uint max_key_length) +int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length) { - uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); + uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); uint local_char_length= max_key_length / field_charset->mbmaxlen; local_char_length= my_charpos(field_charset, ptr + length_bytes, ptr + length_bytes + length, local_char_length); set_if_smaller(length, local_char_length); return field_charset->coll->strnncollsp(field_charset, - (const uchar*) ptr + length_bytes, + ptr + length_bytes, length, - (const uchar*) key_ptr+ + key_ptr+ HA_KEY_BLOB_LENGTH, uint2korr(key_ptr), 0); } -/* - Compare to key segments (always 2 byte length prefix) +/** + Compare to key segments (always 2 byte length prefix). - NOTE + @note This is used only to compare key segments created for index_read(). (keys are created and compared in key.cc) */ -int Field_varstring::key_cmp(const byte *a,const byte *b) +int Field_varstring::key_cmp(const uchar *a,const uchar *b) { return field_charset->coll->strnncollsp(field_charset, - (const uchar*) a + - HA_KEY_BLOB_LENGTH, + a + HA_KEY_BLOB_LENGTH, uint2korr(a), - (const uchar*) b + - HA_KEY_BLOB_LENGTH, + b + HA_KEY_BLOB_LENGTH, uint2korr(b), 0); } -void Field_varstring::sort_string(char *to,uint length) +void Field_varstring::sort_string(uchar *to,uint length) { - uint tot_length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); + uint tot_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); if (field_charset == &my_charset_bin) { @@ -6534,8 +7191,7 @@ void Field_varstring::sort_string(char *to,uint length) } tot_length= my_strnxfrm(field_charset, - (uchar*) to, length, - (uchar*) ptr + length_bytes, + to, length, ptr + length_bytes, tot_length); DBUG_ASSERT(tot_length == length); } @@ -6570,9 +7226,9 @@ void Field_varstring::sql_type(String &res) const } -uint32 Field_varstring::data_length(const char *from) +uint32 Field_varstring::data_length() { - return length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); + return length_bytes == 1 ? (uint32) *ptr : uint2korr(ptr); } /* @@ -6580,24 +7236,32 @@ uint32 Field_varstring::data_length(const char *from) Here the number of length bytes are depending on the given max_length */ -char *Field_varstring::pack(char *to, const char *from, uint max_length) +uchar *Field_varstring::pack(uchar *to, const uchar *from, + uint max_length, + bool low_byte_first __attribute__((unused))) { - uint length= length_bytes == 1 ? (uint) (uchar) *from : uint2korr(from); + uint length= length_bytes == 1 ? (uint) *from : uint2korr(from); set_if_smaller(max_length, field_length); if (length > max_length) length=max_length; - *to++= (char) (length & 255); + + /* Length always stored little-endian */ + *to++= length & 0xFF; if (max_length > 255) - *to++= (char) (length >> 8); - if (length) + *to++= (length >> 8) & 0xFF; + + /* Store bytes of string */ + if (length > 0) memcpy(to, from+length_bytes, length); return to+length; } -char *Field_varstring::pack_key(char *to, const char *key, uint max_length) +uchar * +Field_varstring::pack_key(uchar *to, const uchar *key, uint max_length, + bool low_byte_first __attribute__((unused))) { - uint length= length_bytes == 1 ? (uint) (uchar) *key : uint2korr(key); + uint length= length_bytes == 1 ? (uint) *key : uint2korr(key); uint local_char_length= ((field_charset->mbmaxlen > 1) ? max_length/field_charset->mbmaxlen : max_length); key+= length_bytes; @@ -6616,31 +7280,29 @@ char *Field_varstring::pack_key(char *to, const char *key, uint max_length) } -/* +/** Unpack a key into a record buffer. - SYNOPSIS - unpack_key() - to Pointer into the record buffer. - key Pointer to the packed key. - max_length Key length limit from key description. + A VARCHAR key has a maximum size of 64K-1. + In its packed form, the length field is one or two bytes long, + depending on 'max_length'. - DESCRIPTION - A VARCHAR key has a maximum size of 64K-1. - In its packed form, the length field is one or two bytes long, - depending on 'max_length'. + @param to Pointer into the record buffer. + @param key Pointer to the packed key. + @param max_length Key length limit from key description. - RETURN + @return Pointer to end of 'key' (To the next key part if multi-segment key) */ -const char *Field_varstring::unpack_key(char *to, const char *key, - uint max_length) +const uchar * +Field_varstring::unpack_key(uchar *to, const uchar *key, uint max_length, + bool low_byte_first __attribute__((unused))) { /* get length of the blob key */ - uint32 length= *((uchar*) key++); + uint32 length= *key++; if (max_length > 255) - length+= (*((uchar*) key++)) << 8; + length+= (*key++) << 8; /* put the length into the record buffer */ if (length_bytes == 1) @@ -6651,21 +7313,20 @@ const char *Field_varstring::unpack_key(char *to, const char *key, return key + length; } -/* - Create a packed key that will be used for storage in the index tree +/** + Create a packed key that will be used for storage in the index tree. - SYNOPSIS - pack_key_from_key_image() - to Store packed key segment here - from Key segment (as given to index_read()) - max_length Max length of key + @param to Store packed key segment here + @param from Key segment (as given to index_read()) + @param max_length Max length of key - RETURN + @return end of key storage */ -char *Field_varstring::pack_key_from_key_image(char *to, const char *from, - uint max_length) +uchar * +Field_varstring::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length, + bool low_byte_first __attribute__((unused))) { /* Key length is always stored as 2 bytes */ uint length= uint2korr(from); @@ -6680,16 +7341,37 @@ char *Field_varstring::pack_key_from_key_image(char *to, const char *from, } -/* - unpack field packed with Field_varstring::pack() -*/ +/** + Unpack a varstring field from row data. + + This method is used to unpack a varstring field from a master + whose size of the field is less than that of the slave. -const char *Field_varstring::unpack(char *to, const char *from) + @note + The string length is always packed little-endian. + + @param to Destination of the data + @param from Source of the data + @param param_data Length bytes from the master's field data + + @return New pointer into memory based on from + length of the data +*/ +const uchar * +Field_varstring::unpack(uchar *to, const uchar *from, + uint param_data, + bool low_byte_first __attribute__((unused))) { uint length; - if (length_bytes == 1) - length= (uint) (uchar) (*to= *from++); - else + uint l_bytes= (param_data && (param_data < field_length)) ? + (param_data <= 255) ? 1 : 2 : length_bytes; + if (l_bytes == 1) + { + to[0]= *from++; + length= to[0]; + if (length_bytes == 2) + to[1]= 0; + } + else /* l_bytes == 2 */ { length= uint2korr(from); to[0]= *from++; @@ -6701,7 +7383,7 @@ const char *Field_varstring::unpack(char *to, const char *from) } -int Field_varstring::pack_cmp(const char *a, const char *b, +int Field_varstring::pack_cmp(const uchar *a, const uchar *b, uint key_length_arg, my_bool insert_or_update) { @@ -6713,21 +7395,21 @@ int Field_varstring::pack_cmp(const char *a, const char *b, } else { - a_length= (uint) (uchar) *a++; - b_length= (uint) (uchar) *b++; + a_length= (uint) *a++; + b_length= (uint) *b++; } return field_charset->coll->strnncollsp(field_charset, - (const uchar*) a, a_length, - (const uchar*) b, b_length, + a, a_length, + b, b_length, insert_or_update); } -int Field_varstring::pack_cmp(const char *b, uint key_length_arg, +int Field_varstring::pack_cmp(const uchar *b, uint key_length_arg, my_bool insert_or_update) { - char *a= ptr+ length_bytes; - uint a_length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); + uchar *a= ptr+ length_bytes; + uint a_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); uint b_length; uint local_char_length= ((field_charset->mbmaxlen > 1) ? key_length_arg / field_charset->mbmaxlen : @@ -6738,7 +7420,7 @@ int Field_varstring::pack_cmp(const char *b, uint key_length_arg, b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH; } else - b_length= (uint) (uchar) *b++; + b_length= (uint) *b++; if (a_length > local_char_length) { @@ -6748,18 +7430,17 @@ int Field_varstring::pack_cmp(const char *b, uint key_length_arg, } return field_charset->coll->strnncollsp(field_charset, - (const uchar*) a, - a_length, - (const uchar*) b, b_length, + a, a_length, + b, b_length, insert_or_update); } -uint Field_varstring::packed_col_length(const char *data_ptr, uint length) +uint Field_varstring::packed_col_length(const uchar *data_ptr, uint length) { if (length > 255) return uint2korr(data_ptr)+2; - return (uint) ((uchar) *data_ptr)+1; + return (uint) *data_ptr + 1; } @@ -6768,11 +7449,11 @@ uint Field_varstring::max_packed_col_length(uint max_length) return (max_length > 255 ? 2 : 1)+max_length; } -uint Field_varstring::get_key_image(char *buff, uint length, imagetype type) +uint Field_varstring::get_key_image(uchar *buff, uint length, imagetype type) { - uint f_length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr); + uint f_length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); uint local_char_length= length / field_charset->mbmaxlen; - char *pos= ptr+length_bytes; + uchar *pos= ptr+length_bytes; local_char_length= my_charpos(field_charset, pos, pos + f_length, local_char_length); set_if_smaller(f_length, local_char_length); @@ -6791,23 +7472,23 @@ uint Field_varstring::get_key_image(char *buff, uint length, imagetype type) } -void Field_varstring::set_key_image(char *buff,uint length) +void Field_varstring::set_key_image(const uchar *buff,uint length) { length= uint2korr(buff); // Real length is here - (void) Field_varstring::store(buff+HA_KEY_BLOB_LENGTH, length, + (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length, field_charset); } -int Field_varstring::cmp_binary(const char *a_ptr, const char *b_ptr, +int Field_varstring::cmp_binary(const uchar *a_ptr, const uchar *b_ptr, uint32 max_length) { uint32 a_length,b_length; if (length_bytes == 1) { - a_length= (uint) (uchar) *a_ptr; - b_length= (uint) (uchar) *b_ptr; + a_length= (uint) *a_ptr; + b_length= (uint) *b_ptr; } else { @@ -6835,7 +7516,7 @@ Field *Field_varstring::new_field(MEM_ROOT *root, struct st_table *new_table, Field *Field_varstring::new_key_field(MEM_ROOT *root, struct st_table *new_table, - char *new_ptr, uchar *new_null_ptr, + uchar *new_ptr, uchar *new_null_ptr, uint new_null_bit) { Field_varstring *res; @@ -6852,72 +7533,103 @@ Field *Field_varstring::new_key_field(MEM_ROOT *root, } +uint Field_varstring::is_equal(Create_field *new_field) +{ + if (new_field->sql_type == real_type() && + new_field->charset == field_charset) + { + if (new_field->length == max_display_length()) + return IS_EQUAL_YES; + if (new_field->length > max_display_length() && + ((new_field->length <= 255 && max_display_length() <= 255) || + (new_field->length > 255 && max_display_length() > 255))) + return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length + } + return IS_EQUAL_NO; +} + + +void Field_varstring::hash(ulong *nr, ulong *nr2) +{ + if (is_null()) + { + *nr^= (*nr << 1) | 1; + } + else + { + uint len= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr); + CHARSET_INFO *cs= charset(); + cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2); + } +} + + /**************************************************************************** ** blob type ** A blob is saved as a length and a pointer. The length is stored in the ** packlength slot and may be from 1-4. ****************************************************************************/ -Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, +Field_blob::Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, enum utype unireg_check_arg, const char *field_name_arg, - struct st_table *table_arg,uint blob_pack_length, + TABLE_SHARE *share, uint blob_pack_length, CHARSET_INFO *cs) :Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length), - null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg, - table_arg, cs), + null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg, + cs), packlength(blob_pack_length) { flags|= BLOB_FLAG; - if (table) - { - table->s->blob_fields++; - /* TODO: why do not fill table->s->blob_field array here? */ - } + share->blob_fields++; + /* TODO: why do not fill table->s->blob_field array here? */ } -void Field_blob::store_length(uint32 number) +void Field_blob::store_length(uchar *i_ptr, + uint i_packlength, + uint32 i_number, + bool low_byte_first) { - switch (packlength) { + switch (i_packlength) { case 1: - ptr[0]= (uchar) number; + i_ptr[0]= (uchar) i_number; break; case 2: #ifdef WORDS_BIGENDIAN - if (table->s->db_low_byte_first) + if (low_byte_first) { - int2store(ptr,(unsigned short) number); + int2store(i_ptr,(unsigned short) i_number); } else #endif - shortstore(ptr,(unsigned short) number); + shortstore(i_ptr,(unsigned short) i_number); break; case 3: - int3store(ptr,number); + int3store(i_ptr,i_number); break; case 4: #ifdef WORDS_BIGENDIAN - if (table->s->db_low_byte_first) + if (low_byte_first) { - int4store(ptr,number); + int4store(i_ptr,i_number); } else #endif - longstore(ptr,number); + longstore(i_ptr,i_number); } } -uint32 Field_blob::get_length(const char *pos) +uint32 Field_blob::get_length(const uchar *pos, uint packlength_arg, bool low_byte_first) { - switch (packlength) { + switch (packlength_arg) { case 1: - return (uint32) (uchar) pos[0]; + return (uint32) pos[0]; case 2: { uint16 tmp; #ifdef WORDS_BIGENDIAN - if (table->s->db_low_byte_first) + if (low_byte_first) tmp=sint2korr(pos); else #endif @@ -6930,7 +7642,7 @@ uint32 Field_blob::get_length(const char *pos) { uint32 tmp; #ifdef WORDS_BIGENDIAN - if (table->s->db_low_byte_first) + if (low_byte_first) tmp=uint4korr(pos); else #endif @@ -6943,24 +7655,18 @@ uint32 Field_blob::get_length(const char *pos) } -/* +/** Put a blob length field into a record buffer. - SYNOPSIS - Field_blob::put_length() - pos Pointer into the record buffer. - length The length value to put. + Depending on the maximum length of a blob, its length field is + put into 1 to 4 bytes. This is a property of the blob object, + described by 'packlength'. - DESCRIPTION - Depending on the maximum length of a blob, its length field is - put into 1 to 4 bytes. This is a property of the blob object, - described by 'packlength'. - - RETURN - nothing + @param pos Pointer into the record buffer. + @param length The length value to put. */ -void Field_blob::put_length(char *pos, uint32 length) +void Field_blob::put_length(uchar *pos, uint32 length) { switch (packlength) { case 1: @@ -6981,6 +7687,7 @@ void Field_blob::put_length(char *pos, uint32 length) int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; uint copy_length, new_length; const char *well_formed_error_pos; const char *cannot_convert_error_pos; @@ -7022,6 +7729,17 @@ int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs) if (value.alloc(new_length)) goto oom_error; + + if (f_is_hex_escape(flags)) + { + copy_length= my_copy_with_hex_escaping(field_charset, + (char*) value.ptr(), new_length, + from, length); + Field_blob::store_length(copy_length); + tmp= value.ptr(); + bmove(ptr + packlength, (uchar*) &tmp, sizeof(char*)); + return 0; + } /* "length" is OK as "nchars" argument to well_formed_copy_nchars as this is never used to limit the length of the data. The cut of long data @@ -7037,10 +7755,10 @@ int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs) Field_blob::store_length(copy_length); tmp= value.ptr(); - bmove(ptr+packlength,(char*) &tmp,sizeof(char*)); + bmove(ptr+packlength,(uchar*) &tmp,sizeof(char*)); if (check_string_copy_error(this, well_formed_error_pos, - cannot_convert_error_pos, from + length)) + cannot_convert_error_pos, from + length, cs)) return 2; return report_if_important_data(from_end_pos, from + length, TRUE); @@ -7055,7 +7773,7 @@ oom_error: int Field_blob::store(double nr) { CHARSET_INFO *cs=charset(); - value.set(nr, 2, cs); + value.set_real(nr, 2, cs); return Field_blob::store(value.ptr(),(uint) value.length(), cs); } @@ -7063,16 +7781,14 @@ int Field_blob::store(double nr) int Field_blob::store(longlong nr, bool unsigned_val) { CHARSET_INFO *cs=charset(); - if (unsigned_val) - value.set((ulonglong) nr, cs); - else - value.set(nr, cs); + value.set_int(nr, unsigned_val, cs); return Field_blob::store(value.ptr(), (uint) value.length(), cs); } double Field_blob::val_real(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int not_used; char *end_not_used, *blob; uint32 length; @@ -7089,6 +7805,7 @@ double Field_blob::val_real(void) longlong Field_blob::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; int not_used; char *blob; memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); @@ -7101,6 +7818,7 @@ longlong Field_blob::val_int(void) String *Field_blob::val_str(String *val_buffer __attribute__((unused)), String *val_ptr) { + ASSERT_COLUMN_MARKED_FOR_READ; char *blob; memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); if (!blob) @@ -7113,37 +7831,47 @@ String *Field_blob::val_str(String *val_buffer __attribute__((unused)), my_decimal *Field_blob::val_decimal(my_decimal *decimal_value) { + ASSERT_COLUMN_MARKED_FOR_READ; const char *blob; - memcpy_fixed(&blob, ptr+packlength, sizeof(const char*)); + size_t length; + memcpy_fixed(&blob, ptr+packlength, sizeof(const uchar*)); if (!blob) + { blob= ""; - str2my_decimal(E_DEC_FATAL_ERROR, blob, get_length(ptr), charset(), + length= 0; + } + else + length= get_length(ptr); + + str2my_decimal(E_DEC_FATAL_ERROR, blob, length, charset(), decimal_value); return decimal_value; } -int Field_blob::cmp(const char *a,uint32 a_length, const char *b, +int Field_blob::cmp(const uchar *a,uint32 a_length, const uchar *b, uint32 b_length) { return field_charset->coll->strnncollsp(field_charset, - (const uchar*)a, a_length, - (const uchar*)b, b_length, + a, a_length, b, b_length, 0); } -int Field_blob::cmp(const char *a_ptr, const char *b_ptr) +int Field_blob::cmp_max(const uchar *a_ptr, const uchar *b_ptr, + uint max_length) { - char *blob1,*blob2; + uchar *blob1,*blob2; memcpy_fixed(&blob1,a_ptr+packlength,sizeof(char*)); memcpy_fixed(&blob2,b_ptr+packlength,sizeof(char*)); - return Field_blob::cmp(blob1,get_length(a_ptr), - blob2,get_length(b_ptr)); + uint a_len= get_length(a_ptr), b_len= get_length(b_ptr); + set_if_smaller(a_len, max_length); + set_if_smaller(b_len, max_length); + return Field_blob::cmp(blob1,a_len,blob2,b_len); } -int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr, +int Field_blob::cmp_binary(const uchar *a_ptr, const uchar *b_ptr, uint32 max_length) { char *a,*b; @@ -7164,10 +7892,10 @@ int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr, /* The following is used only when comparing a key */ -uint Field_blob::get_key_image(char *buff,uint length, imagetype type_arg) +uint Field_blob::get_key_image(uchar *buff,uint length, imagetype type_arg) { uint32 blob_length= get_length(ptr); - char *blob; + uchar *blob; #ifdef HAVE_SPATIAL if (type_arg == itMBR) @@ -7184,7 +7912,7 @@ uint Field_blob::get_key_image(char *buff,uint length, imagetype type_arg) return image_length; } get_ptr(&blob); - gobj= Geometry::construct(&buffer, blob, blob_length); + gobj= Geometry::construct(&buffer, (char*) blob, blob_length); if (!gobj || gobj->get_mbr(&mbr, &dummy)) bzero(buff, image_length); else @@ -7219,16 +7947,17 @@ uint Field_blob::get_key_image(char *buff,uint length, imagetype type_arg) } -void Field_blob::set_key_image(char *buff,uint length) +void Field_blob::set_key_image(const uchar *buff,uint length) { length= uint2korr(buff); - (void) Field_blob::store(buff+HA_KEY_BLOB_LENGTH, length, field_charset); + (void) Field_blob::store((const char*) buff+HA_KEY_BLOB_LENGTH, length, + field_charset); } -int Field_blob::key_cmp(const byte *key_ptr, uint max_key_length) +int Field_blob::key_cmp(const uchar *key_ptr, uint max_key_length) { - char *blob1; + uchar *blob1; uint blob_length=get_length(ptr); memcpy_fixed(&blob1,ptr+packlength,sizeof(char*)); CHARSET_INFO *cs= charset(); @@ -7237,14 +7966,31 @@ int Field_blob::key_cmp(const byte *key_ptr, uint max_key_length) local_char_length); set_if_smaller(blob_length, local_char_length); return Field_blob::cmp(blob1, blob_length, - (char*) key_ptr+HA_KEY_BLOB_LENGTH, + key_ptr+HA_KEY_BLOB_LENGTH, uint2korr(key_ptr)); } -int Field_blob::key_cmp(const byte *a,const byte *b) +int Field_blob::key_cmp(const uchar *a,const uchar *b) { - return Field_blob::cmp((char*) a+HA_KEY_BLOB_LENGTH, uint2korr(a), - (char*) b+HA_KEY_BLOB_LENGTH, uint2korr(b)); + return Field_blob::cmp(a+HA_KEY_BLOB_LENGTH, uint2korr(a), + b+HA_KEY_BLOB_LENGTH, uint2korr(b)); +} + + +/** + Save the field metadata for blob fields. + + Saves the pack length in the first byte of the field metadata array + at index of *metadata_ptr. + + @param metadata_ptr First byte of field metadata + + @returns number of bytes written to metadata_ptr +*/ +int Field_blob::do_save_field_metadata(uchar *metadata_ptr) +{ + *metadata_ptr= pack_length_no_ptr(); + return 1; } @@ -7255,9 +8001,9 @@ uint32 Field_blob::sort_length() const } -void Field_blob::sort_string(char *to,uint length) +void Field_blob::sort_string(uchar *to,uint length) { - char *blob; + uchar *blob; uint blob_length=get_length(); if (!blob_length) @@ -7266,7 +8012,7 @@ void Field_blob::sort_string(char *to,uint length) { if (field_charset == &my_charset_bin) { - char *pos; + uchar *pos; /* Store length of blob last in blob to shorter blobs before longer blobs @@ -7292,8 +8038,7 @@ void Field_blob::sort_string(char *to,uint length) memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); blob_length=my_strnxfrm(field_charset, - (uchar*) to, length, - (uchar*) blob, blob_length); + to, length, blob, blob_length); DBUG_ASSERT(blob_length == length); } } @@ -7318,46 +8063,80 @@ void Field_blob::sql_type(String &res) const } } - -char *Field_blob::pack(char *to, const char *from, uint max_length) +uchar *Field_blob::pack(uchar *to, const uchar *from, + uint max_length, bool low_byte_first) { - char *save=ptr; - ptr=(char*) from; + DBUG_ENTER("Field_blob::pack"); + DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx;" + " max_length: %u; low_byte_first: %d", + (ulong) to, (ulong) from, + max_length, low_byte_first)); + DBUG_DUMP("record", from, table->s->reclength); + uchar *save= ptr; + ptr= (uchar*) from; uint32 length=get_length(); // Length of from string - if (length > max_length) - { - ptr=to; - length=max_length; - store_length(length); // Store max length - ptr=(char*) from; - } - else - memcpy(to,from,packlength); // Copy length - if (length) + + /* + Store max length, which will occupy packlength bytes. If the max + length given is smaller than the actual length of the blob, we + just store the initial bytes of the blob. + */ + store_length(to, packlength, min(length, max_length), low_byte_first); + + /* + Store the actual blob data, which will occupy 'length' bytes. + */ + if (length > 0) { - get_ptr((char**) &from); + get_ptr((uchar**) &from); memcpy(to+packlength, from,length); } ptr=save; // Restore org row pointer - return to+packlength+length; + DBUG_DUMP("packed", to, packlength + length); + DBUG_RETURN(to+packlength+length); } -const char *Field_blob::unpack(char *to, const char *from) -{ - memcpy(to,from,packlength); - uint32 length=get_length(from); - from+=packlength; - if (length) - memcpy_fixed(to+packlength, &from, sizeof(from)); - else - bzero(to+packlength,sizeof(from)); - return from+length; +/** + Unpack a blob field from row data. + + This method is used to unpack a blob field from a master whose size of + the field is less than that of the slave. Note: This method is included + to satisfy inheritance rules, but is not needed for blob fields. It + simply is used as a pass-through to the original unpack() method for + blob fields. + + @param to Destination of the data + @param from Source of the data + @param param_data @c TRUE if base types should be stored in little- + endian format, @c FALSE if native format should + be used. + + @return New pointer into memory based on from + length of the data +*/ +const uchar *Field_blob::unpack(uchar *to, + const uchar *from, + uint param_data, + bool low_byte_first) +{ + DBUG_ENTER("Field_blob::unpack"); + DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx;" + " param_data: %u; low_byte_first: %d", + (ulong) to, (ulong) from, param_data, low_byte_first)); + uint const master_packlength= + param_data > 0 ? param_data & 0xFF : packlength; + uint32 const length= get_length(from, master_packlength, low_byte_first); + DBUG_DUMP("packed", from, length + master_packlength); + bitmap_set_bit(table->write_set, field_index); + store(reinterpret_cast<const char*>(from) + master_packlength, + length, field_charset); + DBUG_DUMP("record", to, table->s->reclength); + DBUG_RETURN(from + master_packlength + length); } /* Keys for blobs are like keys on varchars */ -int Field_blob::pack_cmp(const char *a, const char *b, uint key_length_arg, +int Field_blob::pack_cmp(const uchar *a, const uchar *b, uint key_length_arg, my_bool insert_or_update) { uint a_length, b_length; @@ -7368,20 +8147,20 @@ int Field_blob::pack_cmp(const char *a, const char *b, uint key_length_arg, } else { - a_length= (uint) (uchar) *a++; - b_length= (uint) (uchar) *b++; + a_length= (uint) *a++; + b_length= (uint) *b++; } return field_charset->coll->strnncollsp(field_charset, - (const uchar*) a, a_length, - (const uchar*) b, b_length, + a, a_length, + b, b_length, insert_or_update); } -int Field_blob::pack_cmp(const char *b, uint key_length_arg, +int Field_blob::pack_cmp(const uchar *b, uint key_length_arg, my_bool insert_or_update) { - char *a; + uchar *a; uint a_length, b_length; memcpy_fixed(&a,ptr+packlength,sizeof(char*)); if (!a) @@ -7393,24 +8172,26 @@ int Field_blob::pack_cmp(const char *b, uint key_length_arg, b_length= uint2korr(b); b+=2; } else - b_length= (uint) (uchar) *b++; + b_length= (uint) *b++; return field_charset->coll->strnncollsp(field_charset, - (const uchar*) a, a_length, - (const uchar*) b, b_length, + a, a_length, + b, b_length, insert_or_update); } -/* Create a packed key that will be used for storage from a MySQL row */ +/** Create a packed key that will be used for storage from a MySQL row. */ -char *Field_blob::pack_key(char *to, const char *from, uint max_length) +uchar * +Field_blob::pack_key(uchar *to, const uchar *from, uint max_length, + bool low_byte_first __attribute__((unused))) { - char *save=ptr; - ptr=(char*) from; - uint32 length=get_length(); // Length of from string + uchar *save= ptr; + ptr= (uchar*) from; + uint32 length=get_length(); // Length of from string uint local_char_length= ((field_charset->mbmaxlen > 1) ? - max_length/field_charset->mbmaxlen : max_length); + max_length/field_charset->mbmaxlen : max_length); if (length) - get_ptr((char**) &from); + get_ptr((uchar**) &from); if (length > local_char_length) local_char_length= my_charpos(field_charset, from, from+length, local_char_length); @@ -7424,35 +8205,35 @@ char *Field_blob::pack_key(char *to, const char *from, uint max_length) } -/* +/** Unpack a blob key into a record buffer. - SYNOPSIS - Field_blob::unpack_key() - to Pointer into the record buffer. - from Pointer to the packed key. - max_length Key length limit from key description. + A blob key has a maximum size of 64K-1. + In its packed form, the length field is one or two bytes long, + depending on 'max_length'. + Depending on the maximum length of a blob, its length field is + put into 1 to 4 bytes. This is a property of the blob object, + described by 'packlength'. + Blobs are internally stored apart from the record buffer, which + contains a pointer to the blob buffer. - DESCRIPTION - A blob key has a maximum size of 64K-1. - In its packed form, the length field is one or two bytes long, - depending on 'max_length'. - Depending on the maximum length of a blob, its length field is - put into 1 to 4 bytes. This is a property of the blob object, - described by 'packlength'. - Blobs are internally stored apart from the record buffer, which - contains a pointer to the blob buffer. - RETURN + @param to Pointer into the record buffer. + @param from Pointer to the packed key. + @param max_length Key length limit from key description. + + @return Pointer into 'from' past the last byte copied from packed key. */ -const char *Field_blob::unpack_key(char *to, const char *from, uint max_length) +const uchar * +Field_blob::unpack_key(uchar *to, const uchar *from, uint max_length, + bool low_byte_first __attribute__((unused))) { /* get length of the blob key */ - uint32 length= *((uchar*) from++); + uint32 length= *from++; if (max_length > 255) - length+= (*((uchar*) from++)) << 8; + length+= *from++ << 8; /* put the length into the record buffer */ put_length(to, length); @@ -7468,10 +8249,11 @@ const char *Field_blob::unpack_key(char *to, const char *from, uint max_length) } -/* Create a packed key that will be used for storage from a MySQL key */ +/** Create a packed key that will be used for storage from a MySQL key. */ -char *Field_blob::pack_key_from_key_image(char *to, const char *from, - uint max_length) +uchar * +Field_blob::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length, + bool low_byte_first __attribute__((unused))) { uint length=uint2korr(from); if (length > max_length) @@ -7485,11 +8267,11 @@ char *Field_blob::pack_key_from_key_image(char *to, const char *from, } -uint Field_blob::packed_col_length(const char *data_ptr, uint length) +uint Field_blob::packed_col_length(const uchar *data_ptr, uint length) { if (length > 255) return uint2korr(data_ptr)+2; - return (uint) ((uchar) *data_ptr)+1; + return (uint) *data_ptr + 1; } @@ -7499,6 +8281,18 @@ uint Field_blob::max_packed_col_length(uint max_length) } +uint Field_blob::is_equal(Create_field *new_field) +{ + if (compare_str_field_flags(new_field, flags)) + return 0; + + return ((new_field->sql_type == get_blob_type_from_length(max_data_length())) + && new_field->charset == field_charset && + ((Field_blob *)new_field->field)->max_data_length() == + max_data_length()); +} + + #ifdef HAVE_SPATIAL void Field_geom::sql_type(String &res) const @@ -7647,13 +8441,15 @@ void Field_enum::store_type(ulonglong value) } -/* -** Note. Storing a empty string in a enum field gives a warning -** (if there isn't a empty value in the enum) +/** + @note + Storing a empty string in a enum field gives a warning + (if there isn't a empty value in the enum) */ int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int err= 0; uint32 not_used; char buff[STRING_BUFFER_USUAL_SIZE]; @@ -7702,6 +8498,7 @@ int Field_enum::store(double nr) int Field_enum::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; if ((ulonglong) nr > typelib->count || nr == 0) { @@ -7725,49 +8522,69 @@ double Field_enum::val_real(void) longlong Field_enum::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; switch (packlength) { case 1: - return (longlong) (uchar) ptr[0]; + return (longlong) ptr[0]; case 2: - { - uint16 tmp; + { + uint16 tmp; #ifdef WORDS_BIGENDIAN - if (table->s->db_low_byte_first) - tmp=sint2korr(ptr); - else + if (table->s->db_low_byte_first) + tmp=sint2korr(ptr); + else #endif - shortget(tmp,ptr); - return (longlong) tmp; - } + shortget(tmp,ptr); + return (longlong) tmp; + } case 3: return (longlong) uint3korr(ptr); case 4: - { - uint32 tmp; + { + uint32 tmp; #ifdef WORDS_BIGENDIAN - if (table->s->db_low_byte_first) - tmp=uint4korr(ptr); - else + if (table->s->db_low_byte_first) + tmp=uint4korr(ptr); + else #endif - longget(tmp,ptr); - return (longlong) tmp; - } + longget(tmp,ptr); + return (longlong) tmp; + } case 8: - { - longlong tmp; + { + longlong tmp; #ifdef WORDS_BIGENDIAN - if (table->s->db_low_byte_first) - tmp=sint8korr(ptr); - else + if (table->s->db_low_byte_first) + tmp=sint8korr(ptr); + else #endif - longlongget(tmp,ptr); - return tmp; - } + longlongget(tmp,ptr); + return tmp; + } } return 0; // impossible } +/** + Save the field metadata for enum fields. + + Saves the real type in the first byte and the pack length in the + second byte of the field metadata array at index of *metadata_ptr and + *(metadata_ptr + 1). + + @param metadata_ptr First byte of field metadata + + @returns number of bytes written to metadata_ptr +*/ +int Field_enum::do_save_field_metadata(uchar *metadata_ptr) +{ + *metadata_ptr= real_type(); + *(metadata_ptr + 1)= pack_length(); + return 2; +} + + String *Field_enum::val_str(String *val_buffer __attribute__((unused)), String *val_ptr) { @@ -7781,18 +8598,18 @@ String *Field_enum::val_str(String *val_buffer __attribute__((unused)), return val_ptr; } -int Field_enum::cmp(const char *a_ptr, const char *b_ptr) +int Field_enum::cmp(const uchar *a_ptr, const uchar *b_ptr) { - char *old=ptr; - ptr=(char*) a_ptr; + uchar *old= ptr; + ptr= (uchar*) a_ptr; ulonglong a=Field_enum::val_int(); - ptr=(char*) b_ptr; + ptr= (uchar*) b_ptr; ulonglong b=Field_enum::val_int(); - ptr=old; + ptr= old; return (a < b) ? -1 : (a > b) ? 1 : 0; } -void Field_enum::sort_string(char *to,uint length __attribute__((unused))) +void Field_enum::sort_string(uchar *to,uint length __attribute__((unused))) { ulonglong value=Field_enum::val_int(); to+=packlength-1; @@ -7850,6 +8667,7 @@ Field *Field_enum::new_field(MEM_ROOT *root, struct st_table *new_table, int Field_set::store(const char *from,uint length,CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; bool got_warning= 0; int err= 0; char *not_used; @@ -7889,6 +8707,7 @@ int Field_set::store(const char *from,uint length,CHARSET_INFO *cs) int Field_set::store(longlong nr, bool unsigned_val) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int error= 0; ulonglong max_nr= set_bits(ulonglong, typelib->count); if ((ulonglong) nr > max_nr) @@ -7951,7 +8770,12 @@ void Field_set::sql_type(String &res) const res.append(')'); } -/* returns 1 if the fields are equally defined */ +/** + @retval + 1 if the fields are equally defined + @retval + 0 if the fields are unequally defined +*/ bool Field::eq_def(Field *field) { @@ -7961,24 +8785,47 @@ bool Field::eq_def(Field *field) return 1; } + +/** + @return + returns 1 if the fields are equally defined +*/ + bool Field_enum::eq_def(Field *field) { if (!Field::eq_def(field)) return 0; - TYPELIB *from_lib=((Field_enum*) field)->typelib; + return compare_enum_values(((Field_enum*) field)->typelib); +} - if (typelib->count < from_lib->count) - return 0; - for (uint i=0 ; i < from_lib->count ; i++) + +bool Field_enum::compare_enum_values(TYPELIB *values) +{ + if (typelib->count != values->count) + return FALSE; + for (uint i= 0; i < typelib->count; i++) if (my_strnncoll(field_charset, - (const uchar*)typelib->type_names[i], - (uint) strlen(typelib->type_names[i]), - (const uchar*)from_lib->type_names[i], - (uint) strlen(from_lib->type_names[i]))) - return 0; - return 1; + (const uchar*) typelib->type_names[i], + typelib->type_lengths[i], + (const uchar*) values->type_names[i], + values->type_lengths[i])) + return FALSE; + return TRUE; +} + + +uint Field_enum::is_equal(Create_field *new_field) +{ + if (!Field_str::is_equal(new_field)) + return 0; + return compare_enum_values(new_field->interval); } + +/** + @return + returns 1 if the fields are equally defined +*/ bool Field_num::eq_def(Field *field) { if (!Field::eq_def(field)) @@ -7993,6 +8840,17 @@ bool Field_num::eq_def(Field *field) } +uint Field_num::is_equal(Create_field *new_field) +{ + return ((new_field->sql_type == real_type()) && + ((new_field->flags & UNSIGNED_FLAG) == (uint) (flags & + UNSIGNED_FLAG)) && + ((new_field->flags & AUTO_INCREMENT_FLAG) == + (uint) (flags & AUTO_INCREMENT_FLAG)) && + (new_field->length <= max_display_length())); +} + + /* Bit field. @@ -8022,12 +8880,11 @@ bool Field_num::eq_def(Field *field) 11 one byte for 'd' */ -Field_bit::Field_bit(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, +Field_bit::Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg, - enum utype unireg_check_arg, const char *field_name_arg, - struct st_table *table_arg) + enum utype unireg_check_arg, const char *field_name_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), bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7), bytes_in_rec(len_arg / 8) { @@ -8041,9 +8898,53 @@ Field_bit::Field_bit(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, } +void Field_bit::hash(ulong *nr, ulong *nr2) +{ + if (is_null()) + { + *nr^= (*nr << 1) | 1; + } + else + { + CHARSET_INFO *cs= &my_charset_bin; + longlong value= Field_bit::val_int(); + uchar tmp[8]; + mi_int8store(tmp,value); + cs->coll->hash_sort(cs, tmp, 8, nr, nr2); + } +} + + +size_t +Field_bit::do_last_null_byte() const +{ + /* + Code elsewhere is assuming that bytes are 8 bits, so I'm using + that value instead of the correct one: CHAR_BIT. + + REFACTOR SUGGESTION (Matz): Change to use the correct number of + bits. On systems with CHAR_BIT > 8 (not very common), the storage + will lose the extra bits. + */ + DBUG_PRINT("test", ("bit_ofs: %d, bit_len: %d bit_ptr: 0x%lx", + bit_ofs, bit_len, (long) bit_ptr)); + uchar *result; + if (bit_len == 0) + result= null_ptr; + else if (bit_ofs + bit_len > 8) + result= bit_ptr + 1; + else + result= bit_ptr; + + if (result) + return (size_t) (result - table->record[0]) + 1; + return LAST_NULL_BYTE_UNDEF; +} + + Field *Field_bit::new_key_field(MEM_ROOT *root, struct st_table *new_table, - char *new_ptr, uchar *new_null_ptr, + uchar *new_ptr, uchar *new_null_ptr, uint new_null_bit) { Field_bit *res; @@ -8052,7 +8953,7 @@ Field *Field_bit::new_key_field(MEM_ROOT *root, new_null_bit))) { /* Move bits normally stored in null_pointer to new_ptr */ - res->bit_ptr= (uchar*) new_ptr; + res->bit_ptr= new_ptr; res->bit_ofs= 0; if (bit_len) res->ptr++; // Store rest of data here @@ -8061,8 +8962,16 @@ Field *Field_bit::new_key_field(MEM_ROOT *root, } +uint Field_bit::is_equal(Create_field *new_field) +{ + return (new_field->sql_type == real_type() && + new_field->length == max_display_length()); +} + + int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int delta; for (; length && !*from; from++, length--); // skip left 0's @@ -8109,7 +9018,7 @@ int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs) int Field_bit::store(double nr) { - return store((longlong) nr, FALSE); + return Field_bit::store((longlong) nr, FALSE); } @@ -8138,6 +9047,7 @@ double Field_bit::val_real(void) longlong Field_bit::val_int(void) { + ASSERT_COLUMN_MARKED_FOR_READ; ulonglong bits= 0; if (bit_len) { @@ -8147,7 +9057,7 @@ longlong Field_bit::val_int(void) switch (bytes_in_rec) { case 0: return bits; - case 1: return bits | (ulonglong) (uchar) ptr[0]; + case 1: return bits | (ulonglong) ptr[0]; case 2: return bits | mi_uint2korr(ptr); case 3: return bits | mi_uint3korr(ptr); case 4: return bits | mi_uint4korr(ptr); @@ -8162,6 +9072,7 @@ longlong Field_bit::val_int(void) String *Field_bit::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { + ASSERT_COLUMN_MARKED_FOR_READ; char buff[sizeof(longlong)]; uint length= min(pack_length(), sizeof(longlong)); ulonglong bits= val_int(); @@ -8177,18 +9088,48 @@ String *Field_bit::val_str(String *val_buffer, my_decimal *Field_bit::val_decimal(my_decimal *deciaml_value) { + ASSERT_COLUMN_MARKED_FOR_READ; int2my_decimal(E_DEC_FATAL_ERROR, val_int(), 1, deciaml_value); return deciaml_value; } -int Field_bit::key_cmp(const byte *str, uint length) +/* + Compare two bit fields using pointers within the record. + SYNOPSIS + cmp_max() + a Pointer to field->ptr in first record + b Pointer to field->ptr in second record + max_len Maximum length used in index + DESCRIPTION + This method is used from key_rec_cmp used by merge sorts used + by partitioned index read and later other similar places. + The a and b pointer must be pointers to the field in a record + (not the table->record[0] necessarily) +*/ +int Field_bit::cmp_max(const uchar *a, const uchar *b, uint max_len) +{ + my_ptrdiff_t a_diff= a - ptr; + my_ptrdiff_t b_diff= b - ptr; + if (bit_len) + { + int flag; + uchar bits_a= get_rec_bits(bit_ptr+a_diff, bit_ofs, bit_len); + uchar bits_b= get_rec_bits(bit_ptr+b_diff, bit_ofs, bit_len); + if ((flag= (int) (bits_a - bits_b))) + return flag; + } + return memcmp(a, b, field_length); +} + + +int Field_bit::key_cmp(const uchar *str, uint length) { if (bit_len) { int flag; uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len); - if ((flag= (int) (bits - *(uchar*) str))) + if ((flag= (int) (bits - *str))) return flag; str++; length--; @@ -8211,7 +9152,7 @@ int Field_bit::cmp_offset(uint row_offset) } -uint Field_bit::get_key_image(char *buff, uint length, imagetype type_arg) +uint Field_bit::get_key_image(uchar *buff, uint length, imagetype type_arg) { if (bit_len) { @@ -8225,6 +9166,78 @@ uint Field_bit::get_key_image(char *buff, uint length, imagetype type_arg) } +/** + Save the field metadata for bit fields. + + Saves the bit length in the first byte and bytes in record in the + second byte of the field metadata array at index of *metadata_ptr and + *(metadata_ptr + 1). + + @param metadata_ptr First byte of field metadata + + @returns number of bytes written to metadata_ptr +*/ +int Field_bit::do_save_field_metadata(uchar *metadata_ptr) +{ + *metadata_ptr= bit_len; + *(metadata_ptr + 1)= bytes_in_rec; + return 2; +} + + +/** + Returns the number of bytes field uses in row-based replication + row packed size. + + This method is used in row-based replication to determine the number + of bytes that the field consumes in the row record format. This is + used to skip fields in the master that do not exist on the slave. + + @param field_metadata Encoded size in field metadata + + @returns The size of the field based on the field metadata. +*/ +uint Field_bit::pack_length_from_metadata(uint field_metadata) +{ + uint const from_len= (field_metadata >> 8U) & 0x00ff; + uint const from_bit_len= field_metadata & 0x00ff; + uint const source_size= from_len + ((from_bit_len > 0) ? 1 : 0); + return (source_size); +} + + +/** + Check to see if field size is compatible with destination. + + This method is used in row-based replication to verify that the slave's + field size is less than or equal to the master's field size. The + encoded field metadata (from the master or source) is decoded and compared + to the size of this field (the slave or destination). + + @param field_metadata Encoded size in field metadata + + @retval 0 if this field's size is < the source field's size + @retval 1 if this field's size is >= the source field's size +*/ +int Field_bit::compatible_field_size(uint field_metadata, + const Relay_log_info * __attribute__((unused))) +{ + int compatible= 0; + uint const source_size= pack_length_from_metadata(field_metadata); + uint const destination_size= row_pack_length(); + uint const from_bit_len= field_metadata & 0x00ff; + uint const from_len= (field_metadata >> 8U) & 0x00ff; + if ((bit_len == 0) || (from_bit_len == 0)) + compatible= (source_size <= destination_size); + else if (from_bit_len > bit_len) + compatible= (from_len < bytes_in_rec); + else + compatible= ((from_bit_len <= bit_len) && (from_len <= bytes_in_rec)); + return (compatible); +} + + + void Field_bit::sql_type(String &res) const { CHARSET_INFO *cs= res.charset(); @@ -8234,13 +9247,34 @@ void Field_bit::sql_type(String &res) const } -char *Field_bit::pack(char *to, const char *from, uint max_length) +uchar * +Field_bit::pack(uchar *to, const uchar *from, uint max_length, + bool low_byte_first __attribute__((unused))) { - DBUG_ASSERT(max_length); + DBUG_ASSERT(max_length > 0); uint length; - if (bit_len) + if (bit_len > 0) { - uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len); + /* + We have the following: + + ptr Points into a field in record R1 + from Points to a field in a record R2 + bit_ptr Points to the byte (in the null bytes) that holds the + odd bits of R1 + from_bitp Points to the byte that holds the odd bits of R2 + + We have the following: + + ptr - bit_ptr = from - from_bitp + + We want to isolate 'from_bitp', so this gives: + + ptr - bit_ptr - from = - from_bitp + - ptr + bit_ptr + from = from_bitp + bit_ptr + from - ptr = from_bitp + */ + uchar bits= get_rec_bits(bit_ptr + (from - ptr), bit_ofs, bit_len); *to++= bits; } length= min(bytes_in_rec, max_length - (bit_len > 0)); @@ -8249,29 +9283,95 @@ char *Field_bit::pack(char *to, const char *from, uint max_length) } -const char *Field_bit::unpack(char *to, const char *from) +/** + Unpack a bit field from row data. + + This method is used to unpack a bit field from a master whose size + of the field is less than that of the slave. + + @param to Destination of the data + @param from Source of the data + @param param_data Bit length (upper) and length (lower) values + + @return New pointer into memory based on from + length of the data +*/ +const uchar * +Field_bit::unpack(uchar *to, const uchar *from, uint param_data, + bool low_byte_first __attribute__((unused))) { - if (bit_len) + uint const from_len= (param_data >> 8U) & 0x00ff; + uint const from_bit_len= param_data & 0x00ff; + /* + If the parameter data is zero (i.e., undefined), or if the master + and slave have the same sizes, then use the old unpack() method. + */ + if (param_data == 0 || + (from_bit_len == bit_len) && (from_len == bytes_in_rec)) { - set_rec_bits(*from, bit_ptr, bit_ofs, bit_len); - from++; + if (bit_len > 0) + { + /* + set_rec_bits is a macro, don't put the post-increment in the + argument since that might cause strange side-effects. + + For the choice of the second argument, see the explanation for + Field_bit::pack(). + */ + set_rec_bits(*from, bit_ptr + (to - ptr), bit_ofs, bit_len); + from++; + } + memcpy(to, from, bytes_in_rec); + return from + bytes_in_rec; } - memcpy(to, from, bytes_in_rec); - return from + bytes_in_rec; + + /* + We are converting a smaller bit field to a larger one here. + To do that, we first need to construct a raw value for the original + bit value stored in the from buffer. Then that needs to be converted + to the larger field then sent to store() for writing to the field. + Lastly the odd bits need to be masked out if the bytes_in_rec > 0. + Otherwise stray bits can cause spurious values. + */ + uint new_len= (field_length + 7) / 8; + char *value= (char *)my_alloca(new_len); + bzero(value, new_len); + uint len= from_len + ((from_bit_len > 0) ? 1 : 0); + memcpy(value + (new_len - len), from, len); + /* + Mask out the unused bits in the partial byte. + TODO: Add code to the master to always mask these bits and remove + the following. + */ + if ((from_bit_len > 0) && (from_len > 0)) + value[new_len - len]= value[new_len - len] & ((1U << from_bit_len) - 1); + bitmap_set_bit(table->write_set,field_index); + store(value, new_len, system_charset_info); + my_afree(value); + return from + len; } +void Field_bit::set_default() +{ + if (bit_len > 0) + { + my_ptrdiff_t const offset= table->s->default_values - table->record[0]; + uchar bits= get_rec_bits(bit_ptr + offset, bit_ofs, bit_len); + set_rec_bits(bits, bit_ptr, bit_ofs, bit_len); + } + Field::set_default(); +} + /* Bit field support for non-MyISAM tables. */ -Field_bit_as_char::Field_bit_as_char(char *ptr_arg, uint32 len_arg, +Field_bit_as_char::Field_bit_as_char(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg, uchar null_bit_arg, enum utype unireg_check_arg, - const char *field_name_arg, - struct st_table *table_arg) - : Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, 0, - 0, unireg_check_arg, field_name_arg, table_arg) + const char *field_name_arg) + :Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, 0, 0, + unireg_check_arg, field_name_arg) { flags|= UNSIGNED_FLAG; bit_len= 0; @@ -8281,6 +9381,7 @@ Field_bit_as_char::Field_bit_as_char(char *ptr_arg, uint32 len_arg, int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs) { + ASSERT_COLUMN_MARKED_FOR_WRITE; int delta; uchar bits= (uchar) (field_length & 7); @@ -8292,7 +9393,7 @@ int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs) { memset(ptr, 0xff, bytes_in_rec); if (bits) - *ptr&= ((1 << bits) - 1); /* set first byte */ + *ptr&= ((1 << bits) - 1); /* set first uchar */ if (table->in_use->really_abort_on_warning()) set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1); else @@ -8315,20 +9416,14 @@ void Field_bit_as_char::sql_type(String &res) const /***************************************************************************** - Handling of field and create_field + Handling of field and Create_field *****************************************************************************/ -/* - Convert create_field::length from number of characters to number of bytes - - SYNOPSIS - create_field::create_length_to_internal_length() - - DESCRIPTION - Convert create_field::length from number of characters to number of bytes. +/** + Convert create_field::length from number of characters to number of bytes. */ -void create_field::create_length_to_internal_length(void) +void Create_field::create_length_to_internal_length(void) { switch (sql_type) { case MYSQL_TYPE_TINY_BLOB: @@ -8375,7 +9470,10 @@ void create_field::create_length_to_internal_length(void) } -void create_field::init_for_tmp_table(enum_field_types sql_type_arg, +/** + Init for a tmp table field. To be extended if need be. +*/ +void Create_field::init_for_tmp_table(enum_field_types sql_type_arg, uint32 length_arg, uint32 decimals_arg, bool maybe_null, bool is_unsigned) { @@ -8393,30 +9491,30 @@ void create_field::init_for_tmp_table(enum_field_types sql_type_arg, } -/* - Initialize field definition for create +/** + Initialize field definition for create. - SYNOPSIS - thd Thread handle - fld_name Field name - fld_type Field type - fld_length Field length - fld_decimals Decimal (if any) - fld_type_modifier Additional type information - fld_default_value Field default value (if any) - fld_on_update_value The value of ON UPDATE clause - fld_comment Field comment - fld_change Field change - fld_interval_list Interval list (if any) - fld_charset Field charset - fld_geom_type Field geometry type (if any) + @param thd Thread handle + @param fld_name Field name + @param fld_type Field type + @param fld_length Field length + @param fld_decimals Decimal (if any) + @param fld_type_modifier Additional type information + @param fld_default_value Field default value (if any) + @param fld_on_update_value The value of ON UPDATE clause + @param fld_comment Field comment + @param fld_change Field change + @param fld_interval_list Interval list (if any) + @param fld_charset Field charset + @param fld_geom_type Field geometry type (if any) - RETURN + @retval FALSE on success + @retval TRUE on error */ -bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, +bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, char *fld_length, char *fld_decimals, uint fld_type_modifier, Item *fld_default_value, Item *fld_on_update_value, LEX_STRING *fld_comment, @@ -8426,7 +9524,7 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, uint sign_len, allowed_type_modifier= 0; ulong max_field_charlength= MAX_FIELD_CHARLENGTH; - DBUG_ENTER("create_field::init()"); + DBUG_ENTER("Create_field::init()"); field= 0; field_name= fld_name; @@ -8457,7 +9555,7 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, it is NOT NULL, not an AUTO_INCREMENT field and not a TIMESTAMP. */ if (!fld_default_value && !(fld_type_modifier & AUTO_INCREMENT_FLAG) && - (fld_type_modifier & NOT_NULL_FLAG) && fld_type != FIELD_TYPE_TIMESTAMP) + (fld_type_modifier & NOT_NULL_FLAG) && fld_type != MYSQL_TYPE_TIMESTAMP) flags|= NO_DEFAULT_VALUE_FLAG; if (fld_length != NULL) @@ -8477,34 +9575,34 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1; switch (fld_type) { - case FIELD_TYPE_TINY: + case MYSQL_TYPE_TINY: if (!fld_length) length= MAX_TINYINT_WIDTH+sign_len; allowed_type_modifier= AUTO_INCREMENT_FLAG; break; - case FIELD_TYPE_SHORT: + case MYSQL_TYPE_SHORT: if (!fld_length) length= MAX_SMALLINT_WIDTH+sign_len; allowed_type_modifier= AUTO_INCREMENT_FLAG; break; - case FIELD_TYPE_INT24: + case MYSQL_TYPE_INT24: if (!fld_length) length= MAX_MEDIUMINT_WIDTH+sign_len; allowed_type_modifier= AUTO_INCREMENT_FLAG; break; - case FIELD_TYPE_LONG: + case MYSQL_TYPE_LONG: if (!fld_length) length= MAX_INT_WIDTH+sign_len; allowed_type_modifier= AUTO_INCREMENT_FLAG; break; - case FIELD_TYPE_LONGLONG: + case MYSQL_TYPE_LONGLONG: if (!fld_length) length= MAX_BIGINT_WIDTH; allowed_type_modifier= AUTO_INCREMENT_FLAG; break; - case FIELD_TYPE_NULL: + case MYSQL_TYPE_NULL: break; - case FIELD_TYPE_NEWDECIMAL: + case MYSQL_TYPE_NEWDECIMAL: my_decimal_trim(&length, &decimals); if (length > DECIMAL_MAX_PRECISION) { @@ -8532,11 +9630,11 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, break; case MYSQL_TYPE_STRING: break; - case FIELD_TYPE_BLOB: - case FIELD_TYPE_TINY_BLOB: - case FIELD_TYPE_LONG_BLOB: - case FIELD_TYPE_MEDIUM_BLOB: - case FIELD_TYPE_GEOMETRY: + case MYSQL_TYPE_BLOB: + case MYSQL_TYPE_TINY_BLOB: + case MYSQL_TYPE_LONG_BLOB: + case MYSQL_TYPE_MEDIUM_BLOB: + case MYSQL_TYPE_GEOMETRY: if (fld_default_value) { /* Allow empty as default value. */ @@ -8568,12 +9666,12 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, } flags|= BLOB_FLAG; break; - case FIELD_TYPE_YEAR: + case MYSQL_TYPE_YEAR: if (!fld_length || length != 2) length= 4; /* Default length */ flags|= ZEROFILL_FLAG | UNSIGNED_FLAG; break; - case FIELD_TYPE_FLOAT: + case MYSQL_TYPE_FLOAT: /* change FLOAT(precision) to FLOAT or DOUBLE */ allowed_type_modifier= AUTO_INCREMENT_FLAG; if (fld_length && !fld_decimals) @@ -8586,7 +9684,7 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, } else if (tmp_length > PRECISION_FOR_FLOAT) { - sql_type= FIELD_TYPE_DOUBLE; + sql_type= MYSQL_TYPE_DOUBLE; length= DBL_DIG+7; /* -[digits].E+### */ } else @@ -8606,7 +9704,7 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, DBUG_RETURN(TRUE); } break; - case FIELD_TYPE_DOUBLE: + case MYSQL_TYPE_DOUBLE: allowed_type_modifier= AUTO_INCREMENT_FLAG; if (!fld_length && !fld_decimals) { @@ -8620,7 +9718,7 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, DBUG_RETURN(TRUE); } break; - case FIELD_TYPE_TIMESTAMP: + case MYSQL_TYPE_TIMESTAMP: if (fld_length == NULL) { /* Compressed date YYYYMMDDHHMMSS */ @@ -8683,21 +9781,21 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, Field::NONE)); } break; - case FIELD_TYPE_DATE: + case MYSQL_TYPE_DATE: /* Old date type. */ if (protocol_version != PROTOCOL_VERSION-1) - sql_type= FIELD_TYPE_NEWDATE; + sql_type= MYSQL_TYPE_NEWDATE; /* fall trough */ - case FIELD_TYPE_NEWDATE: + case MYSQL_TYPE_NEWDATE: length= 10; break; - case FIELD_TYPE_TIME: + case MYSQL_TYPE_TIME: length= 10; break; - case FIELD_TYPE_DATETIME: + case MYSQL_TYPE_DATETIME: length= MAX_DATETIME_WIDTH; break; - case FIELD_TYPE_SET: + case MYSQL_TYPE_SET: { pack_length= get_set_pack_length(fld_interval_list->elements); @@ -8713,7 +9811,7 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, length= 1; break; } - case FIELD_TYPE_ENUM: + case MYSQL_TYPE_ENUM: { /* Should be safe. */ pack_length= get_enum_pack_length(fld_interval_list->elements); @@ -8722,7 +9820,7 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, String *tmp; while ((tmp= it++)) interval_list.push_back(tmp); - length= 1; /* See comment for FIELD_TYPE_SET above. */ + length= 1; /* See comment for MYSQL_TYPE_SET above. */ break; } case MYSQL_TYPE_VAR_STRING: @@ -8741,19 +9839,19 @@ bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type, pack_length= (length + 7) / 8; break; } - case FIELD_TYPE_DECIMAL: + case MYSQL_TYPE_DECIMAL: DBUG_ASSERT(0); /* Was obsolete */ } /* Remember the value of length */ char_length= length; if (!(flags & BLOB_FLAG) && - ((length > max_field_charlength && fld_type != FIELD_TYPE_SET && - fld_type != FIELD_TYPE_ENUM && + ((length > max_field_charlength && fld_type != MYSQL_TYPE_SET && + fld_type != MYSQL_TYPE_ENUM && (fld_type != MYSQL_TYPE_VARCHAR || fld_default_value)) || ((length == 0) && fld_type != MYSQL_TYPE_STRING && - fld_type != MYSQL_TYPE_VARCHAR && fld_type != FIELD_TYPE_GEOMETRY))) + fld_type != MYSQL_TYPE_VARCHAR && fld_type != MYSQL_TYPE_GEOMETRY))) { my_error((fld_type == MYSQL_TYPE_VAR_STRING || fld_type == MYSQL_TYPE_VARCHAR || @@ -8778,13 +9876,13 @@ enum_field_types get_blob_type_from_length(ulong length) { enum_field_types type; if (length < 256) - type= FIELD_TYPE_TINY_BLOB; + type= MYSQL_TYPE_TINY_BLOB; else if (length < 65536) - type= FIELD_TYPE_BLOB; + type= MYSQL_TYPE_BLOB; else if (length < 256L*256L*256L) - type= FIELD_TYPE_MEDIUM_BLOB; + type= MYSQL_TYPE_MEDIUM_BLOB; else - type= FIELD_TYPE_LONG_BLOB; + type= MYSQL_TYPE_LONG_BLOB; return type; } @@ -8798,32 +9896,32 @@ uint32 calc_pack_length(enum_field_types type,uint32 length) switch (type) { case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_STRING: - case FIELD_TYPE_DECIMAL: return (length); + case MYSQL_TYPE_DECIMAL: return (length); case MYSQL_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2)); - case FIELD_TYPE_YEAR: - case FIELD_TYPE_TINY : return 1; - case FIELD_TYPE_SHORT : return 2; - case FIELD_TYPE_INT24: - case FIELD_TYPE_NEWDATE: - case FIELD_TYPE_TIME: return 3; - case FIELD_TYPE_TIMESTAMP: - case FIELD_TYPE_DATE: - case FIELD_TYPE_LONG : return 4; - case FIELD_TYPE_FLOAT : return sizeof(float); - case FIELD_TYPE_DOUBLE: return sizeof(double); - case FIELD_TYPE_DATETIME: - case FIELD_TYPE_LONGLONG: return 8; /* Don't crash if no longlong */ - case FIELD_TYPE_NULL : return 0; - case FIELD_TYPE_TINY_BLOB: return 1+portable_sizeof_char_ptr; - case FIELD_TYPE_BLOB: return 2+portable_sizeof_char_ptr; - case FIELD_TYPE_MEDIUM_BLOB: return 3+portable_sizeof_char_ptr; - case FIELD_TYPE_LONG_BLOB: return 4+portable_sizeof_char_ptr; - case FIELD_TYPE_GEOMETRY: return 4+portable_sizeof_char_ptr; - case FIELD_TYPE_SET: - case FIELD_TYPE_ENUM: - case FIELD_TYPE_NEWDECIMAL: + case MYSQL_TYPE_YEAR: + case MYSQL_TYPE_TINY : return 1; + case MYSQL_TYPE_SHORT : return 2; + case MYSQL_TYPE_INT24: + case MYSQL_TYPE_NEWDATE: + case MYSQL_TYPE_TIME: return 3; + case MYSQL_TYPE_TIMESTAMP: + case MYSQL_TYPE_DATE: + case MYSQL_TYPE_LONG : return 4; + case MYSQL_TYPE_FLOAT : return sizeof(float); + case MYSQL_TYPE_DOUBLE: return sizeof(double); + case MYSQL_TYPE_DATETIME: + case MYSQL_TYPE_LONGLONG: return 8; /* Don't crash if no longlong */ + case MYSQL_TYPE_NULL : return 0; + case MYSQL_TYPE_TINY_BLOB: return 1+portable_sizeof_char_ptr; + case MYSQL_TYPE_BLOB: return 2+portable_sizeof_char_ptr; + case MYSQL_TYPE_MEDIUM_BLOB: return 3+portable_sizeof_char_ptr; + case MYSQL_TYPE_LONG_BLOB: return 4+portable_sizeof_char_ptr; + case MYSQL_TYPE_GEOMETRY: return 4+portable_sizeof_char_ptr; + case MYSQL_TYPE_SET: + case MYSQL_TYPE_ENUM: + case MYSQL_TYPE_NEWDECIMAL: abort(); return 0; // This shouldn't happen - case FIELD_TYPE_BIT: return length / 8; + case MYSQL_TYPE_BIT: return length / 8; default: return 0; } @@ -8833,17 +9931,17 @@ uint32 calc_pack_length(enum_field_types type,uint32 length) uint pack_length_to_packflag(uint type) { switch (type) { - case 1: return f_settype((uint) FIELD_TYPE_TINY); - case 2: return f_settype((uint) FIELD_TYPE_SHORT); - case 3: return f_settype((uint) FIELD_TYPE_INT24); - case 4: return f_settype((uint) FIELD_TYPE_LONG); - case 8: return f_settype((uint) FIELD_TYPE_LONGLONG); + case 1: return f_settype((uint) MYSQL_TYPE_TINY); + case 2: return f_settype((uint) MYSQL_TYPE_SHORT); + case 3: return f_settype((uint) MYSQL_TYPE_INT24); + case 4: return f_settype((uint) MYSQL_TYPE_LONG); + case 8: return f_settype((uint) MYSQL_TYPE_LONGLONG); } return 0; // This shouldn't happen } -Field *make_field(char *ptr, uint32 field_length, +Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length, uchar *null_pos, uchar null_bit, uint pack_flag, enum_field_types field_type, @@ -8851,14 +9949,13 @@ Field *make_field(char *ptr, uint32 field_length, Field::geometry_type geom_type, Field::utype unireg_check, TYPELIB *interval, - const char *field_name, - struct st_table *table) + const char *field_name) { uchar *bit_ptr; uchar bit_offset; LINT_INIT(bit_ptr); LINT_INIT(bit_offset); - if (field_type == FIELD_TYPE_BIT && !f_bit_as_char(pack_flag)) + if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag)) { bit_ptr= null_pos; bit_offset= null_bit; @@ -8879,15 +9976,14 @@ Field *make_field(char *ptr, uint32 field_length, null_bit= ((uchar) 1) << null_bit; } - switch (field_type) - { - case FIELD_TYPE_DATE: - case FIELD_TYPE_NEWDATE: - case FIELD_TYPE_TIME: - case FIELD_TYPE_DATETIME: - case FIELD_TYPE_TIMESTAMP: - field_charset= &my_charset_bin; - default: break; + switch (field_type) { + case MYSQL_TYPE_DATE: + case MYSQL_TYPE_NEWDATE: + case MYSQL_TYPE_TIME: + case MYSQL_TYPE_DATETIME: + case MYSQL_TYPE_TIMESTAMP: + field_charset= &my_charset_bin; + default: break; } if (f_is_alpha(pack_flag)) @@ -8895,16 +9991,17 @@ Field *make_field(char *ptr, uint32 field_length, if (!f_is_packed(pack_flag)) { if (field_type == MYSQL_TYPE_STRING || - field_type == FIELD_TYPE_DECIMAL || // 3.23 or 4.0 string + field_type == MYSQL_TYPE_DECIMAL || // 3.23 or 4.0 string field_type == MYSQL_TYPE_VAR_STRING) return new Field_string(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, field_charset); if (field_type == MYSQL_TYPE_VARCHAR) return new Field_varstring(ptr,field_length, HA_VARCHAR_PACKLENGTH(field_length), null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, + share, field_charset); return 0; // Error } @@ -8916,103 +10013,105 @@ Field *make_field(char *ptr, uint32 field_length, #ifdef HAVE_SPATIAL if (f_is_geom(pack_flag)) return new Field_geom(ptr,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, share, pack_length, geom_type); #endif if (f_is_blob(pack_flag)) return new Field_blob(ptr,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, share, pack_length, field_charset); if (interval) { if (f_is_enum(pack_flag)) return new Field_enum(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, pack_length, interval, field_charset); else return new Field_set(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, pack_length, interval, field_charset); } } switch (field_type) { - case FIELD_TYPE_DECIMAL: + case MYSQL_TYPE_DECIMAL: return new Field_decimal(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_decimals(pack_flag), f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag) == 0); - case FIELD_TYPE_NEWDECIMAL: + case MYSQL_TYPE_NEWDECIMAL: return new Field_new_decimal(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_decimals(pack_flag), f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag) == 0); - case FIELD_TYPE_FLOAT: + case MYSQL_TYPE_FLOAT: return new Field_float(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_decimals(pack_flag), f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag)== 0); - case FIELD_TYPE_DOUBLE: + case MYSQL_TYPE_DOUBLE: return new Field_double(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_decimals(pack_flag), f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag)== 0); - case FIELD_TYPE_TINY: + case MYSQL_TYPE_TINY: return new Field_tiny(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag) == 0); - case FIELD_TYPE_SHORT: + case MYSQL_TYPE_SHORT: return new Field_short(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag) == 0); - case FIELD_TYPE_INT24: + case MYSQL_TYPE_INT24: return new Field_medium(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag) == 0); - case FIELD_TYPE_LONG: + case MYSQL_TYPE_LONG: return new Field_long(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag) == 0); - case FIELD_TYPE_LONGLONG: + case MYSQL_TYPE_LONGLONG: return new Field_longlong(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table, + unireg_check, field_name, f_is_zerofill(pack_flag) != 0, f_is_dec(pack_flag) == 0); - case FIELD_TYPE_TIMESTAMP: + case MYSQL_TYPE_TIMESTAMP: return new Field_timestamp(ptr,field_length, null_pos, null_bit, - unireg_check, field_name, table, + unireg_check, field_name, share, field_charset); - case FIELD_TYPE_YEAR: + case MYSQL_TYPE_YEAR: return new Field_year(ptr,field_length,null_pos,null_bit, - unireg_check, field_name, table); - case FIELD_TYPE_DATE: + unireg_check, field_name); + case MYSQL_TYPE_DATE: return new Field_date(ptr,null_pos,null_bit, - unireg_check, field_name, table, field_charset); - case FIELD_TYPE_NEWDATE: + unireg_check, field_name, field_charset); + case MYSQL_TYPE_NEWDATE: return new Field_newdate(ptr,null_pos,null_bit, - unireg_check, field_name, table, field_charset); - case FIELD_TYPE_TIME: + unireg_check, field_name, field_charset); + case MYSQL_TYPE_TIME: return new Field_time(ptr,null_pos,null_bit, - unireg_check, field_name, table, field_charset); - case FIELD_TYPE_DATETIME: + unireg_check, field_name, field_charset); + case MYSQL_TYPE_DATETIME: return new Field_datetime(ptr,null_pos,null_bit, - unireg_check, field_name, table, field_charset); - case FIELD_TYPE_NULL: - return new Field_null(ptr,field_length,unireg_check,field_name,table, field_charset); - case FIELD_TYPE_BIT: + unireg_check, field_name, field_charset); + case MYSQL_TYPE_NULL: + return new Field_null(ptr, field_length, unireg_check, field_name, + field_charset); + case MYSQL_TYPE_BIT: return f_bit_as_char(pack_flag) ? new Field_bit_as_char(ptr, field_length, null_pos, null_bit, - unireg_check, field_name, table) : + unireg_check, field_name) : new Field_bit(ptr, field_length, null_pos, null_bit, bit_ptr, - bit_offset, unireg_check, field_name, table); + bit_offset, unireg_check, field_name); + default: // Impossible (Wrong version) break; } @@ -9020,9 +10119,9 @@ Field *make_field(char *ptr, uint32 field_length, } -/* Create a field suitable for create of table */ +/** Create a field suitable for create of table. */ -create_field::create_field(Field *old_field,Field *orig_field) +Create_field::Create_field(Field *old_field,Field *orig_field) { field= old_field; field_name=change=old_field->field_name; @@ -9042,12 +10141,12 @@ create_field::create_field(Field *old_field,Field *orig_field) portable_sizeof_char_ptr); switch (sql_type) { - case FIELD_TYPE_BLOB: + case MYSQL_TYPE_BLOB: switch (pack_length - portable_sizeof_char_ptr) { - case 1: sql_type= FIELD_TYPE_TINY_BLOB; break; - case 2: sql_type= FIELD_TYPE_BLOB; break; - case 3: sql_type= FIELD_TYPE_MEDIUM_BLOB; break; - default: sql_type= FIELD_TYPE_LONG_BLOB; break; + case 1: sql_type= MYSQL_TYPE_TINY_BLOB; break; + case 2: sql_type= MYSQL_TYPE_BLOB; break; + case 3: sql_type= MYSQL_TYPE_MEDIUM_BLOB; break; + default: sql_type= MYSQL_TYPE_LONG_BLOB; break; } length/= charset->mbmaxlen; key_length/= charset->mbmaxlen; @@ -9066,7 +10165,7 @@ create_field::create_field(Field *old_field,Field *orig_field) length= (length+charset->mbmaxlen-1) / charset->mbmaxlen; break; #ifdef HAVE_SPATIAL - case FIELD_TYPE_GEOMETRY: + case MYSQL_TYPE_GEOMETRY: geom_type= ((Field_geom*)old_field)->geom_type; break; #endif @@ -9083,36 +10182,35 @@ create_field::create_field(Field *old_field,Field *orig_field) if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) && old_field->ptr && orig_field && - (sql_type != FIELD_TYPE_TIMESTAMP || /* set def only if */ + (sql_type != MYSQL_TYPE_TIMESTAMP || /* set def only if */ old_field->table->timestamp_field != old_field || /* timestamp field */ unireg_check == Field::TIMESTAMP_UN_FIELD)) /* has default val */ { + char buff[MAX_FIELD_WIDTH]; + String tmp(buff,sizeof(buff), charset); my_ptrdiff_t diff; /* Get the value from default_values */ diff= (my_ptrdiff_t) (orig_field->table->s->default_values- orig_field->table->record[0]); - orig_field->move_field(diff); // Points now at default_values + orig_field->move_field_offset(diff); // Points now at default_values if (!orig_field->is_real_null()) { - char buff[MAX_FIELD_WIDTH],*pos; - String tmp(buff,sizeof(buff), charset), *res; + char buff[MAX_FIELD_WIDTH], *pos; + String tmp(buff, sizeof(buff), charset), *res; res= orig_field->val_str(&tmp); pos= (char*) sql_strmake(res->ptr(), res->length()); def= new Item_string(pos, res->length(), charset); } - orig_field->move_field(-diff); // Back to record[0] + orig_field->move_field_offset(-diff); // Back to record[0] } } -/* - maximum possible display length for blob - - SYNOPSIS - Field_blob::max_display_length() +/** + maximum possible display length for blob. - RETURN + @return length */ @@ -9139,24 +10237,23 @@ uint32 Field_blob::max_display_length() Warning handling *****************************************************************************/ -/* - Produce warning or note about data saved into field +/** + Produce warning or note about data saved into field. - SYNOPSIS - set_warning() - level - level of message (Note/Warning/Error) - code - error code of message to be produced - cuted_increment - whenever we should increase cut fields count or not + @param level - level of message (Note/Warning/Error) + @param code - error code of message to be produced + @param cuted_increment - whenever we should increase cut fields count or not - NOTE + @note This function won't produce warning and increase cut fields counter if count_cuted_fields == CHECK_FIELD_IGNORE for current thread. if count_cuted_fields == CHECK_FIELD_IGNORE then we ignore notes. This allows us to avoid notes in optimisation, like convert_constant_item(). - RETURN VALUE + @retval 1 if count_cuted_fields == CHECK_FIELD_IGNORE and error level is not NOTE + @retval 0 otherwise */ @@ -9180,21 +10277,19 @@ Field::set_warning(MYSQL_ERROR::enum_warning_level level, uint code, } -/* - Produce warning or note about datetime string data saved into field +/** + Produce warning or note about datetime string data saved into field. - SYNOPSIS - set_datime_warning() - level - level of message (Note/Warning/Error) - code - error code of message to be produced - str - string value which we tried to save - str_len - length of string which we tried to save - ts_type - type of datetime value (datetime/date/time) - cuted_increment - whenever we should increase cut fields count or not - - NOTE - This function will always produce some warning but won't increase cut - fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current + @param level level of message (Note/Warning/Error) + @param code error code of message to be produced + @param str string value which we tried to save + @param str_length length of string which we tried to save + @param ts_type type of datetime value (datetime/date/time) + @param cuted_increment whenever we should increase cut fields count or not + + @note + This function will always produce some warning but won't increase cut + fields counter if count_cuted_fields ==FIELD_CHECK_IGNORE for current thread. */ @@ -9212,20 +10307,18 @@ Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, } -/* - Produce warning or note about integer datetime value saved into field +/** + Produce warning or note about integer datetime value saved into field. - SYNOPSIS - set_warning() - level - level of message (Note/Warning/Error) - code - error code of message to be produced - nr - numeric value which we tried to save - ts_type - type of datetime value (datetime/date/time) - cuted_increment - whenever we should increase cut fields count or not - - NOTE - This function will always produce some warning but won't increase cut - fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current + @param level level of message (Note/Warning/Error) + @param code error code of message to be produced + @param nr numeric value which we tried to save + @param ts_type type of datetime value (datetime/date/time) + @param cuted_increment whenever we should increase cut fields count or not + + @note + This function will always produce some warning but won't increase cut + fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current thread. */ @@ -9246,19 +10339,17 @@ Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, } -/* - Produce warning or note about double datetime data saved into field +/** + Produce warning or note about double datetime data saved into field. - SYNOPSIS - set_warning() - level - level of message (Note/Warning/Error) - code - error code of message to be produced - nr - double value which we tried to save - ts_type - type of datetime value (datetime/date/time) - - NOTE - This function will always produce some warning but won't increase cut - fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current + @param level level of message (Note/Warning/Error) + @param code error code of message to be produced + @param nr double value which we tried to save + @param ts_type type of datetime value (datetime/date/time) + + @note + This function will always produce some warning but won't increase cut + fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current thread. */ @@ -9277,4 +10368,3 @@ Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, field_name); } } - |