Mapping primitive data types

Supported data types

During the previous three levels, we got a little familiar with Hibernate. It's time for the second round. Now we will begin to study the same thing, only deeper. And we will start by mapping the fields of the Entity class to the columns of the tables in the database.

As you already know, mapping a field in an Entity class to a column is done using the @Column annotation . And now the question is: what types of fields can be mapped with such an annotation?

All data types in Java can be divided into three groups:

• The type is quite simple and easy to store in a database .
• The type is complex and you need to write a special converter for it .
• The type is very complex and needs a separate table to store its values .

Simple types that Hibernate knows how to store include:

All of these types have their counterparts in the SQL language, so Hibernate knows how to store and load them from the database.

Example:

@Entity
@Table(name="user")
class User
{
   @Column(name="id")
   public Integer id;

   @Column(name="name")
   public String name;

   @Column(name="level")
   public Integer level;

   @Column(name="created_date")
   public Date createdDate;
}

Manual type assignments - @Type annotation

Sometimes you may want to tamper with Hibernate's policy and explicitly tell it what type to store data in the database. For example, you have a field in your Entity class of type Integer, but in the base there is a column for it with type VARCHAR.

There is a special annotation for this - @Type . It looks very simple:

@Type(type="type-name")

Let's, for example, ask Hibernate to make the fieldcreatedDateof our User class was stored in the database as a string:

@Entity
@Table(name="user")
class User
{
   @Column(name="id")
    public Integer id;

   @Column(name="created_date")
   @Type(type="org.hibernate.type.StringType")
    public Date createdDate;
}

If Hibernate figured out how to convert the Date type to your new type, then it would just do it. If it does not understand, then you will need to specify a special type converter. But more on that later.

List of Hibernate types for databases

By the way, did you notice that we specified the type org.hibernate.type.StringType , not String . This is because we have chosen one of the types supported by the DBMS and not by the Java language. They each have their own type system. It's just that the Hibernate developers came up with convenient Java-style names instead of these VARCHARs.

By the way, this list is not so small. I'll give part of it here:

The table, of course, is large, but very useful. For example, it is clear from it that the Boolean type can be stored in the database in at least six different ways. Don't you need that much? And who said that you choose the way to save?

There is no Boolean type in SQL and it is often stored like this:

• 1 or 0
• 'F' or 'T'
• 'Y' or 'N'

Therefore, it is very good when Hibernate understands all these troubles. Or, for example, let's take the storage of data arrays in the database. There are a bunch of different options, and Hibernate knows how to work with them all: