H2

Data type

RapidClipse default mapping

Generated Javacode (example)

CHARACTER(n)

A Unicode string. This type is supported for compatibility with other databases and older applications. The difference to VARCHAR is that trailing spaces are ignored and not persisted.

The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is kept in memory when using this data type.

 
visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"CHARACTER"},new String[]{"java.lang.String"},"CHARACTER"));
 
private String charactertest;
@Column(name = "CHARACTERTEST", length = 10,
            columnDefinition = "CHARACTER")
public String getCharactertest() {
    return this.charactertest;
}

CHAR(n)

A Unicode string. This type is supported for compatibility with other databases and older applications. The difference to VARCHAR is that trailing spaces are ignored and not persisted.

The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is kept in memory when using this data type.

 
visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"CHAR"},new String[]{"java.lang.String"},"CHAR"));
 
private String chartest;
@Column(name = "CHARTEST", length = 10,
            columnDefinition = "CHAR")
public String getChartest() {
    return this.chartest;
}

NCHAR(n)

A Unicode string. This type is supported for compatibility with other databases and older applications. The difference to VARCHAR is that trailing spaces are ignored and not persisted.

The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is kept in memory when using this data type.

 
visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
    new String[]{"NCHAR"},new String[]{"java.lang.String"},"CHAR"));
 
private String nchartest;
@Column(name = "NCHARTEST", length = 10,
            columnDefinition = "CHAR")
public String getNchartest() {
    return this.nchartest;
}

INT

Possible values: -2147483648 to 2147483647.

Hibernate default mapping

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

INTEGER

Possible values: -2147483648 to 2147483647.

Hibernate default mapping

 
private Integer integertest;
@Column(name = "INTEGERTEST")
public Integer getIntegertest() {
    return this.integertest;
}

MEDIUMINT

Possible values: -2147483648 to 2147483647.

Hibernate default mapping

 
private Integer mediuminttest;
@Column(name = "MEDIUMINTTEST")
public Integer getMediuminttest() {
    return this.mediuminttest;
}

INT4

Possible values: -2147483648 to 2147483647.

Hibernate default mapping

 
private Integer int4test;
@Column(name = "INT4TEST")
public Integer getInt4test() {
    return this.int4test;
}

SIGNED

Possible values: -2147483648 to 2147483647.

Hibernate default mapping

 
private Integer signedtest;
@Column(name = "SIGNEDTEST")
public Integer getSignedtest() {
    return this.signedtest;
}

BOOLEAN

Possible values: TRUE and FALSE.

Hibernate default mapping

 
private Boolean booleantest;
@Column(name = "BOOLEANTEST")
public Boolean getBooleantest() {
    return this.booleantest;
}

BIT

Possible values: TRUE and FALSE.

Hibernate default mapping

 
private Boolean bittest;
@Column(name = "BITTEST")
public Boolean getBittest() {
    return this.bittest;
}

BOOL

Possible values: TRUE and FALSE.

Hibernate default mapping

 
private Boolean booltest;
@Column(name = "BOOLTEST")
public Boolean getBooltest() {
    return this.booltest;
}

TINYINT

Possible values: -128 to 127.

Hibernate default mapping

 
private Byte tinyinttest;
@Column(name = "TINYINTTEST")
public Byte getTinyinttest() {
    return this.tinyinttest;
}

SMALLINT

Possible values: -32768 to 32767.

Hibernate default mapping

 
private Short smallinttest;
@Column(name = "SMALLINTTEST")
public Short getSmallinttest() {
    return this.smallinttest;
}

INT2

Possible values: -32768 to 32767.

Hibernate default mapping

 
private Short int2test;
@Column(name = "INT2TEST")
public Short getInt2test() {
    return this.int2test;
}

YEAR

Possible values: -32768 to 32767.

Hibernate default mapping

 
private Short yeartest;
@Column(name = "YEARTEST")
public Short getYeartest() {
    return this.yeartest;
}

BIGINT

Possible values: -9223372036854775808 to 9223372036854775807.

Hibernate default mapping

 
private Long biginttest;
@Column(name = "BIGINTTEST")
public Long getBiginttest() {
    return this.biginttest;
}

INT8

Possible values: -9223372036854775808 to 9223372036854775807.

Hibernate default mapping

 
private Long int8test;
@Column(name = "INT8TEST")
public Long getInt8test() {
    return this.int8test;
}

IDENTITY

Auto-Increment value. Possible values: -9223372036854775808 to 9223372036854775807.

Used values are never re-used, even when the transaction is rolled back.

Hibernate default mapping

 
private Long identitytest;
@GeneratedValue(strategy = IDENTITY)
@Column(name = "IDENTITYTEST",  unique = true,
            nullable = false)
public Long getIdentitytest() {
    return this.identitytest;
}

DECIMAL

Data type with fixed precision and scale.

This data type is recommended for storing currency values.

Hibernate default mapping

 
private BigDecimal decimaltest;
@Column(name = "DECIMALTEST", precision = 20)
public BigDecimal getDecimaltest() {
    return this.decimaltest;
}
private Double decimaltest;
@Column(name = "DECIMALTEST", precision = 20)
public Double getDecimaltest() {
    return this.decimaltest;
}

NUMBER

Data type with fixed precision and scale.

This data type is recommended for storing currency values.

Hibernate default mapping

 
private BigDecimal numbertest;
@Column(name = "NUMBERTEST", precision = 20)
public BigDecimal getNumbertest() {
    return this.numbertest;
}

DEC

Data type with fixed precision and scale.

This data type is recommended for storing currency values.

Hibernate default mapping

 
private BigDecimal dectest;
@Column(name = "DECTEST", precision = 20)
public BigDecimal getDectest() {
    return this.dectest;
}

NUMERIC

Data type with fixed precision and scale.

This data type is recommended for storing currency values.

Hibernate default mapping

 
private BigDecimal numerictest;
@Column(name = "NUMERICTEST", precision = 20)
public BigDecimal getNumerictest() {
    return this.numerictest;
}

DOUBLE

A floating point number. Should not be used to represent currency values, because of rounding problems.

Hibernate default mapping

 
private Double doubletest;
@Column(name = "DOUBLETEST", precision = 17,
            scale = 0)
public Double getDoubletest() {
    return this.doubletest;
}

FLOAT

A floating point number. Should not be used to represent currency values, because of rounding problems.

Hibernate default mapping

 
private Double floattest;
@Column(name = "FLOATTEST", precision = 17,
            scale = 0)
public Double getFloattest() {
    return this.floattest;
}

FLOAT8

A floating point number. Should not be used to represent currency values, because of rounding problems.

Hibernate default mapping

 
private Double float8test;
@Column(name = "FLOAT8TEST", precision = 17,
            scale = 0)
public Double getFloat8test() {
    return this.float8test;
}

REAL

A single precision floating point number. Should not be used to represent currency values, because of rounding problems.

 
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"REAL"},
        new String[]{"java.lang.Float","float"},"real"));
 
private Float realtest;
@Column(name = "REALTEST", precision = 7,
            scale = 0, columnDefinition = "real")
public Float getRealtest() {
    return this.realtest;
}

FLOAT4

A single precision floating point number. Should not be used to represent currency values, because of rounding problems.

 
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"REAL"},
            new String[]{"java.lang.Float","float"},"real"));
 
private Float float4test;
@Column(name = "FLOAT4TEST", precision = 7,
            scale = 0, columnDefinition = "real")
public Float getFloat4test() {
    return this.float4test;
}

TIME

The time data type. The format is hh:mm:ss.

Hibernate default mapping

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

DATE

The date data type. The format is yyyy-MM-dd.

Hibernate default mapping

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

TIMESTAMP

The timestamp data type.

The format is yyyy-MM-dd hh:mm:ss[.nnnnnnn].

Hibernate default mapping

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

DATETIME

The timestamp data type.

The format is yyyy-MM-dd hh:mm:ss[.nnnnnnn].

Hibernate default mapping

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

SMALLDATETIME

The timestamp data type.

The format is yyyy-MM-dd hh:mm:ss[.nnnnnnn].

Hibernate default mapping

 
private Date smalldatetimetest;
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "SMALLDATETIMETEST", length = 23)
public Date getSmalldatetimetest() {
    return this.smalldatetimetest;
}

BINARY

Represents a byte array. For very long arrays, use BLOB.

The maximum size is 2 GB, but the whole object is kept in memory when using this data type. The precision is a size constraint; only the actual data is persisted. For large text data BLOB or CLOB should be used.

