In my last post I showed a simple way of persisting an entity. I explained the default approach that JPA uses to determine the default table for an entity. Let’s assume that we want to override this default name. We may like to do so because the data model has been designed and fixed before and the table names do not match with our class names (I have seen people to create tables with “tbl_” prefix, for example). So how should we override the default table names to match the existing data model?
Turns out, it’s pretty simple. If we need to override the default table names assumed by JPA, then there are a couple of ways to do it:
- We can use the name attribute of the @Entity annotation to provide an explicit entity name to match with the database table name. For our example we could have used @Entity(name = “tbl_address”) in our Address class if our table name was tbl_address.
- We can use a @Table (defined in the javax.persistence package) annotation just below the @Entity annotation and use its name attribute to specify the table name explicitly.
@Entity
@Table(name = "tbl_address")
public class Address {
// Rest of the class
}From these two approaches the @Table annotation provides more options to customize the mapping. For example, some databases like PostgreSQL have a concept of schemas, using which you can further categorize/group your tables. Because of this feature you can create two tables with the same name in a single database (although they will belong to two different schemas). To access these tables you then add the schema name as the table prefix in your query. So if a PostgreSQL database has two different schemas named public (which is sort of like default schema for a PostgreSQL database) and document, and both of these schemas contain tables named document_collection, then both of these two queries are perfectly valid:
-- fetch from the table under public schema SELECT * FROM public.document_collection; -- fetch from the table under document schema SELECT * FROM document.document_collection;
In order to map an entity to the document_collection table in the document schema, you will then use the @Table annotation with its schema attribute set to document:
@Entity
@Table(name="document_collection", schema="document")
public class DocumentCollection {
// rest of the class
}When specified this way, the schema name will be added as a prefix to the table name when the JPA goes to the database to access the table, just like we did in our queries.
What if rather than specifying the schema name in the @Table annotation you append the schema name in the table name itself, like this:
@Entity
@Table(name = "document.document_collection")
public class DocumentCollection {
// rest of the class
}Inlining the schema name with the table name this way is not guaranteed to work across all JPA implementations because support for this is not specified in the JPA specification (non-standard). So it’s better if you do not make a habit of doing this even if your persistence provider supports it.
Let’s turn our attention to the columns next. In order to determine the default columns, JPA does something similar to the following:
- At first it checks to see if any explicit column mapping information is given. If no column mapping information is found, it tries to guess the default values for columns.
- To determine the default values, JPA needs to know the access type of the entity states i.e., the way to read/write the states of the entity. In JPA two different access types are possible – field and property. For our example we have used the field access (actually JPA assumed this from the location/placement of the @Id annotation, but more on this later). If you use this access type then states will be written/read directly from the entity fields using the Reflection API.
- After the access type is known, JPA then tries to determine the column names. For field access type JPA directly treats the field name as the column names, which means if an entity has a field named status then it will be mapped to a column named status.
At this point it should be clear to us how the states of the Address entities got saved into the corresponding columns. Each of the fields of the Address entity has an equivalent column in the database table tbl_address, so JPA directly saved them into their corresponding columns. The id field was saved into the id column, city field into the city column and so on.
OK then, let’s move on to overriding column names. As far as I know there is only one way (if you happen to know of any other way please comment in!) to override the default column names for entity states, which is by using the @Column (defined in the javax.persistence package) annotation. So if the id column of the tbl_address table is renamed to be address_id then we could either change our field name to address_id, or we could use the @Column annotation with its name attribute set to address_id:
@Entity
@Table(name = "tbl_address")
public class Address {
@Id
@GeneratedValue
@Column(name = "address_id")
private Integer id;
// Rest of the class
}You can see that for all the above cases the default approaches that JPA uses are quite sensible, and most of the cases you will be happy with it. However, changing the default values are also very easy and can be done very quickly.
What if we have a field in the Address entity that we do not wish to save in the database? Suppose that the Address entity has a column named transientColumn which does not have any corresponding default column in the database table:
@Entity
@Table(name = "tbl_address")
public class Address {
@Id
@GeneratedValue
@Column(name = "address_id")
private Integer id;
private String street;
private String city;
private String province;
private String country;
private String postcode;
private String transientColumn;
// Rest of the class
}If you compile your code with the above change then you will get an exception which looks something like below:
Exception in thread “main” java.lang.ExceptionInInitializerError at com.keertimaan.javasamples.jpaexample.Main.main(Main.java:33) Caused by: javax.persistence.PersistenceException: Unable to build entity manager factory at org.hibernate.jpa.HibernatePersistenceProvider.createEntityManagerFactory(HibernatePersistenceProvider.java:83) at org.hibernate.ejb.HibernatePersistence.createEntityManagerFactory(HibernatePersistence.java:54) at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:55) at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:39) at com.keertimaan.javasamples.jpaexample.persistenceutil.PersistenceManager.<init>(PersistenceManager.java:31) at com.keertimaan.javasamples.jpaexample.persistenceutil.PersistenceManager.<clinit>(PersistenceManager.java:26) … 1 more Caused by: org.hibernate.HibernateException: Missing column: transientColumn in jpa_example.tbl_address at org.hibernate.mapping.Table.validateColumns(Table.java:365) at org.hibernate.cfg.Configuration.validateSchema(Configuration.java:1336) at org.hibernate.tool.hbm2ddl.SchemaValidator.validate(SchemaValidator.java:155) at org.hibernate.internal.SessionFactoryImpl.<init>(SessionFactoryImpl.java:525) at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1857) at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl$4.perform(EntityManagerFactoryBuilderImpl.java:850) at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl$4.perform(EntityManagerFactoryBuilderImpl.java:843) at org.hibernate.boot.registry.classloading.internal.ClassLoaderServiceImpl.withTccl(ClassLoaderServiceImpl.java:398) at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:842) at org.hibernate.jpa.HibernatePersistenceProvider.createEntityManagerFactory(HibernatePersistenceProvider.java:75) … 6 more
The exception is saying that the persistence provider could not find any column in the database whose name is transientColumn, and we did not do anything to make it clear to the persistence provider that we do not wish to save this field in the database. The persistence provider took it as any other fields in the entity which are mapped to database columns.
In order to fix this problem, we can do any of the following:
- We can annotate the transientColumn field with the @Transient (defined in javax.persistence package) annotation to let the persistence provider know that we do not wish to save this field, and it does not have any corresponding column in the table.
- We can use the transient keyword that Java has by default.
The difference between these two approaches that comes to my mind is that, if we use the transient keyword instead of the annotation, then if one of the Address entities gets serialized from one JVM to another then the transientColumn field will get reinitialized again (just like any other transient fields in Java). For the annotation, this will not happen and the transientColumn field will retain its value across the serialization. As a rule of thumb, I always use the annotation if I do not need to worry about serialization (and in most of the cases I don’t).
So using the annotation, we can fix the problem right away:
@Entity
@Table(name = "tbl_address")
public class Address {
@Id
@GeneratedValue
@Column(name = "address_id")
private Integer id;
private String street;
private String city;
private String province;
private String country;
private String postcode;
@Transient
private String transientColumn;
// Rest of the class
}So that’s it for today folks. If you find any mistakes/have any input, please feel free to comment in!
Until next time.
| Reference: | JPA Tutorial: Mapping Entities – Part 2 from our JCG partner Sayem Ahmed at the Codesod blog. |
