Years ago, I was given a task, to create a backend microservice connected to schema having over 300 rich tables, using a JPA/Hibernate.
I was afraid of the scope. I realized, I have to write a lot of 'find' methods and multiply the code into many various places.
Also I realized, how difficult describing so many relations into JPA, will be.
It was also a time, when Java8 had been released.
I wanted to use Java8 default methods to apply a single point of code approach, into many places, through interface inheritance.
Instead of starting the work immediately, I decided to make a JPA extension previously, to make my work more efficient.
This is how the first version of Daobab had been created.
Indeed, at the beginning, it was just a JPA extension. I didn't want to write an ORM from the very beginning. In fact I was convinced, it wasn't possible to make it any better.
The first version of Daobab worked fine. Indeed, it helped me work faster.
However, describing relations via interfaces, creating them from the very beginning, was complicated.
Daobab required more effort at the start-up, to describe relations. It was an obstacle.
I realized, the new approach I designed, wasn't compliant with the old JPA one, designed before Java8. There was too much of a limitation, deep inside JPA.
I realized, that the problematic JPA features, were embedded into core functionality and because of the backward compatibility, will last forever...
I was thinking, how to deal with this... and then I realized, the only way to do it, was to abandon JPA completely, and connect directly to JDBC, using quite a new approach - entities based on unique column interfaces.
I had to create a very large refactoring, but finally, it worked and it worked well.
From this moment on, the interfaces describing relations, were automatically generated. TypeSafe querying was possible without any problems. Java query became truly object oriented.
It was when the main version of Daobab, which was no longer a JPA extension, but a complete and independent, totally new approach, was created.
Till now, I've spent over 3 years, constantly improving this library.
I've added a lot of useful features.
I found a way, how to use SQL queries over collections, quick byte buffers and remotely. Also how to work efficiently with joins, inner queries, OCC and many many more.
My goal was to create a very pleasant ORM library, which could be bug-resistant, could use IDE support and was easy to test.
In my opinion, this is working quite well.
This library gives not only unprecedented joy of building an SQL, but also speeds up the development process greatly.
Because of deep TypeSafe and IDE query validation, it's very hard to commit a mistake.
These are all the reasons, why SQL querying with Daobab is so pleasant and fast.
Some people say, there is no sense in building another ORM, if we have a few already. Well... those people have never used this library.
I encourage you to get familiar with Daobab and have some fun with it.
I know, there is a lot of content. ORM is a large subject. Not everything is well documented yet, but for sure, you will enjoy this solution quickly, right after the first queries.
Please let me know your thoughts. Any feedback, honest opinion is very important and helps to make this idea better.
If you like this library, and you want to support my work, I would like to ask you to share information about Daobab with others.
One of the biggest problems I have, is how to reach busy people. It's the real challenge.
Thank you very much.
The first program I wrote was on Commodore 64.
As a teenager, I was an assembler coder on the Amiga Scene.
As an adult, I was working for a few polish banks, telecommunication companies and an aircraft movement software producer.
What brings me the most joy is the spontaneous programming, without a strictly specified plan, goal and deadline.
Often, it brings the most unexpected and positive results.