java.lang.Object
- java.lang.Enum<MysqlType>
- - com.mysql.cj.MysqlType

所有已实现的接口:: Serializable, Comparable<MysqlType>, SQLType

public enum MysqlType
extends Enum<MysqlType>
implements SQLType

枚举常量概要

枚举常量
枚举常量	说明
`BIGINT`	BIGINT[(M)] [UNSIGNED] [ZEROFILL] A large integer.
`BIGINT_UNSIGNED`	BIGINT[(M)] UNSIGNED [ZEROFILL]
`BINARY`	BINARY(M) The BINARY type is similar to the CHAR type, but stores binary byte strings rather than nonbinary character strings.
`BIT`	BIT[(M)] A bit-field type.
`BLOB`	BLOB[(M)] A BLOB column with a maximum length of 65,535 (216 - 1) bytes.
`BOOLEAN`	BOOL, BOOLEAN These types are synonyms for TINYINT(1).
`CHAR`	[NATIONAL] CHAR[(M)] [CHARACTER SET charset_name] [COLLATE collation_name] A fixed-length string that is always right-padded with spaces to the specified length when stored.
`DATE`	DATE A date.
`DATETIME`	DATETIME[(fsp)] A date and time combination.
`DECIMAL`	DECIMAL[(M[,D])] [UNSIGNED] [ZEROFILL] A packed "exact" fixed-point number.
`DECIMAL_UNSIGNED`	DECIMAL[(M[,D])] UNSIGNED [ZEROFILL]
`DOUBLE`	DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL] A normal-size (double-precision) floating-point number.
`DOUBLE_UNSIGNED`	DOUBLE[(M,D)] UNSIGNED [ZEROFILL]
`ENUM`	ENUM('value1','value2',...)
`FLOAT`	FLOAT[(M,D)] [UNSIGNED] [ZEROFILL] A small (single-precision) floating-point number.
`FLOAT_UNSIGNED`	FLOAT[(M,D)] UNSIGNED [ZEROFILL]
`GEOMETRY`	Top class for Spatial Data Types Protocol: FIELD_TYPE_GEOMETRY = 255
`INT`	INT[(M)] [UNSIGNED] [ZEROFILL] A normal-size integer.
`INT_UNSIGNED`	INT[(M)] UNSIGNED [ZEROFILL]
`JSON`	The size of JSON documents stored in JSON columns is limited to the value of the max_allowed_packet system variable (max value 1073741824).
`LONGBLOB`	LONGBLOB A BLOB column with a maximum length of 4,294,967,295 or 4GB (232 - 1) bytes.
`LONGTEXT`	LONGTEXT [CHARACTER SET charset_name] [COLLATE collation_name] A TEXT column with a maximum length of 4,294,967,295 or 4GB (232 - 1) characters.
`MEDIUMBLOB`	MEDIUMBLOB A BLOB column with a maximum length of 16,777,215 (224 - 1) bytes.
`MEDIUMINT`	MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL] A medium-sized integer.
`MEDIUMINT_UNSIGNED`	MEDIUMINT[(M)] UNSIGNED [ZEROFILL]
`MEDIUMTEXT`	MEDIUMTEXT [CHARACTER SET charset_name] [COLLATE collation_name] A TEXT column with a maximum length of 16,777,215 (224 - 1) characters.
`NULL`	FIELD_TYPE_NULL = 6
`SET`	SET('value1','value2',...)
`SMALLINT`	SMALLINT[(M)] [UNSIGNED] [ZEROFILL] A small integer.
`SMALLINT_UNSIGNED`	SMALLINT[(M)] UNSIGNED [ZEROFILL]
`TEXT`	TEXT[(M)] [CHARACTER SET charset_name] [COLLATE collation_name] A TEXT column with a maximum length of 65,535 (216 - 1) characters.
`TIME`	TIME[(fsp)] A time.
`TIMESTAMP`	TIMESTAMP[(fsp)] A timestamp.
`TINYBLOB`	TINYBLOB A BLOB column with a maximum length of 255 (28 - 1) bytes.
`TINYINT`	TINYINT[(M)] [UNSIGNED] [ZEROFILL] A very small integer.
`TINYINT_UNSIGNED`	TINYINT[(M)] UNSIGNED [ZEROFILL]
`TINYTEXT`	TINYTEXT [CHARACTER SET charset_name] [COLLATE collation_name] A TEXT column with a maximum length of 255 (28 - 1) characters.
`UNKNOWN`	Fall-back type for those MySQL data types which c/J can't recognize.
`VARBINARY`	VARBINARY(M) The VARBINARY type is similar to the VARCHAR type, but stores binary byte strings rather than nonbinary character strings.
`VARCHAR`	[NATIONAL] VARCHAR(M) [CHARACTER SET charset_name] [COLLATE collation_name] A variable-length string.
`YEAR`	YEAR[(4)] A year in four-digit format.

