Posted on August 8, 2017 by vladmihalcea

How to store schema-less EAV (Entity-Attribute-Value) data using JSON and Hibernate

Last modified:

Introduction

One of my Twitter followers has recently asked me about a way of storing EAV (Entity-Attribute-Value) data using JPA and Hibernate, and, because this is a very good question, I decided to turn into a blog post.

In this article, you are going to see how you can use JSON types to store schema-less EAV data.

6 Comments

Posted on August 2, 2017 by vladmihalcea

How to optimize the merge operation using update while batching with JPA and Hibernate

Last modified:

Follow @vlad_mihalcea

Introduction

One of my readers has recently asked me about optimizing the merge entity state transition, and, because this is a great question, I decided to turn it into a blog post.

In this article, you are going to see a shortcoming of the merge entity state transition and how you can deal with it using Hibernate.

4 Comments

Posted on July 26, 2017 by vladmihalcea

The best way to map a JPA and Hibernate many-to-many association with extra columns

Last modified:

Follow @vlad_mihalcea

Introduction

For a simple many-to-many database relationship, you can use the @ManyToMany JPA annotation and, therefore, hide the join table.

However, sometimes you need more than the two Foreign Key columns in the join table, and, for this purpose, you need to replace the @ManyToMany association with two bidirectional @OneToMany associations. Unlike unidirectional @OneToMany, the bidirectional relationship is the best way to map a one-to-many database relationship that requires a collection of Child elements on the parent side

In this article, we are going to see how you can map a many-to-many database relationship using an intermediary entity for the join table. This way, we can map additional columns that would be otherwise impossible to persist using the @ManyToMany JPA annotation.

Leave a Comment

Posted on July 19, 2017 by vladmihalcea

How to extract change data events from MySQL to Kafka using Debezium

Last modified:

Follow @vlad_mihalcea

Introduction

As previously explained, CDC (Change Data Capture) is one of the best ways to interconnect an OLTP database system with other systems like Data Warehouse, Caches, Spark or Hadoop.

Debezium is an open-source project developed by Red Hat which aims to simplify this process by allowing you to extract changes from various database systems (e.g. MySQL, PostgreSQL, MongoDB) and push them to Apache Kafka.

In this article, we are going to see how you can extract events from MySQL binary logs using Debezium.

Leave a Comment

Posted on July 17, 2017 by vladmihalcea

Book Review – High Performance MySQL (3rd edition)

Last modified:

Follow @vlad_mihalcea

Introduction

I either have time for reading or writing, but not both. Now that the first edition of High-Performance Java Persistence is done, I can catch up on the many books I planned on reading but didn’t have time to do so.

In this post, I’m going to review High Performance MySQL by Baron Schwartz, Peter Zaitsev, and Vadim Tkachenkoa, which is a must-read book for anyone working with MySQL.

High Performance MySQL

Leave a Comment

Posted on July 4, 2017 by vladmihalcea

What’s new in JPA 2.2 – Stream the result of a Query execution

Last modified:

Follow @vlad_mihalcea

Introduction

In this article, we are going to see how the JPA 2.2 Stream query results are supported by Hibernate and the caveats of using database cursors just to limit the amount of data that needs to be fetched.

Leave a Comment

Posted on June 28, 2017 by vladmihalcea

A beginner’s guide to CDC (Change Data Capture)

Last modified:

Follow @vlad_mihalcea

Introduction

In this article, I’m going to explain what CDC (Change Data Capture) is, and why you should use it to extract database row-level changes.

In OLTP (Online Transaction Processing) systems, data is accessed and changed concurrently by multiple transactions, and the database changes from one consistent state to another. An OLTP system always shows the latest state of our data, therefore facilitating the development of front-end applications that require near real-time data consistency guarantees.

However, an OLTP system is no island, being just a small part of a larger system that encapsulates all data transformation needs required by a given enterprise. When integrating an OLTP system with a Cache, a Data Warehouse, or an In-Memory Data Grid, we need an ETL process to collect the list of events that changed the OLTP system data over a given period of time.

In this article, we are going to see various methods used for capturing events and propagating them to other data processing systems.

Leave a Comment

Posted on June 26, 2017 by vladmihalcea

What’s new in JPA 2.2 – Java 8 Date and Time Types

Last modified:

Follow @vlad_mihalcea

Introduction

In this article, we are going to see how JPA 2.2 Date/Time works, and which types you need to use depending on your business case requirements.

Leave a Comment

Posted on June 21, 2017 by vladmihalcea

How to map Java and SQL arrays with JPA and Hibernate

Last modified:

Follow @vlad_mihalcea

Introduction

In this article, we are going to see how you can map SQL arrays to JPA entity attributes when using Hibernate.

Hibernate custom Types allow you to map all sorts of database-specific column types, like IP address, JSON columns, bit sets, or SQL arrays.

However, while you can create your own custom Hibernate Types for mapping PostgreSQL arrays, you don’t need to implement your own Hibernate Type. All you need to do is use the Hypersistence Utils open-source project.

Leave a Comment

Posted on June 13, 2017 by vladmihalcea

The best way to map the @DiscriminatorColumn with JPA and Hibernate

Last modified:

Follow @vlad_mihalcea

Introduction

As previously explained, the SINGLE_TABLE inheritance is the most efficient entity inheritance strategy.

However, for JPQL query such as this one:

List<Post> posts = entityManager
.createQuery(
    "select p " +
    "from Post p " +
    "where p.board = :board", Post.class)
.setParameter("board", board)
.getResultList();

Hibernate generates a SQL query which filters by the associated discriminator column (e.g. DTYPE by default):

SELECT t.id AS id2_1_,
       t.board_id AS board_id8_1_,
       t.createdOn AS createdO3_1_,
       t.owner AS owner4_1_,
       t.title AS title5_1_,
       t.content AS content6_1_
FROM   topic t
WHERE  t.DTYPE = 'Post'
       AND t.board_id = 1

So, because we are filtering by the discriminator column, we might want to index it or include it to speed up queries.

However, the default STRING DiscriminatorType expects a VARCHAR column that must hold the longest entity subclass name. For the Announcement class, we need at least 12 bytes to store the entity class name while for the Post entity, 4 bytes are required.

If the discriminator type column is indexed and we store 1 million Announcement and 100 million Post entities, the index will require 393 MB (12 + 400 million bytes). On the other hand, if the discriminator column is a TINYINT (only 1 byte is needed to store a discriminator value), we need only 96 MB (1 + 100 million bytes).

In this article, I’m going to explain how you can get the most out of the INTEGER DiscriminatorType while still retaining the descriptiveness of the default STRING DiscriminatorType.

Vlad Mihalcea

How to store schema-less EAV (Entity-Attribute-Value) data using JSON and Hibernate

Introduction

How to optimize the merge operation using update while batching with JPA and Hibernate

Introduction

The best way to map a JPA and Hibernate many-to-many association with extra columns

Introduction

How to extract change data events from MySQL to Kafka using Debezium

Introduction

Book Review – High Performance MySQL (3rd edition)

Introduction

What’s new in JPA 2.2 – Stream the result of a Query execution

Introduction

A beginner’s guide to CDC (Change Data Capture)

Introduction

What’s new in JPA 2.2 – Java 8 Date and Time Types

Introduction

How to map Java and SQL arrays with JPA and Hibernate

Introduction

The best way to map the @DiscriminatorColumn with JPA and Hibernate

Introduction

Let’s connect

Find Article

Book

Video Courses

Sponsored

Training

Hypersistence Optimizer

Tutorials

Social Media

About

Meta