Cayenne Guide

Cayenne Guide
		Next

Unless required by applicable law or agreed to in writing, software distributed + under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + CONDITIONS OF ANY KIND, either express or implied. See the License for the specific + language governing permissions and limitations under the License.

Chapter 8. Orderings
Prev	Part II. Cayenne Framework	Next

Chapter 8. Orderings

Part II. Cayenne Framework

Ordering o = new Ordering(Painting.NAME_PROPERTY, SortOrder.ASCENDING_INSENSITIVE); + essentially path expressions combined with a sorting strategy. Creating an Ordering: +

Ordering o = new Ordering(Painting.NAME_PROPERTY, SortOrder.ASENDING);

Like expressions, orderings are translated into SQL as parts of queries (and the sorting + occurs in the database). Also like expressions, orderings can be used in memory, naturally - + to sort + objects:

Ordering o = new Ordering(Painting.NAME_PROPERTY, SortOrder.ASCENDING_INSENSITIVE);
 List<Painting> list = ...
 o.orderList(list);

Note - that unlike filtering with Expressions, ordering is performed in-place. This list object is - reordered and no new list is created.

Chapter 11. Performance Tuning
Prev	Part II. Cayenne Framework	Next

Chapter 11. Performance Tuning

Part II. Cayenne Framework

Chapter 11. Performance Tuning

Table of Contents

Prefetching
Data Rows
Iterated Queries
Paginated Queries
Caching and Fresh Data
Turning off Synchronization of ObjectContexts

Prefetching

Prefetching is a technique that allows to bring back in one query not only the queried - objects, but also objects related to them. In other words it is a controlled eager - relationship resolving mechanism. Prefetching is discussed in the "Performance Tuning" - chapter, as it is a powerful performance optimization method. Another common application - of prefetching is for refreshing stale object relationships.

Prefetching example: -

SelectQuery query = new SelectQuery(Artist.class); + objects, but also objects related to them. In other words it is a controlled eager + relationship resolving mechanism. Prefetching is discussed in the "Performance Tuning" + chapter, as it is a powerful performance optimization method. Another common application + of prefetching is for refreshing stale object relationships.

Prefetching example: +

SelectQuery query = new SelectQuery(Artist.class);
 
-// this instructs Cayenne to prefetch one of Artist's relationships
-query.addPrefetch("paintings");
+// this instructs Cayenne to prefetch one of Artist's relationships
+query.addPrefetch("paintings");
 
-// query is expecuted as usual, but the resulting Artists will have
-// their paintings "inflated"
+// query is expecuted as usual, but the resulting Artists will have
+// their paintings "inflated"
 List<Artist> artists = context.performQuery(query);

- All types of relationships can be preftetched - to-one, to-many, flattened.

A prefetch can span multiple relationships: -

 query.addPrefetch("paintings.gallery");

A query can have multiple - prefetches:

query.addPrefetch("paintings"); 
-query.addPrefetch("paintings.gallery");

If a query is fetching DataRows, all "disjoint" prefetches are ignored, only "joint" - prefetches are executed (see prefetching semantics discussion below for what disjoint and - joint prefetches mean).

Prefetching Semantics

Prefetching semantics defines a strategy to prefetch relationships. Depending on - it, Cayenne would generate different types of queries. The end result is the same - - query root objects with related objects fully resolved. However semantics can affect - preformance, in some cases significantly. There are 3 types of prefetch semantics, - all defined as constants in - org.apache.cayenne.query.PrefetchTreeNode:

PrefetchTreeNode.JOINT_PREFETCH_SEMANTICS + All types of relationships can be preftetched - to-one, to-many, flattened.

A prefetch can span multiple relationships: +

 query.addPrefetch("paintings.gallery");

A query can have multiple + prefetches:

query.addPrefetch("paintings");
+query.addPrefetch("paintings.gallery");

If a query is fetching DataRows, all "disjoint" prefetches are ignored, only "joint" + prefetches are executed (see prefetching semantics discussion below for what disjoint and + joint prefetches mean).

Prefetching Semantics

Prefetching semantics defines a strategy to prefetch relationships. Depending on + it, Cayenne would generate different types of queries. The end result is the same - + query root objects with related objects fully resolved. However semantics can affect + preformance, in some cases significantly. There are 3 types of prefetch semantics, + all defined as constants in + org.apache.cayenne.query.PrefetchTreeNode:

PrefetchTreeNode.JOINT_PREFETCH_SEMANTICS
 PrefetchTreeNode.DISJOINT_PREFETCH_SEMANTICS
 PrefetchTreeNode.DISJOINT_BY_ID_PREFETCH_SEMANTICS

Each query has a default prefetch semantics, so generally users do not have to - worry about changing it, except when performance is a concern, or a few special - cases when a default sematics can't produce the correct result. SelectQuery uses - DISJOINT_PREFETCH_SEMANTICS by default. Semantics can be changed as - follows:

SelectQuery query = new SelectQuery(Artist.class); -query.addPrefetch("paintings").setSemantics( + worry about changing it, except when performance is a concern, or a few special + cases when a default sematics can't produce the correct result. SelectQuery uses + DISJOINT_PREFETCH_SEMANTICS by default. Semantics can be changed as + follows:

SelectQuery query = new SelectQuery(Artist.class);
+query.addPrefetch("paintings").setSemantics(
                 PrefetchTreeNode.JOINT_PREFETCH_SEMANTICS);

There's no limitation on mixing different types of semantics in the same - SelectQuery. Multiple prefetches each can have its own semantics.

SQLTemplate and ProcedureQuery are both using JOINT_PREFETCH_SEMANTICS and it can - not be changed due to the nature of these two queries.

Disjoint Prefetching Semantics

This semantics (only applicable to SelectQuery) results in Cayenne generatiing one - SQL statement for the main objects, and a separate statement for each prefetch path - (hence "disjoint" - related objects are not fetched with the main query). Each - additional SQL statement uses a qualifier of the main query plus a set of joins - traversing the preftech path between the main and related entity.

This strategy has an advantage of efficient JVM memory use, and faster overall - result processing by Cayenne, but it requires (1+N) SQL statements to be executed, - where N is the number of prefetched relationships.

Disjoint-by-ID Prefetching Semantics

This is a variation of disjoint prefetch where related objects are matched against - a set of IDs derived from the fetched main objects (or intermediate objects in a - multi-step prefetch). Cayenne limits the size of the generated WHERE clause, as most - DBs can't parse arbitrary large SQL. So prefetch queries are broken into smaller - queries. The size of is controlled by the DI property - Constants.SERVER_MAX_ID_QUALIFIER_SIZE_PROPERTY (the default number of conditions in - the generated WHERE clause is 10000). Cayenne will generate (1 + N * M) SQL - statements for each query using disjoint-by-ID prefetches, where N is the number of - relationships to prefetch, and M is the number of queries for a given prefetch that - is dependent on the number of objects in the result (ideally M = 1).

The advantage of this type of prefetch is that matching database rows by ID may be - much faster than matching the qualifier of the original query. Moreover this is - the only type of prefetch that can handle - SelectQueries with fetch limit. Both joint and - regular disjoint prefetches may produce invalid results or generate inefficient - fetch-the-entire table SQL when fetch limit is in effect.

The disadvantage is that query SQL can get unwieldy for large result sets, as each - object will have to have its own condition in the WHERE clause of the generated - SQL.

Joint Prefetching Semantics

Joint senantics results in a single SQL statement for root objects and any number - of jointly prefetched paths. Cayenne processes in memory a cartesian product of the - entities involved, converting it to an object tree. It uses OUTER joins to connect - prefetched entities.

Joint is the most efficient prefetch type of the three as far as generated SQL - goes. There's always just 1 SQL query generated. Its downsides are the potentially - increased amount of data that needs to get across the network between the - application server and the database, and more data processing that needs to be done - on the Cayenne side.

Data Rows

Iterated Queries

Paginated Queries

Caching and Fresh Data

Object Caching

Query Result Caching

Turning off Synchronization of ObjectContexts

Prev	Up	Next
Chapter 10. Lifecycle Events	Home	Chapter 12. Customizi ng Cayenne Runtime

\ No newline at end of file + SelectQuery. Multiple prefetches each can have its own semantics.

SQLTemplate and ProcedureQuery are both using JOINT_PREFETCH_SEMANTICS and it can + not be changed due to the nature of these two queries.