字段概要

字段
修饰符和类型	字段	说明
`static int`	`FIELD_FLAG_AUTO_INCREMENT`
`static int`	`FIELD_FLAG_BINARY`
`static int`	`FIELD_FLAG_BLOB`
`static int`	`FIELD_FLAG_MULTIPLE_KEY`
`static int`	`FIELD_FLAG_NOT_NULL`
`static int`	`FIELD_FLAG_PRIMARY_KEY`
`static int`	`FIELD_FLAG_UNIQUE_KEY`
`static int`	`FIELD_FLAG_UNSIGNED`
`static int`	`FIELD_FLAG_ZEROFILL`
`static int`	`FIELD_TYPE_BIT`
`static int`	`FIELD_TYPE_BLOB`
`static int`	`FIELD_TYPE_DATE`
`static int`	`FIELD_TYPE_DATETIME`
`static int`	`FIELD_TYPE_DECIMAL`
`static int`	`FIELD_TYPE_DOUBLE`
`static int`	`FIELD_TYPE_ENUM`
`static int`	`FIELD_TYPE_FLOAT`
`static int`	`FIELD_TYPE_GEOMETRY`
`static int`	`FIELD_TYPE_INT24`
`static int`	`FIELD_TYPE_JSON`
`static int`	`FIELD_TYPE_LONG`
`static int`	`FIELD_TYPE_LONG_BLOB`
`static int`	`FIELD_TYPE_LONGLONG`
`static int`	`FIELD_TYPE_MEDIUM_BLOB`
`static int`	`FIELD_TYPE_NEWDECIMAL`
`static int`	`FIELD_TYPE_NULL`
`static int`	`FIELD_TYPE_SET`
`static int`	`FIELD_TYPE_SHORT`
`static int`	`FIELD_TYPE_STRING`
`static int`	`FIELD_TYPE_TIME`
`static int`	`FIELD_TYPE_TIMESTAMP`
`static int`	`FIELD_TYPE_TINY`
`static int`	`FIELD_TYPE_TINY_BLOB`
`static int`	`FIELD_TYPE_VAR_STRING`
`static int`	`FIELD_TYPE_VARCHAR`
`static int`	`FIELD_TYPE_YEAR`
`protected Class<?>`	`javaClass`
`protected int`	`jdbcType`

方法概要

所有方法静态方法实例方法具体方法
修饰符和类型	方法	说明
`static MysqlType`	`getByJdbcType(int jdbcType)`
`static MysqlType`	`getByName(String fullMysqlTypeName)`	Get MysqlType matching the full MySQL type name, for example "DECIMAL(5,3) UNSIGNED ZEROFILL".
`String`	`getClassName()`
`String`	`getCreateParams()`
`int`	`getJdbcType()`
`String`	`getName()`
`Long`	`getPrecision()`	The PRECISION column represents the maximum column size that the server supports for the given datatype.
`String`	`getVendor()`
`Integer`	`getVendorTypeNumber()`
`boolean`	`isAllowed(int flag)`
`boolean`	`isDecimal()`	Checks if the MySQL Type is a Decimal/Number Type
`static boolean`	`isSigned(MysqlType type)`
`static boolean`	`supportsConvert(int fromType, int toType)`	Is CONVERT between the given SQL types supported?
`static MysqlType`	`valueOf(String name)`	返回带有指定名称的该类型的枚举常量。
`static MysqlType[]`	`values()`	按照声明该枚举类型的常量的顺序, 返回包含这些常量的数组。

从类继承的方法 java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

从类继承的方法 java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- 枚举常量详细资料
  - DECIMAL
