Saturday June 07, 2003
Saturday June 07, 2003
RE: While I'm choosing Hibernate over JDO ... for now
Now I will talk to you about the dealbreaker - the one thing about JDO that pushed me pretty rapidly over to the Hibernate camp: the query language. The JDO query language is just poor, very poor and of a syntax that only the designer could appreciate.
Class gameObjectClass = com.foo.GameObject.class;
Extent oldObjects = pm.getExtent (gameObjectClass, false);
String filter = "age > 25";
Query q = pm.newQuery (gameObjectClass, oldObjects, filter);
Collection oldGameObjects = q.execute ();
This unfortunately gets more and more complex as you have to introduce other variables into the query. This is a major failing of JDO IMO. Hibernate was just so much easier to deal with from the query perspective (and since that's what you'll be spending most of your time doing...).
List oldObjects = sess.find( "from obj in class com.foo.GameObjects where age > 25" );
Big difference in both presentation, LOC and generally understandability in my opinion. [Nation of Greg :: Redux]
I have to agree with Greg here. Hibernate's query language (HQL) is extremely easy to use. In fact, I've been amazed at how I've been able to guess the syntax and get it right 9 times out of 10! It's the best of SQL and OQL. If you think HQL is good - wait until you checkout the Query by Criteria syntax (very cool IMO). There's supposed to be a Hibernate 2.0 Final this weekend... only 26 hours left in my neck of the woods. 
Posted in Java
at Jun 07 2003, 09:53:49 PM MDT
6 Comments
Search This Site
Recent Entries
- Happy Birthday Jack!
- A Good Friend becomes a DU Hockey Coach
- What's wrong with JSF
- Why such a busy week?
- New Passport in 9 Days
- EhCache Project Busy this Summer
- Spontaneous Stuff Weekend
- Awesome Birthday Present: A Kegerator
- Maven Plugin for Running Integration Tests against Multiple Containers
- Presenting Web Frameworks of the Future Tomorrow in Denver
Query query = pm.newQuery(pm.getExtent(GameObject.class, false));
query.setFilter("age > 25");
Collection oldGameObjects = (Collection) q.execute ();
That would be...3 lines.
And I know it's just that I'm no sql guru, but I find the JDO syntax a lot easier to read than "from obj in class com.foo.GameObjects where age > 25". Of course, that's what jdo is aiming for - java-like syntax, not sql-like syntax. And since I'm lazy ;-) I'd rather not learn more new syntax.
Posted by Paul Rivers on June 08, 2003 at 10:23 PM MDT #
And if 25 wasn't hardcoded, you be be using name parameters for your hibernate query - in which case you would have another line or two of code, while the jdo query would stay the same size.
Posted by PaulRivers on June 09, 2003 at 10:19 AM MDT #
Query query = pm.newQuery(pm.getExtent(GameObject.class, false));
query.setFilter("age > ageParam");
query.declareParameters("int ageParam")
Collection oldGameObjects = (Collection)
q.execute(new Integer(25));
Posted by PaulRivers on June 09, 2003 at 10:32 AM MDT #
Whereas the Hibernate case would not:
List oldObjects = sess.find("from GameObjects go where go.age > ?", age, Hibernate.INTEGER);
;)
okay, if you use Hibernate named parameters, to make it a fair comparison, the Hibernate version becomes:
session.createQuery("from GameObjects go where go.age > :age").setInteger("age", age).list();
Which is still much less verbose.
Posted by Gavin on June 09, 2003 at 08:08 PM MDT #
Posted by Paul Rivers on June 10, 2003 at 11:53 PM MDT #
Posted by fds on April 26, 2005 at 04:34 AM MDT #