Hibernate default mapping

 
private byte[] binarytest;
@Column(name = "BINARYTEST")
public byte[] getBinarytest() {
    return this.binarytest;
}

VARBINARY

Represents a byte array. For very long arrays, use BLOB.

The maximum size is 2 GB, but the whole object is kept in memory when using this data type. The precision is a size constraint; only the actual data is persisted. For large text data BLOB or CLOB should be used.

Hibernate default mapping

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

LONGVARBINARY

Represents a byte array. For very long arrays, use BLOB.

The maximum size is 2 GB, but the whole object is kept in memory when using this data type. The precision is a size constraint; only the actual data is persisted. For large text data BLOB or CLOB should be used.

Hibernate default mapping

 
private byte[] longvarbinarytest;
@Column(name = "LONGVARBINARYTEST")
public byte[] getLongvarbinarytest() {
    return this.longvarbinarytest;
}

RAW

Represents a byte array. For very long arrays, use BLOB.

The maximum size is 2 GB, but the whole object is kept in memory when using this data type. The precision is a size constraint; only the actual data is persisted. For large text data BLOB or CLOB should be used.

Hibernate default mapping

 
private byte[] rawtest;
@Column(name = "RAWTEST")
public byte[] getRawtest() {
    return this.rawtest;
}

BYTEA

Represents a byte array. For very long arrays, use BLOB.

The maximum size is 2 GB, but the whole object is kept in memory when using this data type. The precision is a size constraint; only the actual data is persisted. For large text data BLOB or CLOB should be used.

Hibernate default mapping

 
private byte[] byteatest;
@Column(name = "BYTEATEST")
public byte[] getByteatest() {
    return this.byteatest;
}

VARCHAR

A Unicode string. Use two single quotes ('') to create a quote.The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is loaded into memory when using this data type. For large text data CLOB should be used; see there for details.

Hibernate default mapping

 
private String varchartest;
@Column(name = "VARCHARTEST")
public String getVarchartest() {
    return this.varchartest;
}

LONGVARCHAR

A Unicode string. Use two single quotes ('') to create a quote.The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is loaded into memory when using this data type. For large text data CLOB should be used; see there for details.

Hibernate default mapping

 
private String longvarchartest;
@Column(name = "LONGVARCHARTEST")
public String getLongvarchartest() {
    return this.longvarchartest;
}

VARCHAR2

A Unicode string. Use two single quotes ('') to create a quote.The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is loaded into memory when using this data type. For large text data CLOB should be used; see there for details.

Hibernate default mapping

 
private String varchar2test;
@Column(name = "VARCHAR2TEST")
public String getVarchar2test() {
    return this.varchar2test;
}

NVARCHAR

A Unicode string. Use two single quotes ('') to create a quote.The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is loaded into memory when using this data type. For large text data CLOB should be used; see there for details.

Hibernate default mapping

 
private String nvarchartest;
@Column(name = "NVARCHARTEST")
public String getNvarchartest() {
    return this.nvarchartest;
}

NVARCHAR2

A Unicode string. Use two single quotes ('') to create a quote.The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is loaded into memory when using this data type. For large text data CLOB should be used; see there for details.

Hibernate default mapping

 
private String nvarchar2test;
@Column(name = "NVARCHAR2TEST")
public String getNvarchar2test() {
    return this.nvarchar2test;
}

VARCHARCASESENSITIVE

A Unicode string. Use two single quotes ('') to create a quote.The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.

The whole text is loaded into memory when using this data type. For large text data CLOB should be used; see there for details.

Hibernate default mapping

 
private String varcharCasesensitivetest;
@Column(name = "VARCHAR_CASESENSITIVETEST")
public String getVarcharCasesensitivetest() {
    return this.varcharCasesensitivetest;
}

VARCHARIGNORECASE

Same as VARCHAR, but not case-sensitive when comparing.

Stored in mixed case.The maximum precision is Integer.MAX_VALUE. The precision is a size constraint; only the actual data is persisted.The whole text is loaded into memory when using this data type.

For large text data CLOB should be used; see there for details.

Hibernate default mapping

 
private String varcharIgnorecasetest;
@Column(name = "VARCHAR_IGNORECASETEST")
public String getVarcharIgnorecasetest() {
    return this.varcharIgnorecasetest;
}