```
public static final MysqlType DECIMAL
```
    DECIMAL[(M[,D])] [UNSIGNED] [ZEROFILL] A packed "exact" fixed-point number. M is the total number of digits (the precision) and D is the number of digits after the decimal point (the scale). The decimal point and (for negative numbers) the "-" sign are not counted in M. If D is 0, values have no decimal point or fractional part. The maximum number of digits (M) for DECIMAL is 65. The maximum number of supported decimals (D) is 30. If D is omitted, the default is 0. If M is omitted, the default is 10. Protocol: FIELD_TYPE_DECIMAL = 0 Protocol: FIELD_TYPE_NEWDECIMAL = 246 These types are synonyms for DECIMAL: DEC[(M[,D])] [UNSIGNED] [ZEROFILL], NUMERIC[(M[,D])] [UNSIGNED] [ZEROFILL], FIXED[(M[,D])] [UNSIGNED] [ZEROFILL]
  - DECIMAL_UNSIGNED
```
public static final MysqlType DECIMAL_UNSIGNED
```
    DECIMAL[(M[,D])] UNSIGNED [ZEROFILL]
    
    另请参阅:
    
    DECIMAL
  - TINYINT
```
public static final MysqlType TINYINT
```
    TINYINT[(M)] [UNSIGNED] [ZEROFILL] A very small integer. The signed range is -128 to 127. The unsigned range is 0 to 255. Protocol: FIELD_TYPE_TINY = 1
  - TINYINT_UNSIGNED
```
public static final MysqlType TINYINT_UNSIGNED
```
    TINYINT[(M)] UNSIGNED [ZEROFILL]
    
    另请参阅:
    
    TINYINT
  - BOOLEAN
```
public static final MysqlType BOOLEAN
```
    BOOL, BOOLEAN These types are synonyms for TINYINT(1). A value of zero is considered false. Nonzero values are considered true BOOLEAN is converted to TINYINT(1) during DDL execution i.e. it has the same precision=3. Thus we have to look at full data type name and convert TINYINT to BOOLEAN (or BIT) if it has "(1)" length specification. Protocol: FIELD_TYPE_TINY = 1
  - SMALLINT
```
public static final MysqlType SMALLINT
```
    SMALLINT[(M)] [UNSIGNED] [ZEROFILL] A small integer. The signed range is -32768 to 32767. The unsigned range is 0 to 65535. Protocol: FIELD_TYPE_SHORT = 2
  - SMALLINT_UNSIGNED
```
public static final MysqlType SMALLINT_UNSIGNED
```
    SMALLINT[(M)] UNSIGNED [ZEROFILL]
    
    另请参阅:
    
    SMALLINT
  - INT
```
public static final MysqlType INT
```
    INT[(M)] [UNSIGNED] [ZEROFILL] A normal-size integer. The signed range is -2147483648 to 2147483647. The unsigned range is 0 to 4294967295. Protocol: FIELD_TYPE_LONG = 3 INTEGER[(M)] [UNSIGNED] [ZEROFILL] is a synonym for INT.
  - INT_UNSIGNED
```
public static final MysqlType INT_UNSIGNED
```
    INT[(M)] UNSIGNED [ZEROFILL]
    
    另请参阅:
    
    INT
  - FLOAT
```
public static final MysqlType FLOAT
```
    FLOAT[(M,D)] [UNSIGNED] [ZEROFILL] A small (single-precision) floating-point number. Permissible values are -3.402823466E+38 to -1.175494351E-38, 0, and 1.175494351E-38 to 3.402823466E+38. These are the theoretical limits, based on the IEEE standard. The actual range might be slightly smaller depending on your hardware or operating system. M is the total number of digits and D is the number of digits following the decimal point. If M and D are omitted, values are stored to the limits permitted by the hardware. A single-precision floating-point number is accurate to approximately 7 decimal places. Protocol: FIELD_TYPE_FLOAT = 4 Additionally: FLOAT(p) [UNSIGNED] [ZEROFILL] A floating-point number. p represents the precision in bits, but MySQL uses this value only to determine whether to use FLOAT or DOUBLE for the resulting data type. If p is from 0 to 24, the data type becomes FLOAT with no M or D values. If p is from 25 to 53, the data type becomes DOUBLE with no M or D values. The range of the resulting column is the same as for the single-precision FLOAT or double-precision DOUBLE data types.
  - FLOAT_UNSIGNED
```
public static final MysqlType FLOAT_UNSIGNED
```
    FLOAT[(M,D)] UNSIGNED [ZEROFILL]
    
    另请参阅:
    
    FLOAT
  - DOUBLE
