The world's most popular open source database

MySQL 5.1: create_field Class Reference

create_field Class Reference

#include <field.h>

Inheritance diagram for create_field:

[legend]Collaboration diagram for create_field:

[legend]List of all members.


Public Member Functions
	create_field ()
	create_field (Field field, Field orig_field)
void	create_length_to_internal_length (void)
void	init_for_tmp_table (enum_field_types sql_type_arg, uint32 max_length, uint32 decimals, bool maybe_null, bool is_unsigned)
bool	init (THD thd, char field_name, enum_field_types type, char length, char decimals, uint type_modifier, Item default_value, Item on_update_value, LEX_STRING comment, char change, List< String > interval_list, CHARSET_INFO cs, uint uint_geom_type)
Public Attributes
const char *	field_name
const char *	change
const char *	after
LEX_STRING	comment
Item *	def
enum enum_field_types	sql_type
ulong	length
uint32	char_length
uint	decimals
uint	flags
uint	pack_length
uint	key_length
Field::utype	unireg_check
TYPELIB *	interval
List< String >	interval_list
CHARSET_INFO *	charset
Field::geometry_type	geom_type
Field *	field
uint8	row
uint8	col
uint8	sc_length
uint8	interval_id
uint	offset
uint	pack_flag

Detailed Description

Definition at line 1457 of file field.h.

Constructor & Destructor Documentation

create_field::create_field ( ) [inline]

Definition at line 1486 of file field.h.

01486 :after(0) {}

create_field::create_field	(	Field *	field,
		Field *	orig_field
	)

Definition at line 9083 of file field.cc.

References BLOB_FLAG, st_table_share::blob_ptr_size, change, char_length, Field::charset(), charset, Field::comment, comment, Field::decimals(), decimals, def, st_table_share::default_values, ENUM_FLAG, field, Field::field_length, Field::field_name, field_name, FIELD_TYPE_BLOB, FIELD_TYPE_GEOMETRY, FIELD_TYPE_LONG_BLOB, FIELD_TYPE_MEDIUM_BLOB, FIELD_TYPE_TIMESTAMP, FIELD_TYPE_TINY_BLOB, Field::flags, flags, geom_type, HAVE_SPATIAL, interval, Field::is_real_null(), Field::key_length(), key_length, String::length(), MAX_FIELD_WIDTH, charset_info_st::mbmaxlen, Field::move_field_offset(), MYSQL_TYPE_ENUM, MYSQL_TYPE_SET, MYSQL_TYPE_STRING, MYSQL_TYPE_VAR_STRING, MYSQL_TYPE_VARCHAR, NO_DEFAULT_VALUE_FLAG, Field::pack_length(), pack_length, portable_sizeof_char_ptr, String::ptr(), Field::ptr, Field::real_type(), st_table::record, st_table::s, SET_FLAG, sql_strmake(), sql_type, Field::table, st_table::timestamp_field, Field::TIMESTAMP_UN_FIELD, Field::type(), Field::unireg_check, unireg_check, and Field::val_str().

