3788 Dmitry Shulga 2012-05-15
This is a prerequisite patch for WL#6030.
This path implements the rename refactoring pattern.
Rename Field::real_is_nullable ==> Field::is_real_nullable.
Such renaming were implemented in order to provide uniform
naming schema for methods related to nullability check (e.g.
is_null()/is_real_null(), is_nullable()/is_real_nullable).
modified:
sql/field.h
sql/field_conv.cc
sql/item_subselect.cc
sql/opt_range.cc
sql/opt_sum.cc
sql/sql_optimizer.cc
sql/sql_partition.cc
sql/sql_select.cc
sql/sql_show.cc
sql/sql_update.cc
sql/table.cc
storage/csv/ha_tina.cc
storage/federated/ha_federated.cc
storage/heap/ha_heap.cc
storage/innobase/handler/ha_innodb.cc
storage/innobase/handler/handler0alter.cc
storage/myisam/ha_myisam.cc
3787 Dmitry Shulga 2012-05-15
This is a prerequisite patch for WL#6030.
This patch rewrites the implementation of method
Field::is_real_null in the simpler way. The patch
removed the redundant comparison and rely on the
fact that standard of C++ allow for a construction
like A(some_value) even for primitive types.
modified:
sql/field.h
3786 Dmitry Shulga 2012-05-15
Prerequisite patch for WL#6030.
This patch removes unnecessary argument named is_nullable from
constructors of Field class hierarchy. This argument was introduced
by previous changes set but currently is considered as supersfluous
since the nullability can be induced by the value of argument
null_ptr_arg that points to the memory where the value of nullability
flag is stored.
All references to Field::is_null_in_record_with_offset were replaced by
method Field::is_real_null since the former had the same functionality
and was removed as result of refactoring.
modified:
sql/field.cc
sql/field.h
sql/ha_ndbcluster.cc
sql/item.cc
sql/sql_select.h
sql/sql_tmp_table.cc
3785 Dmitry Shulga 2012-05-11
This patch is a prerequisite for WL#6030.
This patch changes the way that Field's nullability is checked for.
Instead of use null_ptr directly to check for nullability this patch
takes into account the value of Field::flags attribute and the flag
NOT_NULL_FLAG when makes decision about Field's nullability.
Nullability flag is passed explicitly to every field constructor.
It's also renamed maybe_null to is_nullable and real_maybe_null to
real_is_nullable.
@ sql/field.cc
Field's nullability now is checked using deicated value in flags attribute.
The data member null_ptr is no longer used to check for NOT NULL.
The Field constructors and the constructors of derivated from Field
classes were changed to have nullability as an explicit parameter.
Explicit nullability argument was added to the factory method
new_key_field().
new_key_field implementation is changed - make update of flags
for new created field object according to nullability condition.
At some places tabs were removed.
@ sql/field.h
Filed's nullability now is checked using dedicated value in flags attribute.
The data member null_ptr is no longer used to check for NOT NULL.
The constructors of class Field and the constructors of derivated from Field
classes were changed to have nullability as an explicit parameter.
Explicit nullability flag was added to the factory method new_key_field().
Some methods were renamed:
maybe_null ==> is_nullable,
real_maybe_null ==> real_is_nullable
The method is_null_in_record_with_with_offset was removed
since there is the method is_real_null that has the same functionality.
At some places tabs were removed.
@ sql/field_conv.cc
The data mamber is_nullable was introduced that is used for nullability check.
Since the methods Field::maybe_null(), Field::real_maybe_null() were renamed
the references to these methods were also renamed.
do_outer_field_to_null_str() were modified: checking for nullability is
performed taking into account that is_nullable attribute may be true but
from_null_ptr still may have NULL value. This is possible since currently
we don't garantee that Fiedld::null_ptr is never equal to NULL. Such
assertion will be true after a follow-up patch.
do_copy_not_null() was modified: added check for NULL against value
of Copy_field::from_null_ptr before makes dereference this pointer.
At some places tabs were removed.
@ sql/filesort.cc
Since the method Field::maybe_null was renamed the references to this
method were also renamed.
@ sql/item.cc
Since the method Field::maybe_null was renamed the references to this method
were also renamed. The methods Item::tmp_table_field_from_field_type() and
Item_type_holder::make_field_by_type() were modified: added passing of
an explicit nullability flag to constructor of classes derived from Field.
@ sql/item_subselect.cc
References to Field::real_maybe_null() were replaced by
Field::real_is_nullable() since the "rename" refactoring method
was applied to Field class.
@ sql/key.cc
References to Field::is_null_in_record_with_offset () were replaced by
Field::is_real_null() since the first method was removed as having
a duplicate functionality against Field::is_real_null.
@ sql/log_event.cc
References to Field::maybe_null() were replaced by Field::is_nullable()
since the "rename" refactoring method was applied to Field class.
@ sql/log_event_old.cc
References to Field::maybe_null() were replaced by Field::is_nullable()
since the "rename" refactoring method was applied to Field class.
@ sql/opt_range.cc
References to Field::real_maybe_null() were replaced by
Field::real_is_nullable() since the "rename" refactoring method
was applied to Field class.
@ sql/opt_sum.cc
References to Field::real_maybe_null() were replaced by
Field::real_is_nullable() since the "rename" refactoring method
was applied to Field class.
@ sql/rpl_record.cc
References to Field::maybe_null() were replaced by
Field::is_nullable() since the "rename" refactoring method
was applied to Field class.
@ sql/sql_join_buffer.cc
References to Field::maybe_null() were replaced by
Field::is_nullable() since the "rename" refactoring method
was applied to Field class.
@ sql/sql_load.cc
References to Field::maybe_null() were replaced by
Field::is_nullable() since the "rename" refactoring method
was applied to Field class.
@ sql/sql_optimizer.cc
References to Field::maybe_null() and Field::real_maybe_null()
were replaced by Field::is_nullable() and Field::real_is_nullable()
since the "rename" refactoring method was applied to Field class.
Access to data member Field::null_ptr to check for nullability
was replaced by call to method Field::real_is_nullable.
@ sql/sql_partition.cc
References to Field::maybe_null() and Field::real_maybe_null()
were replaced by Field::is_nullable() and Field::real_is_nullable()
since the "rename" refactoring method was applied to Field class.
@ sql/sql_resolver.cc
The reference to Field::maybe_null() was replaced by
Field::is_nullable() since the "rename" refactoring method
was applied to Field class.
@ sql/sql_select.cc
Reference to Field::real_maybe_null() was replaced by
Field::real_is_nullable() since the "rename" refactoring method
was applied to Field class. Explicit use of constant NOT_NULL_FLAG
was replaced by call of method Field::real_is_nullable().
@ sql/sql_select.h
References to Field::maybe_nullable() were replaced by Field::is_nullable()
since the "rename" refactoring method was applied to Field class.
Added passing of explicit nullability flag when instantiating the
class derived from Field (over call to Field::new_key_field or explicitly
using the constructor of class Field_varstring).
@ sql/sql_show.cc
References to Field::maybe_null() were replaced by
Field::is_nullable() since the "rename" refactoring method
was applied to Field class. Access to the data member Field::flags
to check for nullability were replaced by the call of
Field::real_is_nullable().
@ sql/sql_tmp_table.cc
References to Field::maybe_null() were replaced by
Field::is_nullable() since the "rename" refactoring method
was applied to Field class.
Added passing of explicit nullability flag when instantiating the
class derived from Field (over call to Field::new_key_field or explicitly
using the constructor of class Field_string).
@ sql/sql_update.cc
References to Field::real_maybe_null() were replaced by
Field::real_is_nullable() since the "rename" refactoring method
was applied to Field class.
@ sql/table.cc
References to Field::real_maybe_null() were replaced by
Field::real_is_nullable() since the "rename" refactoring method
was applied to Field class. Access to data member Field::null_ptr
to check for nullability was replaced by call to the method
Field::real_is_nullable.
@ sql/unireg.cc
make_empty_rec() was modified: access to the Field::null_ptr attribute
when set nullability for a field were replaced by the call of
Field::set_null().
@ storage/csv/ha_tina.cc
The reference to Field::real_maybe_null() was replaced by
Field::real_is_nullable() since the "rename" refactoring method
was applied to Field class.
@ storage/federated/ha_federated.cc
Access to data member Field::null_ptr to check for nullability
was replaced by call to method Field::real_is_nullable.
@ storage/heap/ha_heap.cc
Access to data member Field::null_ptr to check for nullability
was replaced by call to method Field::real_is_nullable.
@ storage/innobase/handler/ha_innodb.cc
Access to data member Field::null_ptr to check for nullability
were replaced by call to method Field::real_is_nullable.
@ storage/innobase/handler/handler0alter.cc
Access to data member Field::null_ptr to check for nullability
was replaced by call to method Field::real_is_nullable.
References to Field::real_maybe_null() were replaced by
Field::real_is_nullable() since the "rename" refactoring method
was applied to Field class.
@ storage/myisam/ha_myisam.cc
Access to data member Field::null_ptr to check for nullability
was replaced by call to method Field::real_is_nullable.
modified:
sql/field.cc
sql/field.h
sql/field_conv.cc
sql/filesort.cc
sql/item.cc
sql/item_subselect.cc
sql/key.cc
sql/log_event.cc
sql/log_event_old.cc
sql/opt_range.cc
sql/opt_sum.cc
sql/rpl_record.cc
sql/sql_join_buffer.cc
sql/sql_load.cc
sql/sql_optimizer.cc
sql/sql_partition.cc
sql/sql_resolver.cc
sql/sql_select.cc
sql/sql_select.h
sql/sql_show.cc
sql/sql_tmp_table.cc
sql/sql_update.cc
sql/table.cc
sql/unireg.cc
storage/csv/ha_tina.cc
storage/federated/ha_federated.cc
storage/heap/ha_heap.cc
storage/innobase/handler/ha_innodb.cc
storage/innobase/handler/handler0alter.cc
storage/myisam/ha_myisam.cc
=== modified file 'sql/field.cc'
--- a/sql/field.cc 2012-05-11 08:55:35 +0000
+++ b/sql/field.cc 2012-05-15 12:39:41 +0000
@@ -1107,10 +1107,10 @@ bool Field::type_can_have_key_part(enum
Numeric fields base class constructor.
*/
Field_num::Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- utype unireg_check_arg, const char *field_name_arg,
- uint8 dec_arg, bool zero_arg, bool unsigned_arg)
- :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ uchar null_bit_arg, utype unireg_check_arg,
+ const char *field_name_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),
dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg)
{
@@ -1319,8 +1319,8 @@ String *Field::val_int_as_str(String *va
/// 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, bool is_nullable,
- utype unireg_check_arg, const char *field_name_arg)
+ uchar null_bit_arg, utype unireg_check_arg,
+ const char *field_name_arg)
:ptr(ptr_arg), null_ptr(null_ptr_arg),
table(0), orig_table(0), table_name(0),
field_name(field_name_arg),
@@ -1328,7 +1328,7 @@ Field::Field(uchar *ptr_arg,uint32 lengt
field_length(length_arg), null_bit(null_bit_arg),
is_created_from_null_item(FALSE)
{
- flags= is_nullable ? 0: NOT_NULL_FLAG;
+ flags= null_ptr ? 0: NOT_NULL_FLAG;
comment.str= (char*) "";
comment.length=0;
field_index= 0;
@@ -1694,10 +1694,10 @@ bool Field_num::get_time(MYSQL_TIME *lti
Field_str::Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- utype unireg_check_arg, const char *field_name_arg,
+ uchar null_bit_arg, utype unireg_check_arg,
+ const char *field_name_arg,
const CHARSET_INFO *charset_arg)
- :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg)
{
field_charset= charset_arg;
@@ -1858,7 +1858,7 @@ Field *Field::new_field(MEM_ROOT *root,
Field *Field::new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uchar *new_null_ptr,
- uint new_null_bit, bool is_nullable)
+ uint new_null_bit)
{
Field *tmp;
if ((tmp= new_field(root, new_table, table == new_table)))
@@ -1866,7 +1866,7 @@ Field *Field::new_key_field(MEM_ROOT *ro
tmp->ptr= new_ptr;
tmp->null_ptr= new_null_ptr;
tmp->null_bit= new_null_bit;
- tmp->flags|= is_nullable ? 0: NOT_NULL_FLAG;
+ tmp->flags|= new_null_ptr ? 0: NOT_NULL_FLAG;
}
return tmp;
}
@@ -2508,13 +2508,13 @@ void Field_decimal::sql_type(String &res
Field_new_decimal::Field_new_decimal(uchar *ptr_arg,
uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
+ uchar null_bit_arg,
enum utype unireg_check_arg,
const char *field_name_arg,
uint8 dec_arg,bool zero_arg,
bool unsigned_arg)
- :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
- unireg_check_arg, field_name_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);
@@ -2531,7 +2531,7 @@ Field_new_decimal::Field_new_decimal(uin
bool unsigned_arg)
:Field_num((uchar*) 0, len_arg,
is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, name, 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);
@@ -5248,11 +5248,10 @@ my_decimal *Field_temporal_with_date_and
*/
Field_timestamp::Field_timestamp(uchar *ptr_arg, uint32 len_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
+ enum utype unireg_check_arg,
const char *field_name_arg)
:Field_temporal_with_date_and_time(ptr_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg,
- field_name_arg, 0)
+ unireg_check_arg, field_name_arg, 0)
{
init_timestamp_flags();
/* For 4.0 MYD and 4.0 InnoDB compatibility */
@@ -5264,7 +5263,7 @@ Field_timestamp::Field_timestamp(bool is
const char *field_name_arg)
:Field_temporal_with_date_and_time((uchar *) 0,
is_nullable ? (uchar *) "" : 0, 0,
- is_nullable, NONE, field_name_arg, 0)
+ NONE, field_name_arg, 0)
{
init_timestamp_flags();
/* For 4.0 MYD and 4.0 InnoDB compatibility */
@@ -5427,11 +5426,11 @@ void Field_timestamp::sql_type(String &r
****************************************************************************/
Field_timestampf::Field_timestampf(uchar *ptr_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
+ enum utype unireg_check_arg,
const char *field_name_arg,
uint8 dec_arg)
:Field_temporal_with_date_and_timef(ptr_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg,
+ unireg_check_arg,
field_name_arg, dec_arg)
{
init_timestamp_flags();
@@ -5443,7 +5442,7 @@ Field_timestampf::Field_timestampf(bool
uint8 dec_arg)
:Field_temporal_with_date_and_timef((uchar*) 0,
is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, field_name_arg, dec_arg)
+ NONE, field_name_arg, dec_arg)
{
if (unireg_check != TIMESTAMP_DN_FIELD)
flags|= ON_UPDATE_NOW_FLAG;
@@ -7414,15 +7413,14 @@ Field *Field_varstring::new_field(MEM_RO
Field *Field_varstring::new_key_field(MEM_ROOT *root,
TABLE *new_table,
uchar *new_ptr, uchar *new_null_ptr,
- uint new_null_bit, bool is_nullable)
+ uint new_null_bit)
{
Field_varstring *res;
if ((res= (Field_varstring*) Field::new_key_field(root,
new_table,
new_ptr,
new_null_ptr,
- new_null_bit,
- is_nullable)))
+ new_null_bit)))
{
/* Keys length prefixes are always packed with 2 bytes */
res->length_bytes= 2;
@@ -7469,12 +7467,11 @@ void Field_varstring::hash(ulong *nr, ul
****************************************************************************/
Field_blob::Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
- const char *field_name_arg,
+ enum utype unireg_check_arg, const char *field_name_arg,
TABLE_SHARE *share, uint blob_pack_length,
const CHARSET_INFO *cs)
:Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length),
- null_ptr_arg, null_bit_arg, is_nullable, unireg_check_arg,
+ null_ptr_arg, null_bit_arg, unireg_check_arg,
field_name_arg, cs),
packlength(blob_pack_length)
{
@@ -8773,10 +8770,10 @@ uint Field_num::is_equal(Create_field *n
*/
Field_bit::Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable, uchar *bit_ptr_arg,
+ uchar null_bit_arg, uchar *bit_ptr_arg,
uchar bit_ofs_arg, enum utype unireg_check_arg,
const char *field_name_arg)
- : Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ : Field(ptr_arg, len_arg, null_ptr_arg, null_bit_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)
@@ -8842,12 +8839,12 @@ Field_bit::do_last_null_byte() const
Field *Field_bit::new_key_field(MEM_ROOT *root,
TABLE *new_table,
uchar *new_ptr, uchar *new_null_ptr,
- uint new_null_bit, bool is_nullable)
+ uint new_null_bit)
{
Field_bit *res;
if ((res= (Field_bit*) Field::new_key_field(root, new_table,
new_ptr, new_null_ptr,
- new_null_bit, is_nullable)))
+ new_null_bit)))
{
/* Move bits normally stored in null_pointer to new_ptr */
res->bit_ptr= new_ptr;
@@ -9293,10 +9290,9 @@ void Field_bit::set_default()
Field_bit_as_char::Field_bit_as_char(uchar *ptr_arg, uint32 len_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable,
enum utype unireg_check_arg,
const char *field_name_arg)
- :Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable, 0, 0,
+ :Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, 0, 0,
unireg_check_arg, field_name_arg)
{
flags|= UNSIGNED_FLAG;
@@ -10021,12 +10017,11 @@ Field *make_field(TABLE_SHARE *share, uc
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,
- is_nullable, unireg_check, field_name,
- field_charset);
+ 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, is_nullable,
+ null_pos, null_bit,
unireg_check, field_name,
share,
field_charset);
@@ -10039,105 +10034,105 @@ Field *make_field(TABLE_SHARE *share, uc
#ifdef HAVE_SPATIAL
if (f_is_geom(pack_flag))
- return new Field_geom(ptr, null_pos, null_bit, is_nullable,
+ return new Field_geom(ptr, null_pos, null_bit,
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, is_nullable,
+ return new Field_blob(ptr, null_pos, null_bit,
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,
- is_nullable, unireg_check, field_name,
- pack_length, interval, field_charset);
+ unireg_check, field_name, pack_length,
+ interval, field_charset);
else
return new Field_set(ptr, field_length, null_pos, null_bit,
- is_nullable, unireg_check, field_name,
- pack_length, interval, field_charset);
+ unireg_check, field_name, pack_length,
+ interval, field_charset);
}
}
switch (field_type) {
case MYSQL_TYPE_DECIMAL:
return new Field_decimal(ptr, field_length, null_pos, null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_decimals(pack_flag),
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_NEWDECIMAL:
return new Field_new_decimal(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_decimals(pack_flag),
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_FLOAT:
return new Field_float(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_decimals(pack_flag),
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag)== 0);
case MYSQL_TYPE_DOUBLE:
return new Field_double(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_decimals(pack_flag),
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag)== 0);
case MYSQL_TYPE_TINY:
return new Field_tiny(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_SHORT:
return new Field_short(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_INT24:
return new Field_medium(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_LONG:
return new Field_long(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_LONGLONG:
return new Field_longlong(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_TIMESTAMP:
return new Field_timestamp(ptr, field_length, null_pos, null_bit,
- is_nullable, unireg_check, field_name);
+ unireg_check, field_name);
case MYSQL_TYPE_TIMESTAMP2:
return new Field_timestampf(ptr, null_pos, null_bit,
- is_nullable, unireg_check, field_name,
+ unireg_check, field_name,
field_length > MAX_DATETIME_WIDTH ?
field_length - 1 - MAX_DATETIME_WIDTH : 0);
case MYSQL_TYPE_YEAR:
return new Field_year(ptr,field_length,null_pos,null_bit,
- is_nullable, unireg_check, field_name);
+ unireg_check, field_name);
case MYSQL_TYPE_NEWDATE:
- return new Field_newdate(ptr, null_pos, null_bit, is_nullable,
+ return new Field_newdate(ptr, null_pos, null_bit,
unireg_check, field_name);
case MYSQL_TYPE_TIME:
- return new Field_time(ptr, null_pos, null_bit, is_nullable,
+ return new Field_time(ptr, null_pos, null_bit,
unireg_check, field_name);
case MYSQL_TYPE_TIME2:
- return new Field_timef(ptr, null_pos, null_bit, is_nullable,
+ return new Field_timef(ptr, null_pos, null_bit,
unireg_check, field_name,
(field_length > MAX_TIME_WIDTH) ?
field_length - 1 - MAX_TIME_WIDTH : 0);
case MYSQL_TYPE_DATETIME:
- return new Field_datetime(ptr, null_pos, null_bit, is_nullable,
+ return new Field_datetime(ptr, null_pos, null_bit,
unireg_check, field_name);
case MYSQL_TYPE_DATETIME2:
- return new Field_datetimef(ptr, null_pos, null_bit, is_nullable,
+ return new Field_datetimef(ptr, null_pos, null_bit,
unireg_check, field_name,
(field_length > MAX_DATETIME_WIDTH) ?
field_length - 1 - MAX_DATETIME_WIDTH : 0);
@@ -10147,8 +10142,8 @@ Field *make_field(TABLE_SHARE *share, uc
case MYSQL_TYPE_BIT:
return f_bit_as_char(pack_flag) ?
new Field_bit_as_char(ptr, field_length, null_pos, null_bit,
- is_nullable, unireg_check, field_name) :
- new Field_bit(ptr, field_length, null_pos, null_bit, is_nullable,
+ unireg_check, field_name) :
+ new Field_bit(ptr, field_length, null_pos, null_bit,
bit_ptr, bit_offset, unireg_check, field_name);
default: // Impossible (Wrong version)
=== modified file 'sql/field.h'
--- a/sql/field.h 2012-05-11 08:55:35 +0000
+++ b/sql/field.h 2012-05-15 15:47:14 +0000
@@ -391,7 +391,7 @@ public:
bool is_created_from_null_item;
Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable, utype unireg_check_arg,
+ uchar null_bit_arg, utype unireg_check_arg,
const char *field_name_arg);
virtual ~Field() {}
/* Store functions returns 1 on overflow and -1 on fatal error */
@@ -629,7 +629,7 @@ public:
my_ptrdiff_t l_offset= (my_ptrdiff_t) (table->s->default_values -
table->record[0]);
memcpy(ptr, ptr + l_offset, pack_length());
- if (real_is_nullable())
+ if (is_real_nullable())
*null_ptr= ((*null_ptr & (uchar) ~null_bit) |
(null_ptr[l_offset] & null_bit));
}
@@ -731,33 +731,32 @@ public:
if (table->null_row)
return true;
- if (real_is_nullable())
+ if (is_real_nullable())
return (null_ptr[row_offset] & null_bit);
return false;
}
inline bool is_real_null(my_ptrdiff_t row_offset= 0)
{
- return real_is_nullable() ?
- (null_ptr[row_offset] & null_bit ? true : false) :
- false;
+ return is_real_nullable() ? bool(null_ptr[row_offset] & null_bit)
+ : false;
}
inline bool is_null_in_record(const uchar *record)
{
- if (!real_is_nullable())
+ if (!is_real_nullable())
return false;
return test(record[(uint) (null_ptr - table->record[0])] &
null_bit);
}
inline void set_null(my_ptrdiff_t row_offset= 0)
- { if (real_is_nullable()) null_ptr[row_offset]|= null_bit; }
+ { if (is_real_nullable()) null_ptr[row_offset]|= null_bit; }
inline void set_notnull(my_ptrdiff_t row_offset= 0)
{ if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; }
- inline bool is_nullable(void) const { return real_is_nullable() || table->maybe_null; }
+ inline bool is_nullable(void) const { return is_real_nullable() || table->maybe_null; }
/**
Signals that this field is NULL-able.
*/
- inline bool real_is_nullable(void) const
+ inline bool is_real_nullable(void) const
{ return !(flags & NOT_NULL_FLAG); }
enum {
@@ -802,7 +801,7 @@ public:
bool keep_type);
virtual Field *new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uchar *new_null_ptr,
- uint new_null_bit, bool is_nullable);
+ uint new_null_bit);
/**
Makes a shallow copy of the Field object.
@@ -1237,7 +1236,7 @@ public:
const uint8 dec;
bool zerofill,unsigned_flag; // Purify cannot handle bit fields
Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable, utype unireg_check_arg,
+ uchar null_bit_arg, utype unireg_check_arg,
const char *field_name_arg,
uint8 dec_arg, bool zero_arg, bool unsigned_arg);
Item_result result_type () const { return REAL_RESULT; }
@@ -1276,7 +1275,7 @@ protected:
enum Derivation field_derivation;
public:
Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable, utype unireg_check_arg,
+ uchar null_bit_arg, utype unireg_check_arg,
const char *field_name_arg, const CHARSET_INFO *charset);
Item_result result_type () const { return STRING_RESULT; }
Item_result numeric_context_result_type() const
@@ -1316,9 +1315,9 @@ protected:
bool count_spaces);
public:
Field_longstr(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable, utype unireg_check_arg,
+ uchar null_bit_arg, utype unireg_check_arg,
const char *field_name_arg, const CHARSET_INFO *charset_arg)
- :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, charset_arg)
{}
@@ -1332,10 +1331,10 @@ public:
my_bool not_fixed;
Field_real(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable, utype unireg_check_arg,
+ uchar null_bit_arg, utype unireg_check_arg,
const char *field_name_arg,
uint8 dec_arg, bool zero_arg, bool unsigned_arg)
- :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, dec_arg, zero_arg,
unsigned_arg),
not_fixed(dec_arg >= NOT_FIXED_DEC)
@@ -1357,11 +1356,11 @@ public:
class Field_decimal :public Field_real {
public:
Field_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- uint8 dec_arg,bool zero_arg,bool unsigned_arg)
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, uint8 dec_arg,
+ bool zero_arg,bool unsigned_arg)
:Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg, field_name_arg,
+ unireg_check_arg, field_name_arg,
dec_arg, zero_arg, unsigned_arg)
{}
enum_field_types type() const { return MYSQL_TYPE_DECIMAL;}
@@ -1415,9 +1414,9 @@ public:
CREATE TABLE ( DECIMAL(x,y))
*/
Field_new_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- uint8 dec_arg, bool zero_arg, bool unsigned_arg);
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, uint8 dec_arg,
+ bool zero_arg, bool unsigned_arg);
Field_new_decimal(uint32 len_arg, bool is_nullable,
const char *field_name_arg, uint8 dec_arg,
bool unsigned_arg);
@@ -1466,11 +1465,10 @@ public:
class Field_tiny :public Field_num {
public:
Field_tiny(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- bool zero_arg, bool unsigned_arg)
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, bool zero_arg, bool unsigned_arg)
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg, field_name_arg,
+ unireg_check_arg, field_name_arg,
0, zero_arg,unsigned_arg)
{}
enum Item_result result_type () const { return INT_RESULT; }
@@ -1517,17 +1515,16 @@ public:
class Field_short :public Field_num {
public:
Field_short(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- bool zero_arg, bool unsigned_arg)
- :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_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,
0, zero_arg,unsigned_arg)
{}
Field_short(uint32 len_arg,bool is_nullable, const char *field_name_arg,
bool unsigned_arg)
:Field_num((uchar*) 0, len_arg, is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, field_name_arg, 0, 0, unsigned_arg)
+ NONE, field_name_arg, 0, 0, unsigned_arg)
{}
enum Item_result result_type () const { return INT_RESULT; }
enum_field_types type() const { return MYSQL_TYPE_SHORT;}
@@ -1570,10 +1567,9 @@ public:
class Field_medium :public Field_num {
public:
Field_medium(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- bool zero_arg, bool unsigned_arg)
- :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_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,
0, zero_arg,unsigned_arg)
{}
@@ -1619,17 +1615,16 @@ public:
class Field_long :public Field_num {
public:
Field_long(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- bool zero_arg, bool unsigned_arg)
- :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_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,
0, zero_arg,unsigned_arg)
{}
Field_long(uint32 len_arg, bool is_nullable, const char *field_name_arg,
bool unsigned_arg)
:Field_num((uchar*) 0, len_arg, is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, field_name_arg, 0, 0, unsigned_arg)
+ NONE, field_name_arg, 0, 0, unsigned_arg)
{}
enum Item_result result_type () const { return INT_RESULT; }
enum_field_types type() const { return MYSQL_TYPE_LONG;}
@@ -1675,18 +1670,17 @@ public:
class Field_longlong :public Field_num {
public:
Field_longlong(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- bool zero_arg, bool unsigned_arg)
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, bool zero_arg, bool unsigned_arg)
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg, field_name_arg,
+ unireg_check_arg, field_name_arg,
0, zero_arg,unsigned_arg)
{}
Field_longlong(uint32 len_arg, bool is_nullable,
const char *field_name_arg,
bool unsigned_arg)
:Field_num((uchar*) 0, len_arg, is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, field_name_arg,0,0,unsigned_arg)
+ NONE, field_name_arg,0,0,unsigned_arg)
{}
enum Item_result result_type () const { return INT_RESULT; }
enum_field_types type() const { return MYSQL_TYPE_LONGLONG;}
@@ -1737,17 +1731,17 @@ public:
class Field_float :public Field_real {
public:
Field_float(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- uint8 dec_arg,bool zero_arg,bool unsigned_arg)
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, uint8 dec_arg,
+ bool zero_arg,bool unsigned_arg)
:Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg, field_name_arg,
+ unireg_check_arg, field_name_arg,
dec_arg, zero_arg, unsigned_arg)
{}
Field_float(uint32 len_arg, bool is_nullable, const char *field_name_arg,
uint8 dec_arg)
:Field_real((uchar*) 0, len_arg, is_nullable ? (uchar*) "": 0, (uint) 0,
- is_nullable, NONE, field_name_arg, dec_arg, 0, 0)
+ NONE, field_name_arg, dec_arg, 0, 0)
{}
enum_field_types type() const { return MYSQL_TYPE_FLOAT;}
enum ha_base_keytype key_type() const { return HA_KEYTYPE_FLOAT; }
@@ -1780,22 +1774,22 @@ private:
class Field_double :public Field_real {
public:
Field_double(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- uint8 dec_arg,bool zero_arg,bool unsigned_arg)
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, uint8 dec_arg,
+ bool zero_arg, bool unsigned_arg)
:Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg, field_name_arg,
+ unireg_check_arg, field_name_arg,
dec_arg, zero_arg, unsigned_arg)
{}
Field_double(uint32 len_arg, bool is_nullable, const char *field_name_arg,
uint8 dec_arg)
:Field_real((uchar*) 0, len_arg, is_nullable ? (uchar*) "" : 0, (uint) 0,
- is_nullable, NONE, field_name_arg, dec_arg, 0, 0)
+ NONE, field_name_arg, dec_arg, 0, 0)
{}
Field_double(uint32 len_arg, bool is_nullable, const char *field_name_arg,
uint8 dec_arg, my_bool not_fixed_arg)
:Field_real((uchar*) 0, len_arg, is_nullable ? (uchar*) "" : 0, (uint) 0,
- is_nullable, NONE, field_name_arg, dec_arg, 0, 0)
+ NONE, field_name_arg, dec_arg, 0, 0)
{not_fixed= not_fixed_arg; }
enum_field_types type() const { return MYSQL_TYPE_DOUBLE;}
enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; }
@@ -1833,8 +1827,8 @@ public:
Field_null(uchar *ptr_arg, uint32 len_arg,
enum utype unireg_check_arg, const char *field_name_arg,
const CHARSET_INFO *cs)
- :Field_str(ptr_arg, len_arg, null, 1, true,
- unireg_check_arg, field_name_arg, cs)
+ :Field_str(ptr_arg, len_arg, null, 1, unireg_check_arg,
+ field_name_arg, cs)
{}
enum_field_types type() const { return MYSQL_TYPE_NULL;}
int store(const char *to, uint length, const CHARSET_INFO *cs)
@@ -2018,12 +2012,12 @@ public:
@param dec_arg Number of second fraction digits, 0..6.
*/
Field_temporal(uchar *ptr_arg,
- uchar *null_ptr_arg, uchar null_bit_arg, bool is_nullable,
+ uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg,
uint32 len_arg, uint8 dec_arg)
:Field(ptr_arg,
len_arg + ((dec= normalize_dec(dec_arg)) ? dec + 1 : 0),
- null_ptr_arg, null_bit_arg, is_nullable,
+ null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg)
{ flags|= BINARY_FLAG; }
/**
@@ -2037,7 +2031,7 @@ public:
uint32 len_arg, uint8 dec_arg)
:Field((uchar *) 0,
len_arg + ((dec= normalize_dec(dec_arg)) ? dec + 1 : 0),
- is_nullable ? (uchar *) "" : 0, 0, is_nullable,
+ is_nullable ? (uchar *) "" : 0, 0,
NONE, field_name_arg)
{ flags|= BINARY_FLAG; }
virtual Item_result result_type() const { return STRING_RESULT; }
@@ -2103,11 +2097,11 @@ public:
@param dec_arg Number of second fraction digits, 0..6.
*/
Field_temporal_with_date(uchar *ptr_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
+ uchar null_bit_arg,
enum utype unireg_check_arg,
const char *field_name_arg,
uint8 int_length_arg, uint8 dec_arg)
- :Field_temporal(ptr_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ :Field_temporal(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg,
int_length_arg, dec_arg)
{ }
@@ -2120,7 +2114,7 @@ public:
*/
Field_temporal_with_date(bool is_nullable, const char *field_name_arg,
uint int_length_arg, uint8 dec_arg)
- :Field_temporal((uchar*) 0, is_nullable ? (uchar*) "": 0, 0, is_nullable,
+ :Field_temporal((uchar*) 0, is_nullable ? (uchar*) "": 0, 0,
NONE, field_name_arg, int_length_arg, dec_arg)
{ }
bool send_binary(Protocol *protocol);
@@ -2179,11 +2173,11 @@ public:
@param dec_arg Number of second fraction digits, 0..6.
*/
Field_temporal_with_date_and_time(uchar *ptr_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
+ uchar null_bit_arg,
enum utype unireg_check_arg,
const char *field_name_arg,
uint8 dec_arg)
- :Field_temporal_with_date(ptr_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ :Field_temporal_with_date(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg,
MAX_DATETIME_WIDTH, dec_arg)
{ }
@@ -2214,12 +2208,12 @@ public:
@param dec_arg Number of second fraction digits, 0..6.
*/
Field_temporal_with_date_and_timef(uchar *ptr_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
+ uchar null_bit_arg,
enum utype unireg_check_arg,
const char *field_name_arg,
uint8 dec_arg)
:Field_temporal_with_date_and_time(ptr_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg,
+ unireg_check_arg,
field_name_arg, dec_arg)
{ }
/**
@@ -2233,7 +2227,7 @@ public:
uint8 dec_arg)
:Field_temporal_with_date_and_time((uchar *) 0,
is_nullable ? (uchar*) "" : 0, 0,
- is_nullable, NONE, field_name_arg,
+ NONE, field_name_arg,
dec_arg)
{ }
@@ -2268,7 +2262,7 @@ protected:
public:
static const int PACK_LENGTH= 4;
Field_timestamp(uchar *ptr_arg, uint32 len_arg,
- uchar *null_ptr_arg, uchar null_bit_arg, bool is_nullable,
+ uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg);
Field_timestamp(bool is_nullable, const char *field_name_arg);
enum_field_types type() const { return MYSQL_TYPE_TIMESTAMP;}
@@ -2329,8 +2323,8 @@ public:
@param dec_arg Number of fractional second digits, 0..6.
*/
Field_timestampf(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
- const char *field_name_arg, uint8 dec_arg);
+ enum utype unireg_check_arg, const char *field_name_arg,
+ uint8 dec_arg);
/**
Field_timestampf constructor
@param is_nullable See Field definition
@@ -2378,9 +2372,9 @@ public:
class Field_year :public Field_tiny {
public:
Field_year(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg)
- :Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg)
+ :Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, 1, 1)
{}
enum_field_types type() const { return MYSQL_TYPE_YEAR;}
@@ -2413,15 +2407,15 @@ protected:
public:
Field_newdate(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
+ enum utype unireg_check_arg,
const char *field_name_arg)
:Field_temporal_with_date(ptr_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg, field_name_arg,
+ unireg_check_arg, field_name_arg,
MAX_DATE_WIDTH, 0)
{ }
Field_newdate(bool is_nullable, const char *field_name_arg)
:Field_temporal_with_date((uchar *) 0, is_nullable ? (uchar *) "" : 0,
- 0, is_nullable, NONE, field_name_arg,
+ 0, NONE, field_name_arg,
MAX_DATE_WIDTH, 0)
{ }
enum_field_types type() const { return MYSQL_TYPE_DATE;}
@@ -2485,9 +2479,9 @@ public:
@param dec_arg Number of second fraction digits, 0..6.
*/
Field_time_common(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
- const char *field_name_arg, uint8 dec_arg)
- :Field_temporal(ptr_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ enum utype unireg_check_arg, const char *field_name_arg,
+ uint8 dec_arg)
+ :Field_temporal(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg,
MAX_TIME_WIDTH, dec_arg)
{ }
@@ -2500,7 +2494,7 @@ public:
Field_time_common(bool is_nullable, const char *field_name_arg,
uint8 dec_arg)
:Field_temporal((uchar *) 0, is_nullable ? (uchar *) "" : 0, 0,
- is_nullable, NONE, field_name_arg, MAX_TIME_WIDTH, dec_arg)
+ NONE, field_name_arg, MAX_TIME_WIDTH, dec_arg)
{ }
int store_time(MYSQL_TIME *ltime, uint8 dec);
String *val_str(String*, String *);
@@ -2519,14 +2513,14 @@ protected:
int store_internal(const MYSQL_TIME *ltime, int *error);
public:
Field_time(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
+ enum utype unireg_check_arg,
const char *field_name_arg)
- :Field_time_common(ptr_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ :Field_time_common(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, 0)
{ }
Field_time(bool is_nullable, const char *field_name_arg)
:Field_time_common((uchar *) 0, is_nullable ? (uchar *) "" : 0, 0,
- is_nullable, NONE, field_name_arg, 0)
+ NONE, field_name_arg, 0)
{ }
enum_field_types type() const { return MYSQL_TYPE_TIME;}
enum ha_base_keytype key_type() const { return HA_KEYTYPE_INT24; }
@@ -2574,9 +2568,9 @@ public:
@param dec_arg Number of second fraction digits, 0..6.
*/
Field_timef(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
- const char *field_name_arg, uint8 dec_arg)
- :Field_time_common(ptr_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ enum utype unireg_check_arg, const char *field_name_arg,
+ uint8 dec_arg)
+ :Field_time_common(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, dec_arg)
{ }
/**
@@ -2587,7 +2581,7 @@ public:
*/
Field_timef(bool is_nullable, const char *field_name_arg, uint8 dec_arg)
:Field_time_common((uchar *) 0, is_nullable ? (uchar *) "" : 0, 0,
- is_nullable, NONE, field_name_arg, dec_arg)
+ NONE, field_name_arg, dec_arg)
{ }
Field_timef *clone(MEM_ROOT *mem_root) const
{
@@ -2676,16 +2670,15 @@ public:
ON UPDATE CURRENT_TIMESTAMP
*/
Field_datetime(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
+ enum utype unireg_check_arg,
const char *field_name_arg)
:Field_temporal_with_date_and_time(ptr_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg,
- field_name_arg, 0)
+ unireg_check_arg, field_name_arg, 0)
{}
Field_datetime(bool is_nullable, const char *field_name_arg)
:Field_temporal_with_date_and_time((uchar *) 0,
- is_nullable ? (uchar *) "" : 0,
- 0, is_nullable, NONE, field_name_arg, 0)
+ is_nullable ? (uchar *) "" : 0, 0,
+ NONE, field_name_arg, 0)
{}
enum_field_types type() const { return MYSQL_TYPE_DATETIME;}
#ifdef HAVE_LONG_LONG
@@ -2752,11 +2745,11 @@ public:
@param dec_arg Number of second fraction digits, 0..6.
*/
Field_datetimef(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
+ enum utype unireg_check_arg,
const char *field_name_arg, uint8 dec_arg)
:Field_temporal_with_date_and_timef(ptr_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg,
- field_name_arg, dec_arg)
+ unireg_check_arg, field_name_arg,
+ dec_arg)
{}
/**
Constructor for Field_datetimef
@@ -2769,7 +2762,7 @@ public:
uint8 dec_arg)
:Field_temporal_with_date_and_timef((uchar *) 0,
is_nullable ? (uchar *) "" : 0, 0,
- is_nullable, NONE, field_name_arg,
+ NONE, field_name_arg,
dec_arg)
{}
Field_datetimef *clone(MEM_ROOT *mem_root) const
@@ -2810,16 +2803,15 @@ class Field_string :public Field_longstr
public:
bool can_alter_field_type;
Field_string(uchar *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- const CHARSET_INFO *cs)
- :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, const CHARSET_INFO *cs)
+ :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, cs),
can_alter_field_type(1) {};
Field_string(uint32 len_arg, bool is_nullable, const char *field_name_arg,
const CHARSET_INFO *cs)
:Field_longstr((uchar*) 0, len_arg, is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, field_name_arg, cs),
+ NONE, field_name_arg, cs),
can_alter_field_type(1) {};
enum_field_types type() const
@@ -2898,10 +2890,10 @@ public:
uint32 length_bytes;
Field_varstring(uchar *ptr_arg,
uint32 len_arg, uint length_bytes_arg,
- uchar *null_ptr_arg, uchar null_bit_arg, bool is_nullable,
+ uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const char *field_name_arg,
TABLE_SHARE *share, const CHARSET_INFO *cs)
- :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, cs),
length_bytes(length_bytes_arg)
{
@@ -2911,7 +2903,7 @@ public:
const char *field_name_arg,
TABLE_SHARE *share, const CHARSET_INFO *cs)
:Field_longstr((uchar*) 0,len_arg, is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, field_name_arg, cs),
+ NONE, field_name_arg, cs),
length_bytes(len_arg < 256 ? 1 :2)
{
share->varchar_fields++;
@@ -2962,7 +2954,7 @@ public:
Field *new_field(MEM_ROOT *root, TABLE *new_table, bool keep_type);
Field *new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uchar *new_null_ptr,
- uint new_null_bit, bool is_nullable);
+ uint new_null_bit);
Field_varstring *clone(MEM_ROOT *mem_root) const {
DBUG_ASSERT(type() == MYSQL_TYPE_VARCHAR);
DBUG_ASSERT(real_type() == MYSQL_TYPE_VARCHAR);
@@ -2994,13 +2986,13 @@ protected:
public:
Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
- const char *field_name_arg, TABLE_SHARE *share,
- uint blob_pack_length, const CHARSET_INFO *cs);
+ enum utype unireg_check_arg, const char *field_name_arg,
+ TABLE_SHARE *share, uint blob_pack_length,
+ const CHARSET_INFO *cs);
Field_blob(uint32 len_arg, bool is_nullable, const char *field_name_arg,
const CHARSET_INFO *cs)
:Field_longstr((uchar*) 0, len_arg, is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, field_name_arg, cs),
+ NONE, field_name_arg, cs),
packlength(4)
{
flags|= BLOB_FLAG;
@@ -3008,7 +3000,7 @@ public:
Field_blob(uint32 len_arg, bool is_nullable, const char *field_name_arg,
const CHARSET_INFO *cs, bool set_packlength)
:Field_longstr((uchar*) 0, len_arg, is_nullable ? (uchar*) "": 0, 0,
- is_nullable, NONE, field_name_arg, cs)
+ NONE, field_name_arg, cs)
{
flags|= BLOB_FLAG;
packlength= 4;
@@ -3021,7 +3013,7 @@ public:
}
}
Field_blob(uint32 packlength_arg)
- :Field_longstr((uchar*) 0, 0, (uchar*) "", 0, false, NONE, "temp", system_charset_info),
+ :Field_longstr((uchar*) 0, 0, (uchar*) "", 0, NONE, "temp", system_charset_info),
packlength(packlength_arg) {}
/* Note that the default copy constructor is used, in clone() */
enum_field_types type() const { return MYSQL_TYPE_BLOB;}
@@ -3170,10 +3162,10 @@ public:
enum geometry_type geom_type;
Field_geom(uchar *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
- bool is_nullable, enum utype unireg_check_arg,
- const char *field_name_arg, TABLE_SHARE *share,
- int blob_pack_length, enum geometry_type geom_type_arg)
- :Field_blob(ptr_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ enum utype unireg_check_arg, const char *field_name_arg,
+ TABLE_SHARE *share, int blob_pack_length,
+ enum geometry_type geom_type_arg)
+ :Field_blob(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, share,
blob_pack_length, &my_charset_bin)
{ geom_type= geom_type_arg; }
@@ -3215,12 +3207,10 @@ protected:
public:
TYPELIB *typelib;
Field_enum(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- uint packlength_arg,
- TYPELIB *typelib_arg,
- const CHARSET_INFO *charset_arg)
- :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, is_nullable,
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, uint packlength_arg,
+ TYPELIB *typelib_arg, const CHARSET_INFO *charset_arg)
+ :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, charset_arg),
packlength(packlength_arg),typelib(typelib_arg)
{
@@ -3276,12 +3266,11 @@ private:
class Field_set :public Field_enum {
public:
Field_set(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg,
- uint32 packlength_arg,
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg, uint32 packlength_arg,
TYPELIB *typelib_arg, const CHARSET_INFO *charset_arg)
:Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
- is_nullable, unireg_check_arg, field_name_arg,
+ unireg_check_arg, field_name_arg,
packlength_arg,
typelib_arg,charset_arg),
empty_set_string("", 0, charset_arg)
@@ -3330,7 +3319,7 @@ public:
uint bit_len; // number of 'uneven' high bits
uint bytes_in_rec;
Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable, uchar *bit_ptr_arg,
+ uchar null_bit_arg, uchar *bit_ptr_arg,
uchar bit_ofs_arg, enum utype unireg_check_arg,
const char *field_name_arg);
enum_field_types type() const { return MYSQL_TYPE_BIT; }
@@ -3394,7 +3383,7 @@ public:
Field *new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uchar *new_null_ptr,
- uint new_null_bit, bool is_nullable);
+ uint new_null_bit);
void set_bit_ptr(uchar *bit_ptr_arg, uchar bit_ofs_arg)
{
bit_ptr= bit_ptr_arg;
@@ -3437,8 +3426,8 @@ private:
class Field_bit_as_char: public Field_bit {
public:
Field_bit_as_char(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
- uchar null_bit_arg, bool is_nullable,
- enum utype unireg_check_arg, const char *field_name_arg);
+ uchar null_bit_arg, enum utype unireg_check_arg,
+ const char *field_name_arg);
enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
int store(const char *to, uint length, const CHARSET_INFO *charset);
int store(double nr) { return Field_bit::store(nr); }
=== modified file 'sql/field_conv.cc'
--- a/sql/field_conv.cc 2012-05-11 08:55:35 +0000
+++ b/sql/field_conv.cc 2012-05-15 15:47:14 +0000
@@ -102,7 +102,7 @@ static void do_field_to_null_str(Copy_fi
int
set_field_to_null(Field *field)
{
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
field->set_null();
field->reset();
@@ -145,7 +145,7 @@ set_field_to_null(Field *field)
int
set_field_to_null_with_conversions(Field *field, bool no_conversions)
{
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
field->set_null();
field->reset();
@@ -555,7 +555,7 @@ void Copy_field::set(uchar *to,Field *fr
if (from->is_nullable())
{
from_null_ptr=from->null_ptr;
- is_nullable= from->real_is_nullable();
+ is_nullable= from->is_real_nullable();
from_bit= from->null_bit;
to_ptr[0]= 1; // Null as default value
to_null_ptr= (uchar*) to_ptr++;
@@ -608,9 +608,9 @@ void Copy_field::set(Field *to,Field *fr
if (from->is_nullable())
{
from_null_ptr= from->null_ptr;
- is_nullable= from->real_is_nullable();
+ is_nullable= from->is_real_nullable();
from_bit= from->null_bit;
- if (to_field->real_is_nullable())
+ if (to_field->is_real_nullable())
{
to_null_ptr= to->null_ptr;
to_bit= to->null_bit;
@@ -626,7 +626,7 @@ void Copy_field::set(Field *to,Field *fr
do_copy= do_copy_not_null;
}
}
- else if (to_field->real_is_nullable())
+ else if (to_field->is_real_nullable())
{
to_null_ptr= to->null_ptr;
to_bit= to->null_bit;
=== modified file 'sql/ha_ndbcluster.cc'
--- a/sql/ha_ndbcluster.cc 2012-03-28 11:25:37 +0000
+++ b/sql/ha_ndbcluster.cc 2012-05-15 12:39:41 +0000
@@ -1943,7 +1943,7 @@ ha_ndbcluster::set_blob_values(const Ndb
NdbBlob *ndb_blob= ndb_op->getBlobHandle(field_no);
if (ndb_blob == NULL)
ERR_RETURN(ndb_op->getNdbError());
- if (field->is_null_in_record_with_offset(row_offset))
+ if (field->is_real_null(row_offset))
{
DBUG_PRINT("info", ("Setting Blob %d to NULL", field_no));
if (ndb_blob->setNull() != 0)
@@ -6117,7 +6117,7 @@ void ha_ndbcluster::unpack_record(uchar
if (field->type() == MYSQL_TYPE_BIT)
{
Field_bit *field_bit= static_cast<Field_bit*>(field);
- if (!field->is_null_in_record_with_offset(src_offset))
+ if (!field->is_real_null(src_offset))
{
field->move_field_offset(src_offset);
longlong value= field_bit->val_int();
@@ -6208,7 +6208,7 @@ static void get_default_value(void *def_
if (field->type() == MYSQL_TYPE_BIT)
{
Field_bit *field_bit= static_cast<Field_bit*>(field);
- if (!field->is_null_in_record_with_offset(src_offset))
+ if (!field->is_real_null(src_offset))
{
field->move_field_offset(src_offset);
longlong value= field_bit->val_int();
@@ -8587,7 +8587,7 @@ static int create_ndb_column(THD *thd,
{
my_ptrdiff_t src_offset= field->table->s->default_values
- field->table->record[0];
- if ((! field->is_null_in_record_with_offset(src_offset)) ||
+ if ((! field->is_real_null(src_offset)) ||
((field->flags & NOT_NULL_FLAG)))
{
/* Set a non-null native default */
=== modified file 'sql/item.cc'
--- a/sql/item.cc 2012-05-11 08:55:35 +0000
+++ b/sql/item.cc 2012-05-15 12:39:41 +0000
@@ -5908,30 +5908,30 @@ Field *Item::tmp_table_field_from_field_
field= Field_new_decimal::create_from_item(this);
break;
case MYSQL_TYPE_TINY:
- field= new Field_tiny((uchar*) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_tiny((uchar*) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(), 0, unsigned_flag);
break;
case MYSQL_TYPE_SHORT:
- field= new Field_short((uchar*) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_short((uchar*) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(), 0, unsigned_flag);
break;
case MYSQL_TYPE_LONG:
- field= new Field_long((uchar*) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_long((uchar*) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(), 0, unsigned_flag);
break;
#ifdef HAVE_LONG_LONG
case MYSQL_TYPE_LONGLONG:
- field= new Field_longlong((uchar*) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_longlong((uchar*) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(), 0, unsigned_flag);
break;
#endif
case MYSQL_TYPE_FLOAT:
- field= new Field_float((uchar*) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_float((uchar*) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(), decimals, 0,
unsigned_flag);
break;
case MYSQL_TYPE_DOUBLE:
- field= new Field_double((uchar*) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_double((uchar*) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(), decimals, 0,
unsigned_flag);
break;
@@ -5940,7 +5940,7 @@ Field *Item::tmp_table_field_from_field_
item_name.ptr(), &my_charset_bin);
break;
case MYSQL_TYPE_INT24:
- field= new Field_medium((uchar*) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_medium((uchar*) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(), 0, unsigned_flag);
break;
case MYSQL_TYPE_DATE:
@@ -5957,11 +5957,11 @@ Field *Item::tmp_table_field_from_field_
field= new Field_datetimef(maybe_null, item_name.ptr(), decimals);
break;
case MYSQL_TYPE_YEAR:
- field= new Field_year((uchar*) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_year((uchar*) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr());
break;
case MYSQL_TYPE_BIT:
- field= new Field_bit_as_char(NULL, max_length, null_ptr, 0, maybe_null,
+ field= new Field_bit_as_char(NULL, max_length, null_ptr, 0,
Field::NONE, item_name.ptr());
break;
default:
@@ -9282,7 +9282,7 @@ Field *Item_type_holder::make_field_by_t
switch (fld_type) {
case MYSQL_TYPE_ENUM:
DBUG_ASSERT(enum_set_typelib);
- field= new Field_enum((uchar *) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_enum((uchar *) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(),
get_enum_pack_length(enum_set_typelib->count),
enum_set_typelib, collation.collation);
@@ -9291,7 +9291,7 @@ Field *Item_type_holder::make_field_by_t
return field;
case MYSQL_TYPE_SET:
DBUG_ASSERT(enum_set_typelib);
- field= new Field_set((uchar *) 0, max_length, null_ptr, 0, maybe_null,
+ field= new Field_set((uchar *) 0, max_length, null_ptr, 0,
Field::NONE, item_name.ptr(),
get_set_pack_length(enum_set_typelib->count),
enum_set_typelib, collation.collation);
=== modified file 'sql/item_subselect.cc'
--- a/sql/item_subselect.cc 2012-05-11 08:55:35 +0000
+++ b/sql/item_subselect.cc 2012-05-15 15:47:14 +0000
@@ -3401,7 +3401,7 @@ bool subselect_hash_sj_engine::setup(Lis
Item_func_eq *eq_cond;
/* Item for the corresponding field from the materialized temp table. */
Item_field *right_col_item;
- const bool nullable= key_parts[part_no].field->real_is_nullable();
+ const bool nullable= key_parts[part_no].field->is_real_nullable();
tmp_tab->ref.items[part_no]= item_in->left_expr->element_index(part_no);
if (!(right_col_item= new Item_field(thd, context,
=== modified file 'sql/opt_range.cc'
--- a/sql/opt_range.cc 2012-05-11 08:55:35 +0000
+++ b/sql/opt_range.cc 2012-05-15 15:47:14 +0000
@@ -75,7 +75,7 @@
keypart_data: [isnull_byte] keypart-value-bytes
- If a keypart may have a NULL value (key_part->field->real_is_nullable() can
+ If a keypart may have a NULL value (key_part->field->is_real_nullable() can
be used to check this), then the first byte is a NULL indicator with the
following valid values:
1 - keypart has NULL value.
@@ -1857,7 +1857,7 @@ inline void SEL_ARG::make_root()
SEL_ARG::SEL_ARG(Field *f,const uchar *min_value_arg,
const uchar *max_value_arg)
- :min_flag(0), max_flag(0), maybe_flag(0), maybe_null(f->real_is_nullable()),
+ :min_flag(0), max_flag(0), maybe_flag(0), maybe_null(f->is_real_nullable()),
elements(1), use_count(1), field(f), min_value((uchar*) min_value_arg),
max_value((uchar*) max_value_arg), next(NULL), prev(NULL),
next_key_part(0), color(BLACK), type(KEY_RANGE)
@@ -1869,7 +1869,7 @@ SEL_ARG::SEL_ARG(Field *field_,uint8 par
uchar *min_value_, uchar *max_value_,
uint8 min_flag_,uint8 max_flag_,uint8 maybe_flag_)
:min_flag(min_flag_),max_flag(max_flag_),maybe_flag(maybe_flag_),
- part(part_),maybe_null(field_->real_is_nullable()), elements(1),use_count(1),
+ part(part_),maybe_null(field_->is_real_nullable()), elements(1),use_count(1),
field(field_), min_value(min_value_), max_value(max_value_),
next(NULL), prev(NULL), next_key_part(0), color(BLACK), type(KEY_RANGE)
{
@@ -1960,7 +1960,7 @@ static int sel_cmp(Field *field, uchar *
if (b_flag & (NO_MIN_RANGE | NO_MAX_RANGE))
return (b_flag & NO_MIN_RANGE) ? 1 : -1;
- if (field->real_is_nullable()) // If null is part of key
+ if (field->is_real_nullable()) // If null is part of key
{
if (*a != *b)
{
@@ -3222,7 +3222,7 @@ void store_key_image_to_rec(Field *field
/* Do the same as print_key_value() does */
my_bitmap_map *old_map;
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
if (*ptr)
{
@@ -6348,7 +6348,7 @@ static SEL_ARG *
get_mm_leaf(RANGE_OPT_PARAM *param, Item *conf_func, Field *field,
KEY_PART *key_part, Item_func::Functype type,Item *value)
{
- uint maybe_null=(uint) field->real_is_nullable();
+ uint maybe_null=(uint) field->is_real_nullable();
bool optimize_range;
SEL_ARG *tree= 0;
MEM_ROOT *alloc= param->mem_root;
@@ -12203,7 +12203,7 @@ void QUICK_GROUP_MIN_MAX_SELECT::update_
}
}
else if (have_min && min_max_arg_part &&
- min_max_arg_part->field->real_is_nullable())
+ min_max_arg_part->field->is_real_nullable())
{
/*
If a MIN/MAX argument value is NULL, we can quickly determine
@@ -13090,7 +13090,7 @@ print_key_value(String *out, const KEY_P
Field *field= key_part->field;
store_length= key_part->store_length;
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
/*
Byte 0 of key is the null-byte. If set, key is NULL.
@@ -13241,7 +13241,7 @@ print_multiple_key_values(KEY_PART *key_
Field *field= key_part->field;
store_length= key_part->store_length;
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
if (*key)
{
=== modified file 'sql/opt_sum.cc'
--- a/sql/opt_sum.cc 2012-05-11 08:55:35 +0000
+++ b/sql/opt_sum.cc 2012-05-15 15:47:14 +0000
@@ -160,7 +160,7 @@ static int get_index_min_value(TABLE *ta
Check if case 1 from above holds. If it does, we should read
the skipped tuple.
*/
- if (item_field->field->real_is_nullable() &&
+ if (item_field->field->is_real_nullable() &&
ref->key_buff[prefix_len] == 1 &&
/*
Last keypart (i.e. the argument to MIN) is set to NULL by
@@ -172,7 +172,7 @@ static int get_index_min_value(TABLE *ta
(error == HA_ERR_KEY_NOT_FOUND ||
key_cmp_if_same(table, ref->key_buff, ref->key, prefix_len)))
{
- DBUG_ASSERT(item_field->field->real_is_nullable());
+ DBUG_ASSERT(item_field->field->is_real_nullable());
error= table->file->ha_index_read_map(table->record[0],
ref->key_buff,
make_prev_keypart_map(ref->key_parts),
@@ -803,7 +803,7 @@ static bool matching_cond(bool max_fl, T
If we have a non-nullable index, we cannot use it,
since set_null will be ignored, and we will compare uninitialized data.
*/
- if (!part->field->real_is_nullable())
+ if (!part->field->is_real_nullable())
DBUG_RETURN(false);
part->field->set_null();
*key_ptr= (uchar) 1;
=== modified file 'sql/sql_optimizer.cc'
--- a/sql/sql_optimizer.cc 2012-05-11 08:55:35 +0000
+++ b/sql/sql_optimizer.cc 2012-05-15 15:47:14 +0000
@@ -4563,7 +4563,7 @@ add_key_field(KEY_FIELD **key_fields,uin
{
// Don't remove column IS NULL on a LEFT JOIN table
if (!eq_func || (*value)->type() != Item::NULL_ITEM ||
- !field->table->maybe_null || field->real_is_nullable())
+ !field->table->maybe_null || field->is_real_nullable())
return; // Not a key. Skip it
exists_optimize= KEY_OPTIMIZE_EXISTS;
DBUG_ASSERT(num_values == 1);
@@ -4583,7 +4583,7 @@ add_key_field(KEY_FIELD **key_fields,uin
if (!(usable_tables & field->table->map))
{
if (!eq_func || (*value)->type() != Item::NULL_ITEM ||
- !field->table->maybe_null || field->real_is_nullable())
+ !field->table->maybe_null || field->is_real_nullable())
return; // Can't use left join optimize
exists_optimize= KEY_OPTIMIZE_EXISTS;
}
@@ -5487,7 +5487,7 @@ update_ref_and_keys(THD *thd, Key_use_ar
{
/* Mark that we can optimize LEFT JOIN */
if (fld->val->type() == Item::NULL_ITEM &&
- !fld->field->real_is_nullable())
+ !fld->field->is_real_nullable())
{
/*
Example:
@@ -8413,7 +8413,7 @@ list_contains_unique_index(JOIN_TAB *tab
key_part < key_part_end;
key_part++)
{
- if (key_part->field->real_is_nullable() ||
+ if (key_part->field->is_real_nullable() ||
!find_func(key_part->field, data))
break;
}
=== modified file 'sql/sql_partition.cc'
--- a/sql/sql_partition.cc 2012-05-11 08:55:35 +0000
+++ b/sql/sql_partition.cc 2012-05-15 15:47:14 +0000
@@ -7416,7 +7416,7 @@ uint32 store_tuple_to_record(Field **pfi
while (value < value_end)
{
loc_value= value;
- if ((*pfield)->real_is_nullable())
+ if ((*pfield)->is_real_nullable())
{
if (*loc_value)
(*pfield)->set_null();
@@ -7733,7 +7733,7 @@ int get_part_iter_for_interval_via_mappi
Find minimum: Do special handling if the interval has left bound in form
" NULL <= X ":
*/
- if (field->real_is_nullable() && part_info->has_null_value &&
+ if (field->is_real_nullable() && part_info->has_null_value &&
!(flags & (NO_MIN_RANGE | NEAR_MIN)) && *min_value)
{
part_iter->ret_null_part= part_iter->ret_null_part_orig= TRUE;
@@ -7864,7 +7864,7 @@ int get_part_iter_for_interval_via_walki
}
/* Handle the "t.field IS NULL" interval, it is a special case */
- if (field->real_is_nullable() && !(flags & (NO_MIN_RANGE | NO_MAX_RANGE)) &&
+ if (field->is_real_nullable() && !(flags & (NO_MIN_RANGE | NO_MAX_RANGE)) &&
*min_value && *max_value)
{
/*
@@ -7898,7 +7898,7 @@ int get_part_iter_for_interval_via_walki
DBUG_RETURN(0); /* No partitions match */
}
- if ((field->real_is_nullable() &&
+ if ((field->is_real_nullable() &&
((!(flags & NO_MIN_RANGE) && *min_value) || // NULL <? X
(!(flags & NO_MAX_RANGE) && *max_value))) || // X <? NULL
(flags & (NO_MIN_RANGE | NO_MAX_RANGE))) // -inf at any bound
@@ -8177,7 +8177,7 @@ uint get_partition_field_store_length(Fi
uint store_length;
store_length= field->key_length();
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
store_length+= HA_KEY_NULL_LENGTH;
if (field->real_type() == MYSQL_TYPE_VARCHAR)
store_length+= HA_KEY_BLOB_LENGTH;
=== modified file 'sql/sql_select.cc'
--- a/sql/sql_select.cc 2012-05-11 08:55:35 +0000
+++ b/sql/sql_select.cc 2012-05-15 15:47:14 +0000
@@ -1132,7 +1132,7 @@ void calc_used_field_length(THD *thd, JO
rec_length+=field->pack_length();
if (flags & BLOB_FLAG)
blobs++;
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
null_fields++;
if (field->type() == MYSQL_TYPE_BIT &&
((Field_bit*)field)->bit_len)
@@ -2480,7 +2480,7 @@ bool setup_sj_materialization(JOIN_TAB *
part_no++, cur_key_part++, ref_key++)
{
tab_ref->items[part_no]= outer_expr++;
- int null_count= test(cur_key_part->field->real_is_nullable());
+ int null_count= test(cur_key_part->field->is_real_nullable());
*ref_key= new store_key_item(thd, cur_key_part->field,
/* TODO:
the NULL byte is taken into account in
=== modified file 'sql/sql_select.h'
--- a/sql/sql_select.h 2012-05-11 08:55:35 +0000
+++ b/sql/sql_select.h 2012-05-15 12:39:41 +0000
@@ -969,14 +969,14 @@ public:
Key segments are always packed with a 2 byte length prefix.
See mi_rkey for details.
*/
- to_field= new Field_varstring(ptr, length, 2, null, 1, null != NULL,
+ to_field= new Field_varstring(ptr, length, 2, null, 1,
Field::NONE, field_arg->field_name,
field_arg->table->s, field_arg->charset());
to_field->init(field_arg->table);
}
else
to_field=field_arg->new_key_field(thd->mem_root, field_arg->table,
- ptr, null, 1, null != NULL);
+ ptr, null, 1);
}
virtual ~store_key() {} /** Not actually needed */
virtual const char *name() const=0;
=== modified file 'sql/sql_show.cc'
--- a/sql/sql_show.cc 2012-05-11 08:55:35 +0000
+++ b/sql/sql_show.cc 2012-05-15 15:47:14 +0000
@@ -1530,7 +1530,7 @@ int store_create_info(THD *thd, TABLE_LI
}
}
- if (!field->real_is_nullable())
+ if (!field->is_real_nullable())
packet->append(STRING_WITH_LEN(" NOT NULL"));
else if (field->type() == MYSQL_TYPE_TIMESTAMP)
{
@@ -4691,7 +4691,7 @@ static int get_schema_column_record(THD
cs);
table->field[IS_COLUMNS_COLUMN_DEFAULT]->set_notnull();
}
- pos=(uchar*) ((!field->real_is_nullable()) ? "NO" : "YES");
+ pos=(uchar*) ((!field->is_real_nullable()) ? "NO" : "YES");
table->field[IS_COLUMNS_IS_NULLABLE]->store((const char*) pos,
strlen((const char*) pos), cs);
store_column_type(table, field, cs, IS_COLUMNS_DATA_TYPE);
@@ -5367,7 +5367,7 @@ static int get_schema_stat_record(THD *t
key_part->field->charset()->mbmaxlen, TRUE);
table->field[10]->set_notnull();
}
- const char *pos=(key_part->field ? (key_part->field->real_is_nullable() ? "YES" : "")
+ const char *pos=(key_part->field ? (key_part->field->is_real_nullable() ? "YES" : "")
: "YES");
table->field[12]->store(pos, strlen(pos), cs);
if (!show_table->s->keys_in_use.is_set(i))
=== modified file 'sql/sql_tmp_table.cc'
--- a/sql/sql_tmp_table.cc 2012-05-11 08:55:35 +0000
+++ b/sql/sql_tmp_table.cc 2012-05-15 12:39:41 +0000
@@ -1036,8 +1036,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARA
group_buff +
test(maybe_null),
field->null_ptr,
- field->null_bit,
- maybe_null)))
+ field->null_bit)))
goto err; /* purecov: inspected */
if (maybe_null)
{
@@ -1110,7 +1109,6 @@ create_tmp_table(THD *thd,TMP_TABLE_PARA
(uint32) key_part_info->length,
(uchar*) 0,
(uint) 0,
- true,
Field::NONE,
NullS, &my_charset_bin);
if (!key_part_info->field)
@@ -1424,7 +1422,7 @@ TABLE *create_duplicate_weedout_tmp_tabl
if (!(key_field= field->new_key_field(thd->mem_root, table,
group_buff,
field->null_ptr,
- field->null_bit, true)))
+ field->null_bit)))
goto err;
key_part_info->key_part_flag|= HA_END_SPACE_ARE_EQUAL; //todo need this?
}
=== modified file 'sql/sql_update.cc'
--- a/sql/sql_update.cc 2012-05-11 08:55:35 +0000
+++ b/sql/sql_update.cc 2012-05-15 15:47:14 +0000
@@ -86,7 +86,7 @@ bool compare_records(const TABLE *table)
Field *field= *ptr;
if (bitmap_is_set(table->write_set, field->field_index))
{
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
uchar null_byte_index= field->null_ptr - table->record[0];
=== modified file 'sql/table.cc'
--- a/sql/table.cc 2012-05-11 08:55:35 +0000
+++ b/sql/table.cc 2012-05-15 15:47:14 +0000
@@ -791,7 +791,7 @@ void KEY_PART_INFO::init_from_field(Fiel
store_length= length;
key_part_flag= 0;
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
store_length+= HA_KEY_NULL_LENGTH;
if (field->type() == MYSQL_TYPE_BLOB ||
field->real_type() == MYSQL_TYPE_VARCHAR ||
@@ -1616,7 +1616,7 @@ static int open_binary_frm(THD *thd, TAB
{
uint fieldnr= key_part[i].fieldnr;
if (!fieldnr ||
- share->field[fieldnr-1]->real_is_nullable() ||
+ share->field[fieldnr-1]->is_real_nullable() ||
share->field[fieldnr-1]->key_length() !=
key_part[i].length)
{
@@ -1641,7 +1641,7 @@ static int open_binary_frm(THD *thd, TAB
}
field= key_part->field= share->field[key_part->fieldnr-1];
key_part->type= field->key_type();
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
key_part->null_offset=(uint) ((uchar*) field->null_ptr -
share->default_values);
=== modified file 'storage/csv/ha_tina.cc'
--- a/storage/csv/ha_tina.cc 2012-05-11 08:55:35 +0000
+++ b/storage/csv/ha_tina.cc 2012-05-15 15:47:14 +0000
@@ -1658,7 +1658,7 @@ int ha_tina::create(const char *name, TA
*/
for (Field **field= table_arg->s->field; *field; field++)
{
- if ((*field)->real_is_nullable())
+ if ((*field)->is_real_nullable())
{
my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "nullable columns");
DBUG_RETURN(HA_ERR_UNSUPPORTED);
=== modified file 'storage/federated/ha_federated.cc'
--- a/storage/federated/ha_federated.cc 2012-05-11 08:55:35 +0000
+++ b/storage/federated/ha_federated.cc 2012-05-15 15:47:14 +0000
@@ -1722,7 +1722,7 @@ static inline uint field_in_record_is_nu
int null_offset;
DBUG_ENTER("ha_federated::field_in_record_is_null");
- if (!field->real_is_nullable())
+ if (!field->is_real_nullable())
DBUG_RETURN(0);
null_offset= (uint) ((char*)field->null_ptr - (char*)table->record[0]);
=== modified file 'storage/heap/ha_heap.cc'
--- a/storage/heap/ha_heap.cc 2012-05-11 08:55:35 +0000
+++ b/storage/heap/ha_heap.cc 2012-05-15 15:47:14 +0000
@@ -703,7 +703,7 @@ heap_prepare_hp_create_info(TABLE *table
seg->charset= &my_charset_bin;
else
seg->charset= field->charset_for_protocol();
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
seg->null_bit= field->null_bit;
seg->null_pos= (uint) (field->null_ptr - (uchar*) table_arg->record[0]);
=== modified file 'storage/innobase/handler/ha_innodb.cc'
--- a/storage/innobase/handler/ha_innodb.cc 2012-05-11 08:55:35 +0000
+++ b/storage/innobase/handler/ha_innodb.cc 2012-05-15 15:47:14 +0000
@@ -4844,7 +4844,7 @@ field_in_record_is_null(
{
int null_offset;
- if (!field->real_is_nullable()) {
+ if (!field->is_real_nullable()) {
return(0);
}
@@ -5779,7 +5779,7 @@ build_template_field(
templ->rec_field_no = dict_index_get_nth_col_pos(index, i);
}
- if (field->real_is_nullable()) {
+ if (field->is_real_nullable()) {
templ->mysql_null_byte_offset =
(ulint) ((char*) field->null_ptr
- (char*) table->record[0]);
@@ -6571,7 +6571,7 @@ calc_row_difference(
}
- if (field->real_is_nullable()) {
+ if (field->is_real_nullable()) {
if (field_in_record_is_null(table, field,
(char*) old_row)) {
o_len = UNIV_SQL_NULL;
@@ -8033,7 +8033,7 @@ create_table_check_doc_id_col(
/* Note the name is case sensitive due to
our internal query parser */
if (col_type == DATA_INT
- && !field->real_is_nullable()
+ && !field->is_real_nullable()
&& col_len == sizeof(doc_id_t)
&& (strcmp(field->field_name,
FTS_DOC_ID_COL_NAME) == 0)) {
@@ -8184,7 +8184,7 @@ create_table_def(
goto err_col;
}
- nulls_allowed = field->real_is_nullable() ? 0 : DATA_NOT_NULL;
+ nulls_allowed = field->is_real_nullable() ? 0 : DATA_NOT_NULL;
binary_type = field->binary() ? DATA_BINARY_TYPE : 0;
charset_no = 0;
=== modified file 'storage/innobase/handler/handler0alter.cc'
--- a/storage/innobase/handler/handler0alter.cc 2012-05-11 08:55:35 +0000
+++ b/storage/innobase/handler/handler0alter.cc 2012-05-15 15:47:14 +0000
@@ -235,7 +235,7 @@ ha_innobase::check_if_supported_inplace_
prebuilt->table, key_part->fieldnr);
if (!(col->prtype & DATA_NOT_NULL)
- != !!key_part->field->real_is_nullable()) {
+ != !!key_part->field->is_real_nullable()) {
sql_print_warning(
"InnoDB table '%s' column '%s' "
"attributes differ from "
@@ -417,7 +417,7 @@ null_field:
/* Assign the NULL flag */
if (ilen == UNIV_SQL_NULL) {
- ut_ad(field->real_is_nullable());
+ ut_ad(field->is_real_nullable());
goto null_field;
}
@@ -759,7 +759,7 @@ innobase_fts_check_doc_id_col(
field->field_name);
} else if (field->type() != MYSQL_TYPE_LONGLONG
|| field->pack_length() != 8
- || field->real_is_nullable()
+ || field->is_real_nullable()
|| !(field->flags & UNSIGNED_FLAG)) {
my_error(ER_INNODB_FT_WRONG_DOCID_COLUMN, MYF(0),
field->field_name);
@@ -1529,7 +1529,7 @@ col_fail:
fits in two bytes */
ut_a(field_type <= MAX_CHAR_COLL_NUM);
- if (!field->real_is_nullable()) {
+ if (!field->is_real_nullable()) {
field_type |= DATA_NOT_NULL;
}
=== modified file 'storage/myisam/ha_myisam.cc'
--- a/storage/myisam/ha_myisam.cc 2012-05-11 08:55:35 +0000
+++ b/storage/myisam/ha_myisam.cc 2012-05-15 15:47:14 +0000
@@ -285,7 +285,7 @@ int table2myisam(TABLE *table_arg, MI_KE
keydef[i].seg[j].bit_pos= 0;
keydef[i].seg[j].language= field->charset_for_protocol()->number;
- if (field->real_is_nullable())
+ if (field->is_real_nullable())
{
keydef[i].seg[j].null_bit= field->null_bit;
keydef[i].seg[j].null_pos= (uint) (field->null_ptr-
@@ -369,7 +369,7 @@ int table2myisam(TABLE *table_arg, MI_KE
found->type() == MYSQL_TYPE_VAR_STRING ?
FIELD_SKIP_ENDSPACE :
FIELD_SKIP_PRESPACE);
- if (found->real_is_nullable())
+ if (found->is_real_nullable())
{
recinfo_pos->null_bit= found->null_bit;
recinfo_pos->null_pos= (uint) (found->null_ptr -
No bundle (reason: useless for push emails).
| Thread |
|---|
| • bzr push into mysql-trunk branch (Dmitry.Shulga:3785 to 3788) WL#6030 | Dmitry Shulga | 16 May |