```
public static final MysqlType DOUBLE
```
    DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL] A normal-size (double-precision) floating-point number. Permissible values are -1.7976931348623157E+308 to -2.2250738585072014E-308, 0, and 2.2250738585072014E-308 to 1.7976931348623157E+308. These are the theoretical limits, based on the IEEE standard. The actual range might be slightly smaller depending on your hardware or operating system. M is the total number of digits and D is the number of digits following the decimal point. If M and D are omitted, values are stored to the limits permitted by the hardware. A double-precision floating-point number is accurate to approximately 15 decimal places. Protocol: FIELD_TYPE_DOUBLE = 5 These types are synonyms for DOUBLE: DOUBLE PRECISION[(M,D)] [UNSIGNED] [ZEROFILL], REAL[(M,D)] [UNSIGNED] [ZEROFILL]. Exception: If the REAL_AS_FLOAT SQL mode is enabled, REAL is a synonym for FLOAT rather than DOUBLE.
  - DOUBLE_UNSIGNED
```
public static final MysqlType DOUBLE_UNSIGNED
```
    DOUBLE[(M,D)] UNSIGNED [ZEROFILL]
    
    另请参阅:
    
    DOUBLE
  - NULL
```
public static final MysqlType NULL
```
    FIELD_TYPE_NULL = 6
  - TIMESTAMP
```
public static final MysqlType TIMESTAMP
```
    TIMESTAMP[(fsp)] A timestamp. The range is '1970-01-01 00:00:01.000000' UTC to '2038-01-19 03:14:07.999999' UTC. TIMESTAMP values are stored as the number of seconds since the epoch ('1970-01-01 00:00:00' UTC). A TIMESTAMP cannot represent the value '1970-01-01 00:00:00' because that is equivalent to 0 seconds from the epoch and the value 0 is reserved for representing '0000-00-00 00:00:00', the "zero" TIMESTAMP value. An optional fsp value in the range from 0 to 6 may be given to specify fractional seconds precision. A value of 0 signifies that there is no fractional part. If omitted, the default precision is 0. Protocol: FIELD_TYPE_TIMESTAMP = 7
  - BIGINT
```
public static final MysqlType BIGINT
```
    BIGINT[(M)] [UNSIGNED] [ZEROFILL] A large integer. The signed range is -9223372036854775808 to 9223372036854775807. The unsigned range is 0 to 18446744073709551615. Protocol: FIELD_TYPE_LONGLONG = 8 SERIAL is an alias for BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.
  - BIGINT_UNSIGNED
```
public static final MysqlType BIGINT_UNSIGNED
```
    BIGINT[(M)] UNSIGNED [ZEROFILL]
    
    另请参阅:
    
    BIGINT
  - MEDIUMINT
```
public static final MysqlType MEDIUMINT
```
    MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL] A medium-sized integer. The signed range is -8388608 to 8388607. The unsigned range is 0 to 16777215. Protocol: FIELD_TYPE_INT24 = 9
  - MEDIUMINT_UNSIGNED
```
public static final MysqlType MEDIUMINT_UNSIGNED
```
    MEDIUMINT[(M)] UNSIGNED [ZEROFILL]
    
    另请参阅:
    
    MEDIUMINT
  - DATE
```
public static final MysqlType DATE
```
    DATE A date. The supported range is '1000-01-01' to '9999-12-31'. MySQL displays DATE values in 'YYYY-MM-DD' format, but permits assignment of values to DATE columns using either strings or numbers. Protocol: FIELD_TYPE_DATE = 10
  - TIME
```
public static final MysqlType TIME
```
    TIME[(fsp)] A time. The range is '-838:59:59.000000' to '838:59:59.000000'. MySQL displays TIME values in 'HH:MM:SS[.fraction]' format, but permits assignment of values to TIME columns using either strings or numbers. An optional fsp value in the range from 0 to 6 may be given to specify fractional seconds precision. A value of 0 signifies that there is no fractional part. If omitted, the default precision is 0. Protocol: FIELD_TYPE_TIME = 11
  - DATETIME
```
public static final MysqlType DATETIME
```
    DATETIME[(fsp)] A date and time combination. The supported range is '1000-01-01 00:00:00.000000' to '9999-12-31 23:59:59.999999'. MySQL displays DATETIME values in 'YYYY-MM-DD HH:MM:SS[.fraction]' format, but permits assignment of values to DATETIME columns using either strings or numbers. An optional fsp value in the range from 0 to 6 may be given to specify fractional seconds precision. A value of 0 signifies that there is no fractional part. If omitted, the default precision is 0. Protocol: FIELD_TYPE_DATETIME = 12
  - YEAR
