{"id":744,"date":"2009-10-26T23:24:22","date_gmt":"2009-10-26T22:24:22","guid":{"rendered":"http:\/\/www.gamlor.info\/wordpress\/?p=744"},"modified":"2021-03-11T09:44:57","modified_gmt":"2021-03-11T08:44:57","slug":"db4o-queries-in-java-or-queries-without-linq","status":"publish","type":"post","link":"https:\/\/www.gamlor.info\/wordpress\/2009\/10\/db4o-queries-in-java-or-queries-without-linq\/","title":{"rendered":"db4o: Queries in Java or Queries Without LINQ"},"content":{"rendered":"

Before I continue with client-server concurrency I explain how to run queries against a db4o database without LINQ. Most of the stuff in db4o works on every platform. The API is nearly the same in Java and .NET, except the different naming-convections. The lucky .NET developers have one big advantage over Java, they have LINQ which is just awesome. The less lucky Java or C# 2.0 developers have to use other methods. So I\u2019ll give an overview over the alternative query-methods. For this post I use Java instead of C# to avoid using LINQ by accident \ud83d\ude09<\/p>\n

\"db4o-java-bff\"<\/a><\/p>\n

(All posts of this series: the basics<\/a>, activation<\/a>, object-identity<\/a>, transactions<\/a>, persistent classes<\/a>, single container concurrency<\/a>, Queries in Java, C# 2.0<\/a>, client-server concurrency<\/a>, transparent persistence<\/a>, adhoc query tools<\/a>)<\/p>\n

Native Queries<\/h3>\n

When you hear \u2018Native Queries\u2019<\/a> you might think that it is something like SQL. The language which is \u2018native\u2019 to the database. You\u2019re wrong. It means that it\u2019s \u2018native\u2019 to your programming language. So you write queries just as Java-Code. Native queries are in my opinion the best alternative to LINQ<\/a>. Basically you pass a inner class (poor man\u2019s closures) to the query-method. There you implement which criteria have to be fulfilled. A simple example:<\/p>\n

List<SimpleObject> result = db.query(new<\/span> Predicate<SimpleObject>() {\r\n    @Override\r\n    public<\/span> boolean match(SimpleObject o) {\r\n        return<\/span> o.getNumber()>2;\r\n    }\r\n});<\/pre>\n
\u00a0<\/pre>\n
So this quite easy and natural. You just write your condition in the match-method of a predicate. A more complex example which also sorts the result:<\/p>\n
List<ComplexObject> result2 = db.query(new<\/span> Predicate<ComplexObject>() {\r\n@Override\r\npublic<\/span> boolean match(ComplexObject o) {\r\n    return<\/span> o.getVersion()==1\r\n            && o.getKnowsAbout().getNumber()<2\r\n            || o.getMightKnowsAlso()!=null<\/span>;\r\n}\r\n},new<\/span> QueryComparator<ComplexObject>() {\r\n    public<\/span> int<\/span> compare(ComplexObject complexObject, ComplexObject complexObject1) {\r\n        return<\/span> complexObject.getKnowsAbout().getName().compareTo(complexObject1.getKnowsAbout().getName());\r\n    }\r\n});\u00a0<\/pre>\n
Modern Java-IDEs collapse the verbose inner classes to readable little \u2018closures\u2019. Therefore it looks nicer in the real world. (Eclipse with lambda4jdt<\/a>, IntelliJ 9<\/a>)<\/p>\n
\"native<\/a>
native queries<\/p><\/div>\n
Query By Example<\/h3>\n
In this query-type<\/a> you give the database an object as an example. Then the database returns all objects which are similar to the given object.<\/p>\n
An example. We create an new object with name \u2018MyObject-3\u2019 and the number 3. Then we pass it to db4o. As result we get all object which have the same name and number.<\/p>\n
SimpleObject toSearchFor = new<\/span> SimpleObject(\"MyObject-3\"<\/span>,3);\r\nfinal ObjectSet<Object> result1 = db.queryByExample(toSearchFor);<\/pre>\n
It\u2019s simple but quite limiting. It\u2019s might a suitable solution when you implement some kind of search-forms.\u00a0Then you\u00a0just can fill an object with values of the search-form and off you go. But you can imagine the limits. For example you cannot get the objects which have number==0. Because query by example only matches fields which differ from the default-value. For a int 0 is the default and you\u2019re fucked. As far as I know there\u2019s no way to express such condition by example. So you have to use other query-types.<\/p>\n
System.out<\/span>.println(\"-cannot get the object with Number=0---\"<\/span>);\r\nSimpleObject doesnotWork = new<\/span> SimpleObject(0);\r\nfinal ObjectSet<Object> result2 = db.queryByExample(doesnotWork);<\/pre>\n
\r\n\r\n
\"query<\/a>
query be example<\/p><\/div><\/pre>\n
SODA-Queries<\/h3>\n
Now SODA-Queries<\/a> is the low level query API for db4o. Normally you don\u2019t touch SODA unless you have some special scenarios. For example when you need to build queries very dynamically. Because of that I just mention it here but don\u2019t give any examples (Maybe another time).<\/p>\n
All other query-types, LINQ, Native-Queries and Query By Example are actually translated into SODA-queries. To achieve this db4o uses byte-code analysis and generates then SODA-queries. Simple queries are translated into SODA an run directly on the database. However more complex queries may cannot be optimized. Then db4o actually instantiates the objects and runs the query on the instances. For more details see here: LINQ-Optimization<\/a>, Native-Query-Optimization<\/a><\/p>\n
\"soda<\/a>
soda queries<\/p><\/div>\n
<\/a><\/p>\n
Conclusion<\/h3>\n
So, db4o supports a variety of query-types. In my opinion LINQ is the best one, but only available on then most recent .NET framework. Native queries is the second best choice. For special cases query be example might be an alternative. In the end everything is crunched down to SODA-Queries, which is the low level query API. Next time I cover the client-server-concurrency as promised =)<\/p>\n
Java-Code: ComplexObject.java<\/a>, Main.java<\/a>, SimpleObject.java<\/a>, Preconditions.java<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Before I continue with client-server concurrency I explain how to run queries against a db4o database without LINQ. Most of the stuff in db4o works on every platform. The API… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":"","_links_to":"","_links_to_target":""},"categories":[150],"tags":[100,295],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts\/744"}],"collection":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/comments?post=744"}],"version-history":[{"count":13,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts\/744\/revisions"}],"predecessor-version":[{"id":3829,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts\/744\/revisions\/3829"}],"wp:attachment":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/media?parent=744"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/categories?post=744"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/tags?post=744"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}