BLOB

Like BINARY, but intended for very large values such as files or images. Unlike when using BINARY, large objects are not kept fully in-memory. Use PreparedStatement.setBinaryStream to store values.See also CLOB and Advanced / Large Objects.

 
<sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
        {"byte[]"},"blob").addLobAnnotation());
 
private byte[] blobtest;
@Lob
@Column(name = "BLOBTEST", columnDefinition = "blob")
public byte[] getBlobtest() {
    return this.blobtest;
}

TINYBLOB

Like BINARY, but intended for very large values such as files or images. Unlike when using BINARY, large objects are not kept fully in-memory. Use PreparedStatement.setBinaryStream to store values.See also CLOB and Advanced / Large Objects.

 
<sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
        {"byte[]"},"blob").addLobAnnotation());
 
private byte[] tinyblobtest;
@Lob
@Column(name = "TINYBLOBTEST", columnDefinition = "blob")
public byte[] getTinyblobtest() {
    return this.tinyblobtest;
}

MEDIUMBLOB

Like BINARY, but intended for very large values such as files or images. Unlike when using BINARY, large objects are not kept fully in-memory. Use PreparedStatement.setBinaryStream to store values.See also CLOB and Advanced / Large Objects.

 
<sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
        {"byte[]"},"blob").addLobAnnotation());
 
private byte[] mediumblobtest;
@Lob
@Column(name = "MEDIUMBLOBTEST", columnDefinition = "blob")
public byte[] getMediumblobtest() {
    return this.mediumblobtest;
}

LONGBLOB

Like BINARY, but intended for very large values such as files or images. Unlike when using BINARY, large objects are not kept fully in-memory. Use PreparedStatement.setBinaryStream to store values.See also CLOB and Advanced / Large Objects.

 
<sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
        {"byte[]"},"blob").addLobAnnotation());
 
private byte[] longblobtest;
@Lob
@Column(name = "LONGBLOBTEST", columnDefinition = "blob")
public byte[] getLongblobtest() {
    return this.longblobtest;
}

IMAGE

Like BINARY, but intended for very large values such as files or images. Unlike when using BINARY, large objects are not kept fully in-memory. Use PreparedStatement.setBinaryStream to store values.See also CLOB and Advanced / Large Objects.

 
<sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
        {"byte[]"},"blob").addLobAnnotation());
 
private byte[] imagetest;
@Lob
@Column(name = "IMAGETEST", columnDefinition = "blob")
public byte[] getImagetest() {
    return this.imagetest;
}

OID

Like BINARY, but intended for very large values such as files or images. Unlike when using BINARY, large objects are not kept fully in-memory. Use PreparedStatement.setBinaryStream to store values.See also CLOB and Advanced / Large Objects.

 
<sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
        {"byte[]"},"blob").addLobAnnotation());
 
private byte[] oidtest;
@Lob
@Column(name = "OIDTEST", columnDefinition = "blob")
public byte[] getOidtest() {
    return this.oidtest;
}

CLOB

CLOB is like VARCHAR, but intended for very large values.

Unlike when using VARCHAR, large CLOB objects are not kept fully in-memory; instead, they are streamed. CLOB should be used for documents and texts with arbitrary size such as XML or HTML documents, text files, or memo fields of unlimited size.

Use PreparedStatment.setCharacterStream to store values.

VARCHAR should be used for text with relatively short average size (for example shorter than 200 characters). Short CLOB values are stored inline, but there is an overhead compared to VARCHAR.

 
<sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"CLOB"},
        new String[]{"java.lang.String"},"clob").addLobAnnotation());
 
private String clobtest;
@Lob
@Column(name = "CLOBTEST", columnDefinition = "clob")
public String getClobtest() {
    return this.clobtest;
}

TINYTEXT

CLOB is like VARCHAR, but intended for very large values.

Unlike when using VARCHAR, large CLOB objects are not kept fully in-memory; instead, they are streamed. CLOB should be used for documents and texts with arbitrary size such as XML or HTML documents, text files, or memo fields of unlimited size.

Use PreparedStatment.setCharacterStream to store values.

VARCHAR should be used for text with relatively short average size (for example shorter than 200 characters). Short CLOB values are stored inline, but there is an overhead compared to VARCHAR.

 
<sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"CLOB"},
        new String[]{"java.lang.String"},"clob").addLobAnnotation());
 