```
public static final MysqlType YEAR
```
    YEAR[(4)] A year in four-digit format. MySQL displays YEAR values in YYYY format, but permits assignment of values to YEAR columns using either strings or numbers. Values display as 1901 to 2155, and 0000. Protocol: FIELD_TYPE_YEAR = 13
  - VARCHAR
```
public static final MysqlType VARCHAR
```
    [NATIONAL] VARCHAR(M) [CHARACTER SET charset_name] [COLLATE collation_name] A variable-length string. M represents the maximum column length in characters. The range of M is 0 to 65,535. The effective maximum length of a VARCHAR is subject to the maximum row size (65,535 bytes, which is shared among all columns) and the character set used. For example, utf8 characters can require up to three bytes per character, so a VARCHAR column that uses the utf8 character set can be declared to be a maximum of 21,844 characters. MySQL stores VARCHAR values as a 1-byte or 2-byte length prefix plus data. The length prefix indicates the number of bytes in the value. A VARCHAR column uses one length byte if values require no more than 255 bytes, two length bytes if values may require more than 255 bytes. Note MySQL 5.7 follows the standard SQL specification, and does not remove trailing spaces from VARCHAR values. VARCHAR is shorthand for CHARACTER VARYING. NATIONAL VARCHAR is the standard SQL way to define that a VARCHAR column should use some predefined character set. MySQL 4.1 and up uses utf8 as this predefined character set. NVARCHAR is shorthand for NATIONAL VARCHAR. Protocol: FIELD_TYPE_VARCHAR = 15 Protocol: FIELD_TYPE_VAR_STRING = 253
  - VARBINARY
```
public static final MysqlType VARBINARY
```
    VARBINARY(M) The VARBINARY type is similar to the VARCHAR type, but stores binary byte strings rather than nonbinary character strings. M represents the maximum column length in bytes. Protocol: FIELD_TYPE_VARCHAR = 15 Protocol: FIELD_TYPE_VAR_STRING = 253
  - BIT
```
public static final MysqlType BIT
```
    BIT[(M)] A bit-field type. M indicates the number of bits per value, from 1 to 64. The default is 1 if M is omitted. Protocol: FIELD_TYPE_BIT = 16
  - JSON
```
public static final MysqlType JSON
```
    The size of JSON documents stored in JSON columns is limited to the value of the max_allowed_packet system variable (max value 1073741824). (While the server manipulates a JSON value internally in memory, it can be larger; the limit applies when the server stores it.) Protocol: FIELD_TYPE_BIT = 245
  - ENUM
```
public static final MysqlType ENUM
```
    ENUM('value1','value2',...) [CHARACTER SET charset_name] [COLLATE collation_name] An enumeration. A string object that can have only one value, chosen from the list of values 'value1', 'value2', ..., NULL or the special '' error value. ENUM values are represented internally as integers. An ENUM column can have a maximum of 65,535 distinct elements. (The practical limit is less than 3000.) A table can have no more than 255 unique element list definitions among its ENUM and SET columns considered as a group Protocol: FIELD_TYPE_ENUM = 247
  - SET
```
public static final MysqlType SET
```
    SET('value1','value2',...) [CHARACTER SET charset_name] [COLLATE collation_name] A set. A string object that can have zero or more values, each of which must be chosen from the list of values 'value1', 'value2', ... SET values are represented internally as integers. A SET column can have a maximum of 64 distinct members. A table can have no more than 255 unique element list definitions among its ENUM and SET columns considered as a group Protocol: FIELD_TYPE_SET = 248
  - TINYBLOB
```
public static final MysqlType TINYBLOB
```
    TINYBLOB A BLOB column with a maximum length of 255 (28 - 1) bytes. Each TINYBLOB value is stored using a 1-byte length prefix that indicates the number of bytes in the value. Protocol:FIELD_TYPE_TINY_BLOB = 249
  - TINYTEXT
```
public static final MysqlType TINYTEXT
```
    TINYTEXT [CHARACTER SET charset_name] [COLLATE collation_name] A TEXT column with a maximum length of 255 (28 - 1) characters. The effective maximum length is less if the value contains multibyte characters. Each TINYTEXT value is stored using a 1-byte length prefix that indicates the number of bytes in the value. Protocol:FIELD_TYPE_TINY_BLOB = 249
  - MEDIUMBLOB
```
public static final MysqlType MEDIUMBLOB
```
    MEDIUMBLOB A BLOB column with a maximum length of 16,777,215 (224 - 1) bytes. Each MEDIUMBLOB value is stored using a 3-byte length prefix that indicates the number of bytes in the value. Protocol: FIELD_TYPE_MEDIUM_BLOB = 250
  - MEDIUMTEXT