09084 {
09085   field=      old_field;
09086   field_name=change=old_field->field_name;
09087   length=     old_field->field_length;
09088   flags=      old_field->flags;
09089   unireg_check=old_field->unireg_check;
09090   pack_length=old_field->pack_length();
09091   key_length= old_field->key_length();
09092   sql_type=   old_field->real_type();
09093   charset=    old_field->charset();             // May be NULL ptr
09094   comment=    old_field->comment;
09095   decimals=   old_field->decimals();
09096 
09097   /* Fix if the original table had 4 byte pointer blobs */
09098   if (flags & BLOB_FLAG)
09099     pack_length= (pack_length- old_field->table->s->blob_ptr_size +
09100                   portable_sizeof_char_ptr);
09101 
09102   switch (sql_type) {
09103   case FIELD_TYPE_BLOB:
09104     switch (pack_length - portable_sizeof_char_ptr) {
09105     case  1: sql_type= FIELD_TYPE_TINY_BLOB; break;
09106     case  2: sql_type= FIELD_TYPE_BLOB; break;
09107     case  3: sql_type= FIELD_TYPE_MEDIUM_BLOB; break;
09108     default: sql_type= FIELD_TYPE_LONG_BLOB; break;
09109     }
09110     length=(length+charset->mbmaxlen-1) / charset->mbmaxlen;
09111     key_length/= charset->mbmaxlen;
09112     break;
09113   case MYSQL_TYPE_STRING:
09114     /* Change CHAR -> VARCHAR if dynamic record length */
09115     if (old_field->type() == MYSQL_TYPE_VAR_STRING)
09116       sql_type= MYSQL_TYPE_VARCHAR;
09117     /* fall through */
09118 
09119   case MYSQL_TYPE_ENUM:
09120   case MYSQL_TYPE_SET:
09121   case MYSQL_TYPE_VARCHAR:
09122   case MYSQL_TYPE_VAR_STRING:
09123     /* This is corrected in create_length_to_internal_length */
09124     length= (length+charset->mbmaxlen-1) / charset->mbmaxlen;
09125     break;
09126 #ifdef HAVE_SPATIAL
09127   case FIELD_TYPE_GEOMETRY:
09128     geom_type= ((Field_geom*)old_field)->geom_type;
09129     break;
09130 #endif
09131   default:
09132     break;
09133   }
09134 
09135   if (flags & (ENUM_FLAG | SET_FLAG))
09136     interval= ((Field_enum*) old_field)->typelib;
09137   else
09138     interval=0;
09139   def=0;
09140   char_length= length;
09141 
09142   if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) &&
09143       old_field->ptr && orig_field &&
09144       (sql_type != FIELD_TYPE_TIMESTAMP ||                /* set def only if */
09145        old_field->table->timestamp_field != old_field ||  /* timestamp field */ 
09146        unireg_check == Field::TIMESTAMP_UN_FIELD))        /* has default val */
09147   {
09148     char buff[MAX_FIELD_WIDTH],*pos;
09149     String tmp(buff,sizeof(buff), charset), *res;
09150     my_ptrdiff_t diff;
09151     bool is_null;
09152 
09153     /* Get the value from default_values */
09154     diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
09155                           orig_field->table->record[0]);
09156     orig_field->move_field_offset(diff);        // Points now at default_values
09157     if (!orig_field->is_real_null())
09158     {
09159       char buff[MAX_FIELD_WIDTH], *pos;
09160       String tmp(buff, sizeof(buff), charset), *res;
09161       res= orig_field->val_str(&tmp);
09162       pos= (char*) sql_strmake(res->ptr(), res->length());
09163       def= new Item_string(pos, res->length(), charset);
09164     }
09165     orig_field->move_field_offset(-diff);       // Back to record[0]
09166   }
09167 }

Here is the call graph for this function:

Member Function Documentation

void create_field::create_length_to_internal_length ( void )

Definition at line 8406 of file field.cc.

References calc_pack_length(), charset, decimals, f_bit_as_char, flags, key_length, charset_info_st::mbmaxlen, my_decimal_get_binary_size(), my_decimal_length_to_precision(), MYSQL_TYPE_BIT, MYSQL_TYPE_BLOB, MYSQL_TYPE_ENUM, MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_NEWDECIMAL, MYSQL_TYPE_SET, MYSQL_TYPE_STRING, MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_VAR_STRING, MYSQL_TYPE_VARCHAR, pack_flag, pack_length, sql_type, test, and UNSIGNED_FLAG.

Referenced by mysql_prepare_table(), and sp_prepare_create_field().