private String tinytexttest;
@Lob
@Column(name = "TINYTEXTTEST", columnDefinition = "clob")
public String getTinytexttest() {
    return this.tinytexttest;
}

TEXT

CLOB is like VARCHAR, but intended for very large values.

Unlike when using VARCHAR, large CLOB objects are not kept fully in-memory; instead, they are streamed. CLOB should be used for documents and texts with arbitrary size such as XML or HTML documents, text files, or memo fields of unlimited size.

Use PreparedStatment.setCharacterStream to store values.

VARCHAR should be used for text with relatively short average size (for example shorter than 200 characters). Short CLOB values are stored inline, but there is an overhead compared to VARCHAR.

 
<sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"CLOB"},
        new String[]{"java.lang.String"},"clob").addLobAnnotation());
 
private String texttest;
@Lob
@Column(name = "TEXTTEST", columnDefinition = "clob")
public String getTexttest() {
    return this.texttest;
}

CLOB is like VARCHAR, but intended for very large values.

Unlike when using VARCHAR, large CLOB objects are not kept fully in-memory; instead, they are streamed. CLOB should be used for documents and texts with arbitrary size such as XML or HTML documents, text files, or memo fields of unlimited size.

Use PreparedStatment.setCharacterStream to store values.

VARCHAR should be used for text with relatively short average size (for example shorter than 200 characters). Short CLOB values are stored inline, but there is an overhead compared to VARCHAR.

 
<sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"CLOB"},
        new String[]{"java.lang.String"},"clob").addLobAnnotation());
 
private String mediumtexttest;
@Lob
@Column(name = "MEDIUMTEXTTEST", columnDefinition = "clob")
public String getMediumtexttest() {
    return this.mediumtexttest;
}

LONG TEXT

CLOB is like VARCHAR, but intended for very large values.

Unlike when using VARCHAR, large CLOB objects are not kept fully in-memory; instead, they are streamed. CLOB should be used for documents and texts with arbitrary size such as XML or HTML documents, text files, or memo fields of unlimited size.

Use PreparedStatment.setCharacterStream to store values.

VARCHAR should be used for text with relatively short average size (for example shorter than 200 characters). Short CLOB values are stored inline, but there is an overhead compared to VARCHAR.

 
<sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"CLOB"},
        new String[]{"java.lang.String"},"clob").addLobAnnotation());
 
private String longtexttest;
@Lob
@Column(name = "LONGTEXTTEST", columnDefinition = "clob")
public String getLongtexttest() {
    return this.longtexttest;
}

NTEXT

CLOB is like VARCHAR, but intended for very large values.

Unlike when using VARCHAR, large CLOB objects are not kept fully in-memory; instead, they are streamed. CLOB should be used for documents and texts with arbitrary size such as XML or HTML documents, text files, or memo fields of unlimited size.

Use PreparedStatment.setCharacterStream to store values.

VARCHAR should be used for text with relatively short average size (for example shorter than 200 characters). Short CLOB values are stored inline, but there is an overhead compared to VARCHAR.

 
<sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"CLOB"},
        new String[]{"java.lang.String"},"clob").addLobAnnotation());
 
private String ntexttest;
@Lob
@Column(name = "NTEXTTEST", columnDefinition = "clob")
public String getNtexttest() {
    return this.ntexttest;
}

NCLOB

CLOB is like VARCHAR, but intended for very large values.

Unlike when using VARCHAR, large CLOB are not kept fully in-memory; instead, they are streamed. CLOB should be used for documents and texts with arbitrary size such as XML or HTML documents, text files, or memo fields of unlimited size.

Use PreparedStatment.setCharacterStream to store values.

VARCHAR should be used for text with relatively short average size (for example shorter than 200 characters). Short CLOB values are stored inline, but there is an overhead compared to VARCHAR.

 
<sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type>
visitor.addPropertyColumnDefinitionFix(
    new PropertyColumnDefinitionFix(new String[]{"CLOB"},
        new String[]{"java.lang.String"},"clob").addLobAnnotation());
 
private String nclobtest;
@Lob
@Column(name = "NCLOBTEST", columnDefinition = "clob")
public String getNclobtest() {
    return this.nclobtest;
}