```
public static final MysqlType MEDIUMTEXT
```
    MEDIUMTEXT [CHARACTER SET charset_name] [COLLATE collation_name] A TEXT column with a maximum length of 16,777,215 (224 - 1) characters. The effective maximum length is less if the value contains multibyte characters. Each MEDIUMTEXT value is stored using a 3-byte length prefix that indicates the number of bytes in the value. Protocol: FIELD_TYPE_MEDIUM_BLOB = 250
  - LONGBLOB
```
public static final MysqlType LONGBLOB
```
    LONGBLOB A BLOB column with a maximum length of 4,294,967,295 or 4GB (232 - 1) bytes. The effective maximum length of LONGBLOB columns depends on the configured maximum packet size in the client/server protocol and available memory. Each LONGBLOB value is stored using a 4-byte length prefix that indicates the number of bytes in the value. Protocol: FIELD_TYPE_LONG_BLOB = 251
  - LONGTEXT
```
public static final MysqlType LONGTEXT
```
    LONGTEXT [CHARACTER SET charset_name] [COLLATE collation_name] A TEXT column with a maximum length of 4,294,967,295 or 4GB (232 - 1) characters. The effective maximum length is less if the value contains multibyte characters. The effective maximum length of LONGTEXT columns also depends on the configured maximum packet size in the client/server protocol and available memory. Each LONGTEXT value is stored using a 4-byte length prefix that indicates the number of bytes in the value. Protocol: FIELD_TYPE_LONG_BLOB = 251
  - BLOB
```
public static final MysqlType BLOB
```
    BLOB[(M)] A BLOB column with a maximum length of 65,535 (216 - 1) bytes. Each BLOB value is stored using a 2-byte length prefix that indicates the number of bytes in the value. An optional length M can be given for this type. If this is done, MySQL creates the column as the smallest BLOB type large enough to hold values M bytes long. Protocol: FIELD_TYPE_BLOB = 252
  - TEXT
```
public static final MysqlType TEXT
```
    TEXT[(M)] [CHARACTER SET charset_name] [COLLATE collation_name] A TEXT column with a maximum length of 65,535 (216 - 1) characters. The effective maximum length is less if the value contains multibyte characters. Each TEXT value is stored using a 2-byte length prefix that indicates the number of bytes in the value. An optional length M can be given for this type. If this is done, MySQL creates the column as the smallest TEXT type large enough to hold values M characters long. Protocol: FIELD_TYPE_BLOB = 252
  - CHAR
```
public static final MysqlType CHAR
```
    [NATIONAL] CHAR[(M)] [CHARACTER SET charset_name] [COLLATE collation_name] A fixed-length string that is always right-padded with spaces to the specified length when stored. M represents the column length in characters. The range of M is 0 to 255. If M is omitted, the length is 1. Note Trailing spaces are removed when CHAR values are retrieved unless the PAD_CHAR_TO_FULL_LENGTH SQL mode is enabled. CHAR is shorthand for CHARACTER. NATIONAL CHAR (or its equivalent short form, NCHAR) is the standard SQL way to define that a CHAR column should use some predefined character set. MySQL 4.1 and up uses utf8 as this predefined character set. MySQL permits you to create a column of type CHAR(0). This is useful primarily when you have to be compliant with old applications that depend on the existence of a column but that do not actually use its value. CHAR(0) is also quite nice when you need a column that can take only two values: A column that is defined as CHAR(0) NULL occupies only one bit and can take only the values NULL and '' (the empty string). Protocol: FIELD_TYPE_STRING = 254
  - BINARY
```
public static final MysqlType BINARY
```
    BINARY(M) The BINARY type is similar to the CHAR type, but stores binary byte strings rather than nonbinary character strings. M represents the column length in bytes. The CHAR BYTE data type is an alias for the BINARY data type. Protocol: no concrete type on the wire TODO: really?
  - GEOMETRY
```
public static final MysqlType GEOMETRY
```
    Top class for Spatial Data Types Protocol: FIELD_TYPE_GEOMETRY = 255
  - UNKNOWN
```
public static final MysqlType UNKNOWN
```
    Fall-back type for those MySQL data types which c/J can't recognize. Handled the same as BLOB. Has no protocol ID.
- 字段详细资料
  - jdbcType
```
protected int jdbcType
```
  - javaClass
