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.
|
Code Block |
---|
language | java |
---|
theme | Confluence |
---|
| visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
new String[]{"CHARACTER"},new String[]{"java.lang.String"},"CHARACTER")); |
|
Code Block |
---|
| private String charactertest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
new String[]{"CHAR"},new String[]{"java.lang.String"},"CHAR")); |
|
Code Block |
---|
| private String chartest; |
Code Block |
---|
| @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. |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(new PropertyColumnDefinitionFix(
new String[]{"NCHAR"},new String[]{"java.lang.String"},"CHAR")); |
|
Code Block |
---|
| private String nchartest; |
Code Block |
---|
| @Column(name = "NCHARTEST", length = 10,
columnDefinition = "CHAR")
public String getNchartest() {
return this.nchartest;
} |
|
INT Possible values: -2147483648 to 2147483647. | Hibernate default mapping |
Code Block |
---|
| private int inttest; |
Code Block |
---|
| @Column(name = "INTTEST", unique = true,
nullable = false)
public int getInttest() {
return this.inttest;
} |
|
INTEGER Possible values: -2147483648 to 2147483647. | Hibernate default mapping |
Code Block |
---|
| private Integer integertest; |
Code Block |
---|
| @Column(name = "INTEGERTEST")
public Integer getIntegertest() {
return this.integertest;
} |
|
MEDIUMINT Possible values: -2147483648 to 2147483647. | Hibernate default mapping |
Code Block |
---|
| private Integer mediuminttest; |
Code Block |
---|
| @Column(name = "MEDIUMINTTEST")
public Integer getMediuminttest() {
return this.mediuminttest;
} |
|
INT4 Possible values: -2147483648 to 2147483647. | Hibernate default mapping |
Code Block |
---|
| private Integer int4test; |
Code Block |
---|
| @Column(name = "INT4TEST")
public Integer getInt4test() {
return this.int4test;
} |
|
SIGNED Possible values: -2147483648 to 2147483647. | Hibernate default mapping |
Code Block |
---|
| private Integer signedtest; |
Code Block |
---|
| @Column(name = "SIGNEDTEST")
public Integer getSignedtest() {
return this.signedtest;
} |
|
BOOLEAN Possible values: TRUE and FALSE . | Hibernate default mapping |
Code Block |
---|
| private Boolean booleantest; |
Code Block |
---|
| @Column(name = "BOOLEANTEST")
public Boolean getBooleantest() {
return this.booleantest;
} |
|
BIT Possible values: TRUE and FALSE . | Hibernate default mapping |
Code Block |
---|
| private Boolean bittest; |
Code Block |
---|
| @Column(name = "BITTEST")
public Boolean getBittest() {
return this.bittest;
} |
|
BOOL Possible values: TRUE and FALSE . | Hibernate default mapping |
Code Block |
---|
| private Boolean booltest; |
Code Block |
---|
| @Column(name = "BOOLTEST")
public Boolean getBooltest() {
return this.booltest;
} |
|
TINYINT Possible values are: -128 to 127. | Hibernate default mapping |
Code Block |
---|
| private Byte tinyinttest; |
Code Block |
---|
| @Column(name = "TINYINTTEST")
public Byte getTinyinttest() {
return this.tinyinttest;
} |
|
SMALLINT Possible values: -32768 to 32767. | Hibernate default mapping |
Code Block |
---|
| private Short smallinttest; |
Code Block |
---|
| @Column(name = "SMALLINTTEST")
public Short getSmallinttest() {
return this.smallinttest;
} |
|
INT2 Possible values: -32768 to 32767. | Hibernate default mapping |
Code Block |
---|
| private Short int2test; |
Code Block |
---|
| @Column(name = "INT2TEST")
public Short getInt2test() {
return this.int2test;
} |
|
YEAR Possible values: -32768 to 32767. | Hibernate default mapping |
Code Block |
---|
| private Short yeartest; |
Code Block |
---|
| @Column(name = "YEARTEST")
public Short getYeartest() {
return this.yeartest;
} |
|
BIGINT Possible values: -9223372036854775808 to 9223372036854775807. | Hibernate default mapping |
Code Block |
---|
| private Long biginttest; |
Code Block |
---|
| @Column(name = "BIGINTTEST")
public Long getBiginttest() {
return this.biginttest;
} |
|
INT8 Possible values: -9223372036854775808 to 9223372036854775807. | Hibernate default mapping |
Code Block |
---|
| private Long int8test; |
Code Block |
---|
| @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 |
Code Block |
---|
| private Long identitytest; |
Code Block |
---|
| @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 |
Code Block |
---|
| private BigDecimal decimaltest; |
Code Block |
---|
| @Column(name = "DECIMALTEST", precision = 20)
public BigDecimal getDecimaltest() {
return this.decimaltest;
} |
Code Block |
---|
| private Double decimaltest; |
Code Block |
---|
| @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 |
Code Block |
---|
| private BigDecimal numbertest; |
Code Block |
---|
| @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 |
Code Block |
---|
| private BigDecimal dectest; |
Code Block |
---|
| @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 |
Code Block |
---|
| private BigDecimal numerictest; |
Code Block |
---|
| @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 |
Code Block |
---|
| private Double doubletest; |
Code Block |
---|
| @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 |
Code Block |
---|
| private Double floattest; |
Code Block |
---|
| @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 |
Code Block |
---|
| private Double float8test; |
Code Block |
---|
| @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. |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"REAL"},
new String[]{"java.lang.Float","float"},"real")); |
|
Code Block |
---|
| private Float realtest; |
Code Block |
---|
| @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. |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"REAL"},
new String[]{"java.lang.Float","float"},"real")); |
|
Code Block |
---|
| private Float float4test; |
Code Block |
---|
| @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
|
Code Block |
---|
| private Date timetest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private Date datetest; |
Code Block |
---|
| @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[.nnnnnnnnn]. | Hibernate default mapping
|
Code Block |
---|
| private Date timestamptest; |
Code Block |
---|
| @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[.nnnnnnnnn]. | Hibernate default mapping
|
Code Block |
---|
| private Date datetimetest; |
Code Block |
---|
| @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[.nnnnnnnnn]. | Hibernate default mapping
|
Code Block |
---|
| private Date smalldatetimetest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private byte[] binarytest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private byte[] varbinarytest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private byte[] longvarbinarytest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private byte[] rawtest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private byte[] byteatest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private String varchartest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private String longvarchartest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private String varchar2test; |
Code Block |
---|
| @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
|
Code Block |
---|
| private String nvarchartest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private String nvarchar2test; |
Code Block |
---|
| @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
|
Code Block |
---|
| private String varcharCasesensitivetest; |
Code Block |
---|
| @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
|
Code Block |
---|
| private String varcharIgnorecasetest; |
Code Block |
---|
| @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. |
Code Block |
---|
| <sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
{"byte[]"},"blob").addLobAnnotation()); |
|
Code Block |
---|
| private byte[] blobtest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
{"byte[]"},"blob").addLobAnnotation()); |
|
Code Block |
---|
| private byte[] tinyblobtest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
{"byte[]"},"blob").addLobAnnotation()); |
|
Code Block |
---|
| private byte[] mediumblobtest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
{"byte[]"},"blob").addLobAnnotation()); |
|
Code Block |
---|
| private byte[] longblobtest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
{"byte[]"},"blob").addLobAnnotation()); |
|
Code Block |
---|
| private byte[] imagetest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="BLOB" hibernate-type="byte[]"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"BLOB"},new String[]
{"byte[]"},"blob").addLobAnnotation()); |
|
Code Block |
---|
| private byte[] oidtest; |
Code Block |
---|
| @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. |
Code Block |
---|
| <sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"CLOB"},
new String[]{"java.lang.String"},"clob").addLobAnnotation()); |
|
Code Block |
---|
| private String clobtest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"CLOB"},
new String[]{"java.lang.String"},"clob").addLobAnnotation()); |
|
Code Block |
---|
| private String tinytexttest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"CLOB"},
new String[]{"java.lang.String"},"clob").addLobAnnotation()); |
|
Code Block |
---|
| private String texttest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"CLOB"},
new String[]{"java.lang.String"},"clob").addLobAnnotation()); |
|
Code Block |
---|
| private String mediumtexttest; |
Code Block |
---|
| @Lob
@Column(name = "MEDIUMTEXTTEST", columnDefinition = "clob")
public String getMediumtexttest() {
return this.mediumtexttest;
} |
|
LONGTEXT 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.
|
Code Block |
---|
| <sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"CLOB"},
new String[]{"java.lang.String"},"clob").addLobAnnotation()); |
|
Code Block |
---|
| private String longtexttest; |
Code Block |
---|
| @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.
|
Code Block |
---|
| <sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"CLOB"},
new String[]{"java.lang.String"},"clob").addLobAnnotation()); |
|
Code Block |
---|
| private String ntexttest; |
Code Block |
---|
| @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 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.
|
Code Block |
---|
| <sql-type jdbc-type="CLOB" hibernate-type="java.lang.String"></sql-type> |
Code Block |
---|
| visitor.addPropertyColumnDefinitionFix(
new PropertyColumnDefinitionFix(new String[]{"CLOB"},
new String[]{"java.lang.String"},"clob").addLobAnnotation()); |
|
Code Block |
---|
| private String nclobtest; |
Code Block |
---|
| @Lob
@Column(name = "NCLOBTEST", columnDefinition = "clob")
public String getNclobtest() {
return this.nclobtest;
}
|
|