MySQL

Data type

RapidClipse default mapping

Generated Javacode (example)

DECIMAL(M,D) [UNSIGNED] [ZEROFILLED]

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.

UNSIGNED, if specified, disallows negative values.

All basic calculations (+, -, *, /) with DECIMAL columns are done with a precision of 65 digits.

<sql-type jdbc-type="DECIMAL" hibernate-type="java.math.BigDecimal"></sql-type>

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"DECIMAL"},new String[]{"java.math.BigDecimal"},"decimal"));

private BigDecimal decimaltest;

@Column(name = "DECIMALTEST", nullable = false,
            precision = 10, scale = 0, columnDefinition = "decimal")
public BigDecimal getDecimaltest() {
    return this.decimaltest;
}

private Double decimaltest;

@Column(name = "DECIMALTEST", nullable = false,
            precision = 10, scale = 0, columnDefinition = "decimal")
public Double getDecimaltest() {
    return this.decimaltest;
}

YEAR

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.

<sql-type jdbc-type="YEAR" hibernate-type="java.lang.String"></sql-type>

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"YEAR"},new String[]{"java.lang.String"},"year"));

private String yeartest;

@Column(name = "YEARTEST", nullable = false,
            length = 0, columnDefinition = "year")
public String getYeartest() {
    return this.yeartest;
}

SERIAL

SERIAL is an alias for BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.

Hibernate default mapping

private Long serialtest;

@GeneratedValue(strategy = IDENTITY)
@Column(name = "SERIALTEST", unique = true,
            nullable = false)
public Long getSerialtest() {
    return this.serialtest;
}

INT(M) [UNSIGNED][ZEROFILLED]

A normal-size integer. The signed range is -2147483648 to 2147483647.

The unsigned range is 0 to 4294967295.

<sql-type jdbc-type="INTEGER" hibernate-type="java.lang.Integer"> </sql-type>

private int inttest;

@Column(name = "INTTEST", nullable = false)
public int getInttest() {
    return this.inttest;
}

VARCHAR

Values in VARCHAR columns are variable-length strings.

The length can be specified as a value from 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.

Hibernate default mapping

private String varchartest;

@Column(name = "VARCHARTEST", nullable = false,
            length = 10)
public String getVarchartest() {
    return this.varchartest;
}

TEXT

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.

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"TEXT"},new String[]{"java.lang.String"},"text"));

private String texttest;

@Column(name = "TEXTTEST", nullable = false,
            length = 65535, columnDefinition = "text")
public String getTexttest() {
    return this.texttest;
}

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.

Hibernate default mapping

private Date datetest;

@Temporal(TemporalType.DATE)
@Column(name = "DATETEST", nullable = false,
            length = 10)
public Date getDatetest() {
    return this.datetest;
}

TINYINT(M) _[UNSIGNED][ZEROFILLED]_

A very small integer. The signed range is -128 to 127. The unsigned range is 0 to 255.

<sql-type jdbc-type="TINYINT" hibernate-type="java.lang.Short"> </sql-type>

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"TINYINT","TINYINT UNSIGNED"},
        new String[]{"java.lang.Short","short"},"tinyint"));

private short tinyinttest;

@Column(name = "TINYINTTEST", nullable = false,
            columnDefinition = "tinyint")
public short getTinyinttest() {
    return this.tinyinttest;
}

SMALLINT(M) [UNSIGNED] [ZEROFILLED]

A small integer. The signed range is -32768 to 32767. The unsigned range is 0 to 65535.

Hibernate default mapping

private short smallinttest;

@Column(name = "SMALLINTTEST", nullable = false)
public short getSmallinttest() {
    return this.smallinttest;
}

MEDIUMINT(M) [UNSIGNED]__

A medium-sized integer. The signed range is -8388608 to 8388607. The unsigned range is 0 +`to `+16777215.

Hibernate default mapping

private int mediuminttest;

@Column(name = "MEDIUMINTTEST", nullable = false)
public int getMediuminttest() {
    return this.mediuminttest;
}

BIGINT(M) [UNSIGNED]__

A large integer. The signed range is -9223372036854775808 to 9223372036854775807. The unsigned range is 0 to 18446744073709551615.

Hibernate default mapping

private long biginttest;

@Column(name = "BIGINTTEST", nullable = false)
public long getBiginttest() {
    return this.biginttest;
}

FLOAT(M,D) [UNSIGNED]__

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.

UNSIGNED, if specified, disallows negative values.

Hibernate default mapping

private float floattest;

@Column(name = "FLOATTEST", nullable = false,
            precision = 12, scale = 0)
public float getFloattest() {
    return this.floattest;
}

DOUBLE(M,D) [UNSIGNED] __

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.

UNSIGNED, if specified, disallows negative values.

Hibernate default mapping

private double doubletest;