```
protected final Class<?> javaClass
```
  - FIELD_FLAG_NOT_NULL
```
public static final int FIELD_FLAG_NOT_NULL
```
    另请参阅:
    
    常量字段值
  - FIELD_FLAG_PRIMARY_KEY
```
public static final int FIELD_FLAG_PRIMARY_KEY
```
    另请参阅:
    
    常量字段值
  - FIELD_FLAG_UNIQUE_KEY
```
public static final int FIELD_FLAG_UNIQUE_KEY
```
    另请参阅:
    
    常量字段值
  - FIELD_FLAG_MULTIPLE_KEY
```
public static final int FIELD_FLAG_MULTIPLE_KEY
```
    另请参阅:
    
    常量字段值
  - FIELD_FLAG_BLOB
```
public static final int FIELD_FLAG_BLOB
```
    另请参阅:
    
    常量字段值
  - FIELD_FLAG_UNSIGNED
```
public static final int FIELD_FLAG_UNSIGNED
```
    另请参阅:
    
    常量字段值
  - FIELD_FLAG_ZEROFILL
```
public static final int FIELD_FLAG_ZEROFILL
```
    另请参阅:
    
    常量字段值
  - FIELD_FLAG_BINARY
```
public static final int FIELD_FLAG_BINARY
```
    另请参阅:
    
    常量字段值
  - FIELD_FLAG_AUTO_INCREMENT
```
public static final int FIELD_FLAG_AUTO_INCREMENT
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_DECIMAL
```
public static final int FIELD_TYPE_DECIMAL
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_TINY
```
public static final int FIELD_TYPE_TINY
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_SHORT
```
public static final int FIELD_TYPE_SHORT
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_LONG
```
public static final int FIELD_TYPE_LONG
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_FLOAT
```
public static final int FIELD_TYPE_FLOAT
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_DOUBLE
```
public static final int FIELD_TYPE_DOUBLE
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_NULL
```
public static final int FIELD_TYPE_NULL
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_TIMESTAMP
```
public static final int FIELD_TYPE_TIMESTAMP
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_LONGLONG
```
public static final int FIELD_TYPE_LONGLONG
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_INT24
```
public static final int FIELD_TYPE_INT24
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_DATE
```
public static final int FIELD_TYPE_DATE
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_TIME
```
public static final int FIELD_TYPE_TIME
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_DATETIME
```
public static final int FIELD_TYPE_DATETIME
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_YEAR
```
public static final int FIELD_TYPE_YEAR
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_VARCHAR
```
public static final int FIELD_TYPE_VARCHAR
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_BIT
```
public static final int FIELD_TYPE_BIT
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_JSON
```
public static final int FIELD_TYPE_JSON
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_NEWDECIMAL
```
public static final int FIELD_TYPE_NEWDECIMAL
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_ENUM
```
public static final int FIELD_TYPE_ENUM
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_SET
```
public static final int FIELD_TYPE_SET
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_TINY_BLOB
```
public static final int FIELD_TYPE_TINY_BLOB
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_MEDIUM_BLOB
```
public static final int FIELD_TYPE_MEDIUM_BLOB
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_LONG_BLOB
```
public static final int FIELD_TYPE_LONG_BLOB
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_BLOB
```
public static final int FIELD_TYPE_BLOB
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_VAR_STRING
```
public static final int FIELD_TYPE_VAR_STRING
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_STRING
```
public static final int FIELD_TYPE_STRING
```
    另请参阅:
    
    常量字段值
  - FIELD_TYPE_GEOMETRY
```
public static final int FIELD_TYPE_GEOMETRY
```
    另请参阅:
    
    常量字段值
- 方法详细资料
  - values
```
public static MysqlType[] values()
```
    按照声明该枚举类型的常量的顺序, 返回包含这些常量的数组。该方法可用于迭代常量, 如下所示:
    for (MysqlType c : MysqlType.values()) System.out.println(c);
    返回:
    
    按照声明该枚举类型的常量的顺序返回的包含这些常量的数组
  - valueOf
```
public static MysqlType valueOf(String name)
```
    返回带有指定名称的该类型的枚举常量。字符串必须与用于声明该类型的枚举常量的标识符完全匹配。(不允许有多余的空格字符。)
    
    参数:
    
    name - 要返回的枚举常量的名称。
    
    返回:
    
    返回带有指定名称的枚举常量
    
    抛出:
    
    IllegalArgumentException - 如果该枚举类型没有带有指定名称的常量
    
    NullPointerException - 如果参数为空值
  - getByName