08407 {
08408   switch (sql_type) {
08409   case MYSQL_TYPE_TINY_BLOB:
08410   case MYSQL_TYPE_MEDIUM_BLOB:
08411   case MYSQL_TYPE_LONG_BLOB:
08412   case MYSQL_TYPE_BLOB:
08413   case MYSQL_TYPE_VAR_STRING:
08414   case MYSQL_TYPE_STRING:
08415   case MYSQL_TYPE_VARCHAR:
08416     length*= charset->mbmaxlen;
08417     key_length= length;
08418     pack_length= calc_pack_length(sql_type, length);
08419     break;
08420   case MYSQL_TYPE_ENUM:
08421   case MYSQL_TYPE_SET:
08422     /* Pack_length already calculated in sql_parse.cc */
08423     length*= charset->mbmaxlen;
08424     key_length= pack_length;
08425     break;
08426   case MYSQL_TYPE_BIT:
08427     if (f_bit_as_char(pack_flag))
08428     {
08429       key_length= pack_length= ((length + 7) & ~7) / 8;
08430     }
08431     else
08432     {
08433       pack_length= length / 8;
08434       /* We need one extra byte to store the bits we save among the null bits */
08435       key_length= pack_length + test(length & 7);
08436     }
08437     break;
08438   case MYSQL_TYPE_NEWDECIMAL:
08439     key_length= pack_length=
08440       my_decimal_get_binary_size(my_decimal_length_to_precision(length,
08441                                                                 decimals,
08442                                                                 flags &
08443                                                                 UNSIGNED_FLAG),
08444                                  decimals);
08445     break;
08446   default:
08447     key_length= pack_length= calc_pack_length(sql_type, length);
08448     break;
08449   }
08450 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool create_field::init	(	THD *	thd,
		char *	field_name,
		enum_field_types	type,
		char *	length,
		char *	decimals,
		uint	type_modifier,
		Item *	default_value,
		Item *	on_update_value,
		LEX_STRING *	comment,
		char *	change,
		List< String > *	interval_list,
		CHARSET_INFO *	cs,
		uint	uint_geom_type
	)

Definition at line 8494 of file field.cc.

References atoi(), AUTO_INCREMENT_FLAG, BLOB_FLAG, change, char_length, charset, comment, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, DECIMAL_MAX_PRECISION, decimals, def, base_list::elements, base_list::empty(), ER, ER_BLOB_CANT_HAVE_DEFAULT, ER_M_BIGGER_THAN_D, ER_TOO_BIG_DISPLAYWIDTH, ER_TOO_BIG_FIELDLENGTH, ER_TOO_BIG_PRECISION, ER_TOO_BIG_SCALE, ER_TOO_BIG_SET, ER_WRONG_FIELD_SPEC, FALSE, field, field_name, FIELD_TYPE_BLOB, FIELD_TYPE_DATE, FIELD_TYPE_DATETIME, FIELD_TYPE_DECIMAL, FIELD_TYPE_DOUBLE, FIELD_TYPE_ENUM, FIELD_TYPE_FLOAT, FIELD_TYPE_GEOMETRY, FIELD_TYPE_INT24, FIELD_TYPE_LONG, FIELD_TYPE_LONG_BLOB, FIELD_TYPE_LONGLONG, FIELD_TYPE_MEDIUM_BLOB, FIELD_TYPE_NEWDATE, FIELD_TYPE_NEWDECIMAL, FIELD_TYPE_NULL, FIELD_TYPE_SET, FIELD_TYPE_SHORT, FIELD_TYPE_TIME, FIELD_TYPE_TIMESTAMP, FIELD_TYPE_TINY, FIELD_TYPE_TINY_BLOB, FIELD_TYPE_YEAR, flags, Item::FUNC_ITEM, geom_type, get_enum_pack_length(), get_set_pack_length(), interval, interval_list, key_length, String::length(), MAX_BIGINT_WIDTH, MAX_BIT_FIELD_LENGTH, MAX_FIELD_CHARLENGTH, MAX_FIELD_VARCHARLENGTH, MAX_INT_WIDTH, MAX_MEDIUMINT_WIDTH, MAX_SMALLINT_WIDTH, MAX_TINYINT_WIDTH, min, MODE_STRICT_ALL_TABLES, MODE_STRICT_TRANS_TABLES, my_decimal_get_binary_size(), my_decimal_precision_to_length(), my_error(), MYF, MYSQL_TYPE_BIT, MYSQL_TYPE_STRING, MYSQL_TYPE_VAR_STRING, MYSQL_TYPE_VARCHAR, Field::NEXT_NUMBER, NO_DEFAULT_VALUE_FLAG, Field::NONE, NOT_FIXED_DEC, NOT_NULL_FLAG, Item_func::NOW_FUNC, pack_length, PRECISION_FOR_DOUBLE, PRECISION_FOR_FLOAT, PROTOCOL_VERSION, protocol_version, List< T >::push_back(), push_warning_printf(), sql_type, Field::TIMESTAMP_DN_FIELD, Field::TIMESTAMP_DNUN_FIELD, Field::TIMESTAMP_OLD_FIELD, Field::TIMESTAMP_UN_FIELD, TRUE, Item::type(), unireg_check, UNSIGNED_FLAG, Item::val_str(), MYSQL_ERROR::WARN_LEVEL_WARN, and ZEROFILL_FLAG.

Referenced by add_field_to_list(), and sp_head::fill_field_definition().

08500 {
08501   uint sign_len, allowed_type_modifier= 0;
08502   ulong max_field_charlength= MAX_FIELD_CHARLENGTH;
08503 
08504   DBUG_ENTER("create_field::init()");
08505   
08506   field= 0;
08507   field_name= fld_name;
08508   def= fld_default_value;
08509   flags= fld_type_modifier;
08510   unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
08511                  Field::NEXT_NUMBER : Field::NONE);
08512   decimals= fld_decimals ? (uint)atoi(fld_decimals) : 0;
08513   if (decimals >= NOT_FIXED_DEC)
08514   {
08515     my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
08516              NOT_FIXED_DEC-1);
08517     DBUG_RETURN(TRUE);
08518   }
08519 
08520   sql_type= fld_type;
08521   length= 0;
08522   change= fld_change;
08523   interval= 0;
08524   pack_length= key_length= 0;
08525   charset= fld_charset;
08526   geom_type= (Field::geometry_type) fld_geom_type;
08527   interval_list.empty();
08528 
08529   comment= *fld_comment;
08530   /*
08531     Set NO_DEFAULT_VALUE_FLAG if this field doesn't have a default value and
08532     it is NOT NULL, not an AUTO_INCREMENT field and not a TIMESTAMP.
08533   */
08534   if (!fld_default_value && !(fld_type_modifier & AUTO_INCREMENT_FLAG) &&
08535       (fld_type_modifier & NOT_NULL_FLAG) && fld_type != FIELD_TYPE_TIMESTAMP)
08536     flags|= NO_DEFAULT_VALUE_FLAG;
08537 
08538   if (fld_length && !(length= (uint) atoi(fld_length)))
08539     fld_length= 0; /* purecov: inspected */
08540   sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;
08541 
08542   switch (fld_type) {
08543   case FIELD_TYPE_TINY:
08544     if (!fld_length)
08545       length= MAX_TINYINT_WIDTH+sign_len;
08546     allowed_type_modifier= AUTO_INCREMENT_FLAG;
08547     break;
08548   case FIELD_TYPE_SHORT:
08549     if (!fld_length)
08550       length= MAX_SMALLINT_WIDTH+sign_len;
08551     allowed_type_modifier= AUTO_INCREMENT_FLAG;
08552     break;
08553   case FIELD_TYPE_INT24:
08554     if (!fld_length)
08555       length= MAX_MEDIUMINT_WIDTH+sign_len;
08556     allowed_type_modifier= AUTO_INCREMENT_FLAG;
08557     break;
08558   case FIELD_TYPE_LONG:
08559     if (!fld_length)
08560       length= MAX_INT_WIDTH+sign_len;
08561     allowed_type_modifier= AUTO_INCREMENT_FLAG;
08562     break;
08563   case FIELD_TYPE_LONGLONG:
08564     if (!fld_length)
08565       length= MAX_BIGINT_WIDTH;
08566     allowed_type_modifier= AUTO_INCREMENT_FLAG;
08567     break;
08568   case FIELD_TYPE_NULL:
08569     break;
08570   case FIELD_TYPE_NEWDECIMAL:
08571     if (!fld_length && !decimals)
08572       length= 10;
08573     if (length > DECIMAL_MAX_PRECISION)
08574     {
08575       my_error(ER_TOO_BIG_PRECISION, MYF(0), length, fld_name,
08576                DECIMAL_MAX_PRECISION);
08577       DBUG_RETURN(TRUE);
08578     }
08579     if (length < decimals)
08580     {
08581       my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
08582       DBUG_RETURN(TRUE);
08583     }
08584     length=
08585       my_decimal_precision_to_length(length, decimals,
08586                                      fld_type_modifier & UNSIGNED_FLAG);
08587     pack_length=
08588       my_decimal_get_binary_size(length, decimals);
08589     break;
08590   case MYSQL_TYPE_VARCHAR:
08591     /*
08592       Long VARCHAR's are automaticly converted to blobs in mysql_prepare_table
08593       if they don't have a default value
08594     */
08595     max_field_charlength= MAX_FIELD_VARCHARLENGTH;
08596     break;
08597   case MYSQL_TYPE_STRING:
08598     break;
08599   case FIELD_TYPE_BLOB:
08600   case FIELD_TYPE_TINY_BLOB:
08601   case FIELD_TYPE_LONG_BLOB:
08602   case FIELD_TYPE_MEDIUM_BLOB:
08603   case FIELD_TYPE_GEOMETRY:
08604     if (fld_default_value)
08605     {
08606       /* Allow empty as default value. */
08607       String str,*res;
08608       res= fld_default_value->val_str(&str);
08609       /*
08610         A default other than '' is always an error, and any non-NULL
08611         specified default is an error in strict mode.
08612       */
08613       if (res->length() || (thd->variables.sql_mode &
08614                             (MODE_STRICT_TRANS_TABLES |
08615                              MODE_STRICT_ALL_TABLES)))
08616       {
08617         my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
08618                  fld_name); /* purecov: inspected */
08619         DBUG_RETURN(TRUE);
08620       }
08621       else
08622       {
08623         /*
08624           Otherwise a default of '' is just a warning.
08625         */
08626         push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
08627                             ER_BLOB_CANT_HAVE_DEFAULT,
08628                             ER(ER_BLOB_CANT_HAVE_DEFAULT),
08629                             fld_name);
08630       }
08631       def= 0;
08632     }
08633     flags|= BLOB_FLAG;
08634     break;
08635   case FIELD_TYPE_YEAR:
08636     if (!fld_length || length != 2)
08637       length= 4; /* Default length */
08638     flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
08639     break;
08640   case FIELD_TYPE_FLOAT:
08641     /* change FLOAT(precision) to FLOAT or DOUBLE */
08642     allowed_type_modifier= AUTO_INCREMENT_FLAG;
08643     if (fld_length && !fld_decimals)
08644     {
08645       uint tmp_length= length;
08646       if (tmp_length > PRECISION_FOR_DOUBLE)
08647       {
08648         my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
08649         DBUG_RETURN(TRUE);
08650       }
08651       else if (tmp_length > PRECISION_FOR_FLOAT)
08652       {
08653         sql_type= FIELD_TYPE_DOUBLE;
08654         length= DBL_DIG+7; /* -[digits].E+### */
08655       }
08656       else
08657         length= FLT_DIG+6; /* -[digits].E+## */
08658       decimals= NOT_FIXED_DEC;
08659       break;
08660     }
08661     if (!fld_length && !fld_decimals)
08662     {
08663       length=  FLT_DIG+6;
08664       decimals= NOT_FIXED_DEC;
08665     }
08666     if (length < decimals &&
08667         decimals != NOT_FIXED_DEC)
08668     {
08669       my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
08670       DBUG_RETURN(TRUE);
08671     }
08672     break;
08673   case FIELD_TYPE_DOUBLE:
08674     allowed_type_modifier= AUTO_INCREMENT_FLAG;
08675     if (!fld_length && !fld_decimals)
08676     {
08677       length= DBL_DIG+7;
08678       decimals= NOT_FIXED_DEC;
08679     }
08680     if (length < decimals &&
08681         decimals != NOT_FIXED_DEC)
08682     {
08683       my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
08684       DBUG_RETURN(TRUE);
08685     }
08686     break;
08687   case FIELD_TYPE_TIMESTAMP:
08688     if (!fld_length)
08689       length= 14;  /* Full date YYYYMMDDHHMMSS */
08690     else if (length != 19)
08691     {
08692       /*
08693         We support only even TIMESTAMP lengths less or equal than 14
08694         and 19 as length of 4.1 compatible representation.
08695       */
08696       length= ((length+1)/2)*2; /* purecov: inspected */
08697       length= min(length,14); /* purecov: inspected */
08698     }
08699     flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
08700     if (fld_default_value)
08701     {
08702       /* Grammar allows only NOW() value for ON UPDATE clause */
08703       if (fld_default_value->type() == Item::FUNC_ITEM && 
08704           ((Item_func*)fld_default_value)->functype() == Item_func::NOW_FUNC)
08705       {
08706         unireg_check= (fld_on_update_value ? Field::TIMESTAMP_DNUN_FIELD:
08707                                              Field::TIMESTAMP_DN_FIELD);
08708         /*
08709           We don't need default value any longer moreover it is dangerous.
08710           Everything handled by unireg_check further.
08711         */
08712         def= 0;
08713       }
08714       else
08715         unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD:
08716                                              Field::NONE);
08717     }
08718     else
08719     {
08720       /*
08721         If we have default TIMESTAMP NOT NULL column without explicit DEFAULT
08722         or ON UPDATE values then for the sake of compatiblity we should treat
08723         this column as having DEFAULT NOW() ON UPDATE NOW() (when we don't
08724         have another TIMESTAMP column with auto-set option before this one)
08725         or DEFAULT 0 (in other cases).
08726         So here we are setting TIMESTAMP_OLD_FIELD only temporary, and will
08727         replace this value by TIMESTAMP_DNUN_FIELD or NONE later when
08728         information about all TIMESTAMP fields in table will be availiable.
08729 
08730         If we have TIMESTAMP NULL column without explicit DEFAULT value
08731         we treat it as having DEFAULT NULL attribute.
08732       */
08733       unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD :
08734                      (flags & NOT_NULL_FLAG ? Field::TIMESTAMP_OLD_FIELD :
08735                                               Field::NONE));
08736     }
08737     break;
08738   case FIELD_TYPE_DATE:
08739     /* Old date type. */
08740     if (protocol_version != PROTOCOL_VERSION-1)
08741       sql_type= FIELD_TYPE_NEWDATE;
08742     /* fall trough */
08743   case FIELD_TYPE_NEWDATE:
08744     length= 10;
08745     break;
08746   case FIELD_TYPE_TIME:
08747     length= 10;
08748     break;
08749   case FIELD_TYPE_DATETIME:
08750     length= 19;
08751     break;
08752   case FIELD_TYPE_SET:
08753     {
08754       if (fld_interval_list->elements > sizeof(longlong)*8)
08755       {
08756         my_error(ER_TOO_BIG_SET, MYF(0), fld_name); /* purecov: inspected */
08757         DBUG_RETURN(TRUE);
08758       }
08759       pack_length= get_set_pack_length(fld_interval_list->elements);
08760 
08761       List_iterator<String> it(*fld_interval_list);
08762       String *tmp;
08763       while ((tmp= it++))
08764         interval_list.push_back(tmp);
08765       /*
08766         Set fake length to 1 to pass the below conditions.
08767         Real length will be set in mysql_prepare_table()
08768         when we know the character set of the column
08769       */
08770       length= 1;
08771       break;
08772     }
08773   case FIELD_TYPE_ENUM:
08774     {
08775       /* Should be safe. */
08776       pack_length= get_enum_pack_length(fld_interval_list->elements);
08777 
08778       List_iterator<String> it(*fld_interval_list);
08779       String *tmp;
08780       while ((tmp= it++))
08781         interval_list.push_back(tmp);
08782       length= 1; /* See comment for FIELD_TYPE_SET above. */
08783       break;
08784    }
08785   case MYSQL_TYPE_VAR_STRING:
08786     DBUG_ASSERT(0);  /* Impossible. */
08787     break;
08788   case MYSQL_TYPE_BIT:
08789     {
08790       if (!fld_length)
08791         length= 1;
08792       if (length > MAX_BIT_FIELD_LENGTH)
08793       {
08794         my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), fld_name,
08795                  MAX_BIT_FIELD_LENGTH);
08796         DBUG_RETURN(TRUE);
08797       }
08798       pack_length= (length + 7) / 8;
08799       break;
08800     }
08801   case FIELD_TYPE_DECIMAL:
08802     DBUG_ASSERT(0); /* Was obsolete */
08803   }
08804   /* Remember the value of length */
08805   char_length= length;
08806 
08807   if (!(flags & BLOB_FLAG) &&
08808       ((length > max_field_charlength && fld_type != FIELD_TYPE_SET &&
08809         fld_type != FIELD_TYPE_ENUM &&
08810         (fld_type != MYSQL_TYPE_VARCHAR || fld_default_value)) ||
08811        (!length &&
08812         fld_type != MYSQL_TYPE_STRING &&
08813         fld_type != MYSQL_TYPE_VARCHAR && fld_type != FIELD_TYPE_GEOMETRY)))
08814   {
08815     my_error((fld_type == MYSQL_TYPE_VAR_STRING ||
08816               fld_type == MYSQL_TYPE_VARCHAR ||
08817               fld_type == MYSQL_TYPE_STRING) ?  ER_TOO_BIG_FIELDLENGTH :
08818                                                 ER_TOO_BIG_DISPLAYWIDTH,
08819               MYF(0),
08820               fld_name, max_field_charlength); /* purecov: inspected */
08821     DBUG_RETURN(TRUE);
08822   }
08823   fld_type_modifier&= AUTO_INCREMENT_FLAG;
08824   if ((~allowed_type_modifier) & fld_type_modifier)
08825   {
08826     my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
08827     DBUG_RETURN(TRUE);
08828   }
08829 
08830   DBUG_RETURN(FALSE); /* success */
08831 }

Here is the call graph for this function:

Here is the caller graph for this function:

void create_field::init_for_tmp_table	(	enum_field_types	sql_type_arg,
		uint32	max_length,
		uint32	decimals,
		bool	maybe_null,
		bool	is_unsigned
	)

Definition at line 8453 of file field.cc.

References char_length, charset, field_name, FIELDFLAG_DEC_SHIFT, FIELDFLAG_DECIMAL, FIELDFLAG_MAX_DEC, FIELDFLAG_MAYBE_NULL, FIELDFLAG_NUMBER, Field::GEOM_GEOMETRY, geom_type, interval, Field::NONE, pack_flag, sql_type, and unireg_check.

Referenced by Item_sum_distinct::setup().

08456 {
08457   field_name= "";
08458   sql_type= sql_type_arg;
08459   char_length= length= length_arg;;
08460   unireg_check= Field::NONE;
08461   interval= 0;
08462   charset= &my_charset_bin;
08463   geom_type= Field::GEOM_GEOMETRY;
08464   pack_flag= (FIELDFLAG_NUMBER |
08465               ((decimals & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
08466               (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
08467               (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
08468 }