@Column(name = "DOUBLETEST", nullable = false,
            precision = 22, scale = 0)
public double getDoubletest() {
    return this.doubletest;
}

REAL(M,D) [UNSIGNED]__

This type is a synonym for DOUBLE.

Exception: If the REAL_AS_FLOAT SQL mode is enabled, REAL is a synonym for FLOAT rather than DOUBLE.

Hibernate default mapping

private double realtest;

@Column(name = "REALTEST", nullable = false,
            precision = 22, scale = 0)
public double getRealtest() {
    return this.realtest;
}

private Float realtest;

@Column(name = "REALTEST", nullable = false,
            precision = 22, scale = 0)
public Float getRealtest() {
    return this.realtest;
}

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.

Hibernate default mapping

private boolean bittest;

@Column(name = "BITTEST", nullable = false)
public boolean isBittest() {
    return this.bittest;
}

BOOLEAN

These types are synonyms for TINYINT(1). A value of zero is considered false. Nonzero values are considered true.

Hibernate default mapping

private boolean booleantest;

@Column(name = "BOOLEANTEST", nullable = false)
public boolean isBooleantest() {
    return this.booleantest;
}

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 allows 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.

Hibernate default mapping

private Date datetimetest;

@Temporal(TemporalType.TIMESTAMP)
@Column(name = "DATETIMETEST", nullable = false,
            length = 19)
public Date getDatetimetest() {
    return this.datetimetest;
}

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.

Hibernate default mapping

private Date timestamptest;

@Temporal(TemporalType.TIMESTAMP)
@Column(name = "TIMESTAMPTEST", nullable = false,
            length = 19)
public Date getTimestamptest() {
    return this.timestamptest;
}

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 allows 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.

Hibernate default mapping

private Date timetest;

@Temporal(TemporalType.TIME)
@Column(name = "TIMETEST", nullable = false,
            length = 8)
public Date getTimetest() {
    return this.timetest;
}

CHAR(M)

Values in CHAR columns are fixed-length strings.

The length of a CHAR column is fixed to the length that you declare when you create the table. The length can be any value from 0 to 255. When CHAR values are stored, they are right-padded with spaces to the specified length.

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"CHAR"},new String[]{"java.lang.String"},"char"));

private String chartest;

@Column(name = "CHARTEST", nullable = false,
            length = 10, columnDefinition = "char")
public String getChartest() {
    return this.chartest;
}

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 TINYTEXTvalue is stored using a 1-byte length prefix that indicates the number of bytes in the value.

Hibernate default mapping

private String tinytexttest;

@Column(name = "TINYTEXTTEST", nullable = false)
public String getTinytexttest() {
    return this.tinytexttest;
}

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.

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"MEDIUMTEXT"},new String[]{"java.lang.String"},"mediumtext"));

private String mediumtexttest;

@Column(name = "MEDIUMTEXTTEST", nullable = false,
            length = 16777215, columnDefinition = "mediumtext")
public String getMediumtexttest() {
    return this.mediumtexttest;
}

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.

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"LONGTEXT"},new String[]{"java.lang.String"},"longtext"));

private String longtexttest;

@Column(name = "LONGTEXTTEST", nullable = false,
            columnDefinition = "longtext")
public String getLongtexttest() {
    return this.longtexttest;
}

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.

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"BINARY"},new String[]{"byte[]"},"binary"));

private byte[] binarytest;

@Column(name = "BINARYTEST", nullable = false,
            columnDefinition = "binary")
public byte[] getBinarytest() {
    return this.binarytest;
}

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.

Hibernate default mapping

private byte[] varbinarytest;

@Column(name = "VARBINARYTEST", nullable = false)
public byte[] getVarbinarytest() {
    return this.varbinarytest;
}

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.

Hibernate default mapping

private byte[] tinyblobtest;

@Column(name = "TINYBLOBTEST", nullable = false)
public byte[] getTinyblobtest() {
    return this.tinyblobtest;
}

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.

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"MEDIUMBLOB"},new String[]{"byte[]"},"mediumblob"));

private byte[] mediumblobtest;

@Column(name = "MEDIUMBLOBTEST", nullable = false,
            columnDefinition = "mediumblob")
public byte[] getMediumblobtest() {
    return this.mediumblobtest;
}

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 ype large enough to hold values M bytes long.

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"BLOB"},new String[]{"byte[]"},"blob"));

private byte[] blobtest;

@Column(name = "BLOBTEST", nullable = false,
            columnDefinition = "blob")
public byte[] getBlobtest() {
    return this.blobtest;
}

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.

visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"LONGBLOB"},new String[]{"byte[]"},"longblob"));

private byte[] longblobtest;

@Column(name = "LONGBLOBTEST", nullable = false,
            columnDefinition = "longblob")
public byte[] getLongblobtest() {
    return this.longblobtest;
}