```
public static MysqlType getByName(String fullMysqlTypeName)
```
    Get MysqlType matching the full MySQL type name, for example "DECIMAL(5,3) UNSIGNED ZEROFILL". Distinct *_UNSIGNED type will be returned if "UNSIGNED" is present in fullMysqlTypeName.
    
    参数:
    
    fullMysqlTypeName - full MySQL type name
    
    返回:
    
    MysqlType
  - getByJdbcType
```
public static MysqlType getByJdbcType(int jdbcType)
```
  - supportsConvert
```
public static boolean supportsConvert(int fromType,
                                      int toType)
```
    Is CONVERT between the given SQL types supported?
    
    参数:
    
    fromType - the type to convert from
    
    toType - the type to convert to
    
    返回:
    
    true if so
    
    另请参阅:
    
    Types
  - isSigned
```
public static boolean isSigned(MysqlType type)
```
  - getName
```
public String getName()
```
    指定者:
    
    getName 在接口中 SQLType
  - getJdbcType
```
public int getJdbcType()
```
  - isAllowed
```
public boolean isAllowed(int flag)
```
  - getClassName
```
public String getClassName()
```
  - isDecimal
```
public boolean isDecimal()
```
    Checks if the MySQL Type is a Decimal/Number Type
    
    返回:
    
    true if the MySQL Type is a Decimal/Number Type
  - getPrecision
```
public Long getPrecision()
```
    The PRECISION column represents the maximum column size that the server supports for the given datatype.
    
    For numeric data, this is the maximum precision.
    For character data, this is the length in characters.
    For datetime datatypes, this is the length in characters of the String representation (assuming the maximum allowed precision of the fractional seconds component).
    For binary data, this is the length in bytes.
    For the ROWID datatype, this is the length in bytes.
    Null is returned for data types where the column size is not applicable.
    返回:
    
    precision
  - getCreateParams
```
public String getCreateParams()
```
  - getVendor
```
public String getVendor()
```
    指定者:
    
    getVendor 在接口中 SQLType
  - getVendorTypeNumber
```
public Integer getVendorTypeNumber()
```
    指定者:
    
    getVendorTypeNumber 在接口中 SQLType

枚举 MysqlType

枚举常量概要

字段概要

方法概要

从类继承的方法 java.lang.Enum

从类继承的方法 java.lang.Object

枚举常量详细资料

DECIMAL

DECIMAL_UNSIGNED

TINYINT

TINYINT_UNSIGNED

BOOLEAN

SMALLINT

SMALLINT_UNSIGNED

INT

INT_UNSIGNED

FLOAT

FLOAT_UNSIGNED

DOUBLE

DOUBLE_UNSIGNED

NULL

TIMESTAMP

BIGINT

BIGINT_UNSIGNED

MEDIUMINT

MEDIUMINT_UNSIGNED

DATE

TIME

DATETIME

YEAR

VARCHAR

VARBINARY

BIT

JSON

ENUM

SET

TINYBLOB

TINYTEXT

MEDIUMBLOB

MEDIUMTEXT

LONGBLOB

LONGTEXT

BLOB

TEXT

CHAR

BINARY

GEOMETRY

UNKNOWN

字段详细资料

jdbcType

javaClass

FIELD_FLAG_NOT_NULL

FIELD_FLAG_PRIMARY_KEY

FIELD_FLAG_UNIQUE_KEY

FIELD_FLAG_MULTIPLE_KEY

FIELD_FLAG_BLOB

FIELD_FLAG_UNSIGNED

FIELD_FLAG_ZEROFILL

FIELD_FLAG_BINARY

FIELD_FLAG_AUTO_INCREMENT

FIELD_TYPE_DECIMAL

FIELD_TYPE_TINY

FIELD_TYPE_SHORT

FIELD_TYPE_LONG

FIELD_TYPE_FLOAT

FIELD_TYPE_DOUBLE

FIELD_TYPE_NULL

FIELD_TYPE_TIMESTAMP

FIELD_TYPE_LONGLONG

FIELD_TYPE_INT24

FIELD_TYPE_DATE

FIELD_TYPE_TIME

FIELD_TYPE_DATETIME

FIELD_TYPE_YEAR

FIELD_TYPE_VARCHAR

FIELD_TYPE_BIT

FIELD_TYPE_JSON

FIELD_TYPE_NEWDECIMAL

FIELD_TYPE_ENUM

FIELD_TYPE_SET