selectbook.title,pub.name/* projection */fromBookasbook/* root table */joinPublisheraspub/* table join */onbook.publisherId=pub.id/* join condition */wherebook.titlelike'Hibernate%'/* restriction (selection) */orderbybook.title/* sorting */

selectbook.title,pub.name/* projection */fromBookasbook/* root entity */joinbook.publisheraspub/* association join */wherebook.titlelike'Hibernate%'/* restriction (selection) */orderbybook.title/* sorting */

An identifier is a name used to refer to an entity, an attribute of a Java class, anidentification variable, or a function.

For example,Book,title,author, andupper are all identifiers, but they refer to different kinds of things.In HQL and JPQL, the case sensitivity of an identifier depends on the kind of thing the identifier refers to.

The rules for case sensitivity are:

• keywords and function names are case-insensitive, but

• identification variable names, Java class names, and the names of attributes of Java classes, are case-sensitive.

We apologize for this inconsistency.In hindsight, it might have been better to define the whole language as case-sensitive.

Just to reiterate these rules:

Aquoted identifier is written in backticks. Quoting lets you use a keyword as an identifier.

Actually, in most contexts, HQL keywords are "soft", and don’t need to be quoted.The parser is usually able to distinguish if the reserved word is being used as a keyword or as an identifier.

Comments in HQL look like multiline comments in Java.They’re delimited by/* and*/.

Neither SQL-style-- nor Java-style// line-ending comments are allowed.

It’s quite rare to see comments in HQL, but perhaps it will be more common now that Java has text blocks.

Parameters come in two flavors in JPQL, and HQL supports a third flavor for historical reasons:

JDBC-style parameters of form? are like ordinal parameters where the index is inferred from the position in the text of the query.JDBC-style parameters are deprecated.

Some of the syntax for literal values also departs from the standard syntax in ANSI SQL, especially in the area of date/time literals, but we’ll discuss all that later, inLiterals.

The SQLnull behaves quite differently to a null value in Java.

• In Java, an expression likenumber + 1 produces in an exception ifnumber is null.

• But in SQL, and therefore also in HQL and JPQL, such an expression evaluates tonull.

This rule is the source of the famous (and controversial)ternary logic of SQL.A logical expression likefirstName='Gavin' and team='Hibernate' isn’t restricted to the valuestrue andfalse.It may also benull.

This can, in principle, lead to some quite unintuitive results: we can’t use the law of the excluded middle to reason about logical expressions in SQL!But in practice, we’ve never once run into a case where this caused us problems.

As you probably know, when a logical predicate occurs as arestriction, rows for which the predicate evaluates tonull areexcluded from the result set.That is, in this context at least, a logical null is interpreted as "effectively false".

TheBNF for anupdate statement is quite straightforward:

Theset clause has a list of assignments to attributes of the given entity.

For example:

Update statements are polymorphic, and affect mapped subclasses of the given entity class.Therefore, a single HQLupdate statement might result in multiple SQL update statements executed against the database.

Anupdate statement must be executed usingQuery.executeUpdate().

The integer value returned byexecuteUpdate() indicates the number of entity instances affected by the operation.

Anupdate statement, by default, does not affect the column mapped by the@Version attribute of the affected entities.

Adding the keywordversioned—writingupdate versioned—specifies that Hibernate should increment the version number or update the last modification timestamp.

Anupdate statement may not directlyjoin other entities, but it may:

• have animplicit join, or

• have subqueries in itsset clause, or in itswhere clause, and the subqueries may contain joins.

The BNF for adelete statement is even simpler:

For example:

As in SQL, the presence or absence of thefrom keyword has absolutely no effect on the semantics of thedelete statement.

Just like update statements, delete statements are polymorphic, and affect mapped subclasses of the given entity class.Therefore, a single HQLdelete statement might result in multiple SQL delete statements executed against the database.

Adelete statement is executed by callingQuery.executeUpdate().

The integer value returned byexecuteUpdate() indicates the number of entity instances affected by the operation.

Adelete statement may not directlyjoin other entities, but it may:

• have animplicit join, or

• have subqueries in itswhere clause, and the subqueries may contain joins.

There are two kinds ofinsert statement:

• insert …​ values, where the attribute values to insert are given directly as tuples, and

• insert …​ select, where the inserted attribute values are sourced from a subquery.

The first form inserts a single row in the database, or multiple rows if you provide multiple tuples in thevalues clause.The second form may insert many new rows, or none at all.

The BNF for aninsert statement is:

For example:

As in SQL, the presence or absence of theinto keyword has no effect on the semantics of theinsert statement.

From these examples we might notice thatinsert statements are in one respect a bit different toupdate anddelete statements.

ThequeryExpression in aninsert …​ select statement may be any validselect query, with the caveat that the types of the values in theselect list must match the types of the target fields.

There are two ways to assign a value to the@Id attribute:

• explicitly specify the id attribute in the list of target fields, and its value in the values assigned to the target fields, or

• omit it, in which case a generated value is used.

Of course, the second option is only available for entities with database-level id generation (sequences or identity/autoincrement columns).It’s not available for entities whose id generator is implemented in Java, nor for entities whose id is assigned by the application.

The same two options are available for a@Version attribute.When no version is explicitly specified, the version for a new entity instance is used.

Theon conflict clause lets us specify what action should be taken when the database already contains the record we’re attempting to insert.

Note that theon constraint variant accepting the name of a unique constraint only works on certain databases, or when just a single row is being inserted.

Likeupdate anddelete statements, aninsert statement must be executed by callingQuery.executeUpdate().

Now it’s time to look at somethingmuch more complicated.

Select statements retrieve and analyse data.This is what we’re really here for.

The full BNF for aselect query is quite complicated, but there’s no need to understand it now.We’re displaying it here for future reference.

Most of the complexity here arises from the interplay of set operators (union,intersect, andexcept) with sorting.

We’ll describe the various clauses of a query later, inRoot entities and joins and inSelection, projection, and aggregation, but for now, to summarize, a query might have these bits:

Every one of these clauses is optional!

For example, the simplest query in HQL has noselect clause at all:

But we don’t necessarilyrecommend leaving off theselect list.

Naturally, the previous query may be written with aselect clause:

But when there’s no explicitselect clause, the select list is implied by the result type of the query:

For complicated queries, it’s probably best to explicitly specify aselect list.

An alternative "simplest" query hasonly aselect list:

This results in a SQLfrom dual query (or equivalent).

Naturally, queries are always polymorphic.Indeed, a fairly innocent-looking HQL query can easily translate to a SQL statement with many joins and unions.

When there’s no explicitselect clause, a further abbreviation is sometimes possible.

If there’s just one projected item in theselect list, then, no sweat, that’s the type of each query result.

There’s really no need to fuss about with trying to represent a "tuple of length 1".We’re not even sure what to call those.

Problems arise as soon as we have multiple items in theselect list of a query.

When there are multiple expressions in the select list then, by default, and in compliance with JPA, each query result is packaged as an array of typeObject[].

This is bearable, but let’s explore some other options.

JPA lets us specify that we want each query result packaged as an instance ofjakarta.persistence.Tuple.All we have to do is pass the classTuple tocreateQuery().

The names of theTuple elements are determined by the aliases given to the projected items in the select list.If no aliases are specified, the elements may be accessed by their position in the list, where the first item is assigned the position zero.

As an extension to JPA, and in a similar vein, Hibernate lets us passMap orList, and have each result packaged as a map or list:

Unfortunately, not one of the typesObject[],List,Map, norTuple lets us access an individual item in a result tuple without a type cast.SureTuple does the type cast for us when we pass a class object toget(), but it’s logically identical.Fortunately there’s one more option, as we’re about to see.

Hibernate 6 lets us pass an arbitrary class type with an appropriate constructor tocreateQuery() and will use it to package the query results.This works extremely nicely withrecord types.

It’s important that the constructor ofBookSummary has parameters which exactly match the items in theselect list.

We must caution that this still isn’t typesafe.In fact, we’ve just pushed the typecasts down into the call tocreateQuery().But at least we don’t have to write them explicitly.

In JPQL, and in older versions of Hibernate, this functionality required more ceremony.

For example, the JPA-standardselect new construct packages the query results into a user-written Java class instead of an array.

Simplifying slightly, the BNF for a projected item is:

Where the list ofselections in aninstantiation is essentially a nested projection list.

The boolean literal values are the (case-insensitive) keywordstrue andfalse.

String literals are enclosed in single quotes.

To escape a single quote within a string literal, use a doubled single quote:''.

Alternatively, Java-style double-quoted strings are also allowed, with the usual Java character escape syntax.

This option is not much used.

Numeric literals come in several different forms:

For example:

The type of a numeric literal may be specified using a Java-style postfix:

It’s not usually necessary to specify the precision explicitly.

According to the JPQL specification, date and time literals may be specified using the JDBC escape syntax.Since this syntax is rather unpleasant to look at, HQL provides not one, but two alternatives.

Literals referring to the current date and time are also provided.Again there is some flexibility.

Of these, onlylocal date,local time,local datetime,current_date,current_time, andcurrent_timestamp are defined by the JPQL specification.

There are two sorts of duration in HQL:

• year-day durations, that is, the length of an interval between two dates, and

• week-nanosecond durations, that is, the length of an interval between two datetimes.

For conceptual reasons, the two kinds of duration cannot be cleanly composed.

Literal duration expressions are of formn unit, for example1 day or10 year or100 nanosecond.

The unit may be:day,week,month,quarter,year,second,minute,hour, ornanosecond.

HQL also provides a choice of formats for binary strings:

• the braced syntax{0xDE, 0xAD, 0xBE, 0xEF}, a list of Java-style hexadecimal byte literals, or

• the quoted syntaxX’DEADBEEF' orx’deadbeef', similar to SQL.

Literal values of a Java enumerated type may be written without needing to specify the enum class name:

In the examples above, the enum class is inferred from the type of the expression on the left of the comparison, assignment operator, orin predicate.

In this example the enum class is inferred from the type of thecase expression.

HQL allows any Javastatic constant to be used in HQL, but it must be referenced by its fully-qualified name:

Entity names may also occur as a literal value. They do not need to be qualified.

SeeTypes and typecasts.

selectbook.publisher.namefromBookbook

selecttreat(order.paymentasCreditCardPayment).creditCardNumberfromOrderorder

selectelement(book.authors).namefromBookbook

selectbook.editions[0].datefromBookbook

HQL defines two ways to concatenate strings:

• the SQL-style concatenation operator,||, and

• the JPQL-standardconcat() function.

Seebelow for details of theconcat() function.

Many more operations on strings are defined below, inFunctions.

The basic SQL arithmetic operators,+,-,*, and/ are joined by the remainder operator%.

When both operands of a binary numeric operator have the same type, the result type of the whole expression is the same as the operands.

When the operands are of different type, one of the operands is implicitly converted towider type, with wideness given, in decreasing order, by the list below:

• Double (widest)

• Float

• BigDecimal

• BigInteger

• Long

• Integer

• Short

• Byte

Many more numeric operations are defined below, inFunctions.

Arithmetic involving dates, datetimes, and durations is quite subtle.Among the issues to consider are:

• There’s two kinds of duration: year-day, and week-nanosecond durations.The first is a difference between dates; the second is a difference between datetimes.

• We can subtract dates and datetimes, but we can’t add them.

• A Java-style duration has much too much precision, and so in order to use it for anything useful, we must somehow truncate it to something coarser-grained.

Here we list the basic operations.

Theby unit operator converts a duration to an integer, for example:(local date - your.birthday) by day evaluates to the number of days you still have to wait.

The functionextract(unit from …​) extracts a field from a date, time, or datetime type, for example,extract(year from your.birthday) produces the year in which you were born, and throws away important information about your birthday.

Additional datetime operations, including the usefulformat() function, are defined below, inFunctions.

"CASE" expression ("WHEN" expression "THEN" expression)+ ("ELSE" expression)? "END"

selectcaseauthor.nomDePlumewhen''thenperson.nameelseauthor.nomDePlumeendfromAuthorasauthorjoinauthor.personasperson

"CASE" ("WHEN" predicate "THEN" expression)+ ("ELSE" expression)? "END"

selectcasewhenauthor.nomDePlumeisnullthenperson.nameelseauthor.nomDePlumeendfromAuthorasauthorjoinauthor.personasperson

fromPersonwhere(firstName,lastName)=('Ludwig','Boltzmann')

fromEventwhere(year,day)>(year(localdate),day(localdate))

fromPersonwhereaddress=('1600 Pennsylvania Avenue, NW','Washington','DC',20500,'USA')

The following special functions make it possible to discover or narrow expression types:

Let’s see what these functions do.

The functiontype(), applied to an identification variable or to an entity-valued or embeddable-valued path expression, evaluates to the concrete type, that is, the JavaClass, of the referenced entity or embeddable.This is mainly useful when dealing with entity inheritance hierarchies.

The functiontreat() may be used to narrow the type of an identification variable.This is useful when dealing with entity or embeddable inheritance hierarchies.

The type of the expressiontreat(p as CreditCardPayment) is the narrowed type,CreditCardPayment, instead of the declared typePayment ofp.This allows the attributecardNumber declared by the subtypeCreditCardPayment to be referenced.

• The first argument is usually an identification variable.

• The second argument is the target type given as an unqualified entity name.

Thetreat() function may even occur in ajoin.

The functioncast() has a similar syntax, but is used to narrow basic types.

• Its first argument is usually an attribute of an entity, or a more complex expression involving entity attributes.

• Its second argument is the target type given as an unqualified Java class name:String,Long,Integer,Double,Float,Character,Byte,BigInteger,BigDecimal,LocalDate,LocalTime,LocalDateTime, etc.

The functionstr(x) is a synonym forcast(x as String).

The following functions make it easy to deal with null values:

Thecoalesce() function is a sort of abbreviatedcase expression that returns the first non-null operand.

HQL allowsifnull() as a synonym forcoalesce() in the case of exactly two arguments.

On the other hand,nullif() evaluates to null if its operands are equal, or to its first argument otherwise.

There are some very important functions for working with dates and times.

The special functionextract() obtains a single field of a date, time, or datetime.

• Its first argument is an expression that evaluates to a date, time, or datetime.

• Its second argument is a date/timefield type.

Recognized Field types are listed below.

For a full list of field types, see the Javadoc forTemporalUnit.

The following functions are abbreviations forextract():

Theformat() function formats a date, time, or datetime according to a pattern.

• Its first argument is an expression that evaluates to a date, time, or datetime.

• Its second argument is a formatting pattern, given as a string.

The pattern must be written in a subset of the pattern language defined by Java’sjava.time.format.DateTimeFormatter.

For a full list offormat() pattern elements, see the Javadoc forDialect.appendDatetimeFormat.

Thetruncate() function truncates the precision of a date, time, or datetime to the temporal unit specified by field type.

• Its first argument is an expression that evaluates to a date, time, or datetime.

• Its second argument is a date/time field type, specifying the precision of the truncated value.

Supported temporal units are:year,month,day,hour,minute orsecond.

Truncating a date, time or datetime value means obtaining a value of the same type in which all temporal units smaller thanfield have been pruned.For hours, minutes and second this means setting them to00. For months and days, this means setting them to01.

Naturally, there are a good number of functions for working with strings.

Let’s take a closer look at just some of these.

The JPQL-standard and ANSI SQL-standardconcat() function accepts a variable number of arguments, and produces a string by concatenating them.

The JPQL functionlocate() determines the position of a substring within another string.

• The first argument is the pattern to search for within the second string.

• The second argument is the string to search in.

• The optional third argument is used to specify a position at which to start the search.

Theposition() function has a similar purpose, but follows the ANSI SQL syntax.

Unsurprisingly,substring() returns a substring of the given string.

• The second argument specifies the position of the first character of the substring.

• The optional third argument specifies the maximum length of the substring.

Thetrim() function follows the syntax and semantics of ANSI SQL.It may be used to trimleading characters,trailing characters, or both.

Its BNF is funky:

Thepad() function has a syntax inspired bytrim().

Its BNF is given by:

Thecollate() function selects a collation to be used for its string-valued argument.Collations are useful forbinary comparisons with< or>, and in theorder by clause.

For example,collate(p.name as ucs_basic) specifies the SQL standard collationucs_basic.

Of course, we also have a number of functions for working with numeric values.

We haven’t includedaggregate functions,ordered set aggregate functions, orwindow functions in this list, because their purpose is more specialized, and because they come with extra special syntax.

The functions described in this section are especially useful when dealing with@ElementCollection mappings, or with collection mappings involving an@OrderColumn or@MapKeyColumn.

The following functions accept either:

1. an identification variable that refers to ajoined collection or many-valued association, or

2. acompound path that refers to a collection or many-valued association of an entity.

In case 2, application of the function produces animplicit join.

The next group of functions always accept a compound path referring to a collection or many-valued association of an entity.They’re interpreted as referring to the collection as a whole.

Application of one of these function produces an implicit subquery or implicit join.

This query has an implicit join:

This query has an implicit subquery:

Thesize() function returns the number of elements of a collection or to-many association.

Theelement() function returns a reference to an element of a joined set or list.For an identification variable (case 1 above), this function is optional.For a compound path (case 2), it’s required.

Theindex() function returns a reference to the index of a joined list.

In this example,element() is optional, butindex() is required:

Thekey() function returns a reference to a key of a joined map.Thevalue() function returns a reference to its value.

Quantification over collections

selecttitlefromBookwhere'hibernate'inelements(tags)

selecttitle,max(index(revisions))fromBook/* implicit join */

selecttitle,max(indices(revisions))fromBook/* implicit subquery */

Finally, the following functions evaluate the id, version, or natural id of an entity, or the foreign key of a to-one association:

The following special functions let us embed a call to a native SQL function, refer directly to a column, or evaluate an expression written in native SQL.

Direct column references

selectcolumn(log.ctidasString)fromLoglog

Native and user-defined functions

Embedding native SQL in HQL

fromComputercwherec.ipAddress=sql('?::inet','127.0.0.1')

select*fromComputercwherec.ipAddress='127.0.0.1'::inet

fromHumanhorderbysql('(? <-> ?)',h.workLocation,h.homeLocation)

select*fromHumanhwhere(h.workLocation<->h.homeLocation)

The binary comparison operators are borrowed from SQL:=,>,>=,<,<=,<>.

The operands should be of the same type.

The ternarybetween operator, and its negation,not between, determine if a value falls within a range.

Of course, all three operands must be of compatible type.

The following operators make it easier to deal with null values.These predicates never evaluate tonull.

These operators perform comparisons on values of typeboolean.These predicates never evaluate tonull.

Forlogical operations onpredicates, seeLogical operators below.

The following operators apply to collection-valued attributes and to-many associations.

Thelike operator performs pattern matching on strings.Its friendilike performs case-insensitive matching.

Their syntax is defined by:

The expression on the right is a pattern, where:

• _ matches any single character,

• % matches any number of characters, and

• if an escape character is specified, it may be used to escape either of these wildcards.

The optionalescape character allows a pattern to include a literal_ or% character.

As you can guess,not like andnot ilike are the enemies oflike andilike, and evaluate to the exact opposite boolean values.

Thein predicates evaluates to true if the value to its left is in …​ well, whatever it finds to its right.

Its syntax is unexpectedly complicated:

This less-than-lovely fragment of the HQL ANTLR grammar tells us that the thing to the right might be:

• a list of values enclosed in parentheses,

• a subquery,

• one of the collection-handling functions definedabove, or

• a query parameter,

The type of the expression on the left, and the types of all the values on the right must be compatible.

It’s quite common to have a parameterized list of values.

We may even "vectorize" anin predicate, using a tuple constructor and a subquery with multiple selection items:

The binary comparisons we metabove may involve a quantifier, either:

• a quantified subquery, or

• a quantifier applied to one of the functions definedabove.

The quantifiers are unary prefix operators:all,every,any, andsome.

The unary prefixexists operator evaluates to true if the thing to its right is nonempty.

The thing to its right might be:

• a subquery, or

• one of the functions definedabove.

As you can surely guess,not exists evaluates to true if the thing to the rightis empty.

The logical operators are binary infixand andor, and unary prefixnot.

Just like SQL, logical expressions are based on ternary logic.A logical operator evaluates to null if it has a null operand.

An identification variable is just a name we can use to refer to an entity and its attributes from expressions in the query.It may be any legal Java identifier.According to the JPQL specification, identification variables must be treated as case-insensitive language elements.

Identification variables may be declared with theas keyword, but this is optional.

A root entity reference, or what the JPQL specification calls arange variable declaration, is a direct reference to a mapped@Entity type by its entity name.

In this example,Book is the entity name, andbook is the identification variable.Theas keyword is optional.

Alternatively, a fully-qualified Java class name may be specified.Then Hibernate will query every entity which inherits the named type.

Of course, there may be multiple root entities.

This query may even be written using the syntaxcross join in place of the commas:

Of course, it’s possible to write old-fashioned pre-ANSI-era joins:

But we never write HQL this way.

HQL and JPQL queries are inherently polymorphic.Consider:

This query names thePayment entity explicitly.But theCreditCardPayment andWireTransferPayment entities inheritPayment, and sopayment ranges over all three types.Instances of all these entities are returned by the query.

Aderived root is an uncorrelated subquery which occurs in thefrom clause.

The derived root may declare an identification variable.

This feature can be used to break a more complicated query into smaller pieces.

A subquery may also occur in ajoin, in which case it may be a correlated subquery.

Acommon table expression (CTE) is like a derived root with a name.We’ll discuss CTEslater.

An explicit root join works just like an ANSI-style join in SQL.

The join condition is written out explicitly in theon clause.

Every explicit association join specifies an entity attribute to be joined.The specified attribute:

• is usually a@OneToMany,@ManyToMany,@OneToOne, or@ManyToOne association, but

• it could be an@ElementCollection, and

• it might even be an attribute of embeddable type.

In the case of an association or collection, the generated SQL will have a join of the same type.(For a many-to-many association it will havetwo joins.)In the case of an embedded attribute, the join is purely logical and does not result in a join in the generated SQL.

An explicit join may assign an identification variable to the joined entity.

For an outer join, we must write our query to accommodate the possibility that the joined association is missing.

For further information about collection-valued association references, seeJoining collections and many-valued associations.

Thewith oron clause allows explicit qualification of the join conditions.

Join conditions occurring in thewith oron clause are added to theon clause in the generated SQL.

Afetch join overrides the laziness of a given association, specifying that the association should be fetched with a SQL join.The join may be an inner or outer join.

• Ajoin fetch, or, more explicitly,inner join fetch, only returns base entities with an associated entity.

• Aleft join fetch, or—for lovers of verbosity—left outer join fetch, returns all the base entities, including those which have no associated joined entity.

For example, ifPerson has a one-to-many association namedphones, the use ofjoin fetch in the following query specifies that the collection elements should be fetched in the same SQL query:

In this example, we used a left outer join forbook.publisher because we also wanted to obtain books with no publisher, but a regular inner join forbook.authors because every book has at least one author.

A query may have more than one fetch join, but be aware that:

• it’s perfectly safe to fetch several to-one associations in series or parallel in a single query, and

• a single series ofnested fetch joins is also fine, but

• fetching multiple collections or to-many associations inparallel results in a Cartesian product at the database level, and might exhibit very poor performance.

HQL doesn’t disallow it, but it’s usually a bad idea to apply a restriction to ajoin fetched entity, since the elements of the fetched collection would be incomplete.Indeed, it’s best to avoid even assigning an identification variable to a fetched joined entity except for the purpose of specifying a nested fetch join.

Fetch joins are disallowed in subqueries, where they would make no sense.

An explicit join may narrow the type of the joined entity usingtreat().

Here, the identification variableccp declared to the right oftreat() has the narrowed typeCreditCardPayment, instead of the declared typePayment.This allows the attributecardNumber declared by the subtypeCreditCardPayment to be referenced in the rest of the query.

SeeTypes and typecasts for more information abouttreat().

Ajoin clause may contain a subquery, either:

• an uncorrelated subquery, which is almost the same as aderived root, except that it may have anon restriction, or

• alateral join, which is a correlated subquery, and may refer to other roots declared earlier in the samefrom clause.

Thelateral keyword just distinguishes the two cases.

This query may also be expressed using alateral join:

A lateral join may be an inner or left outer join, but not a right join, nor a full join.

Lateral joins are particularly useful for computing top-N elements of multiple groups.

It’s not necessary to explicitlyjoin every entity that occurs in a query.Instead, entity associations may benavigated, just like in Java:

• if an attribute is of embedded type, or is a to-one association, it may be further navigated, but

• if an attribute is of basic type, it is considered terminal, and may not be further navigated, and

• if an attribute is collection-valued, or is a to-many association, it may be navigated, but only with the help ofvalue(),element(), orkey().

It’s clear that:

• A path expression likeauthor.name with only two elements just refers to state held directly by an entity with an aliasauthor defined infrom orjoin.

• But a longer path expression, for example,author.person.name, might refer to state held by an associated entity.(Alternatively, it might refer to state held by an embedded class.)

In the second case, Hibernate with automatically add a join to the generated SQL if necessary.

As in this example, implicit joins usually appear outside thefrom clause of the HQL query.However, they always affect thefrom clause of the SQL query.

The example above is equivalent to:

Note that:

• Implicit joins are always treated as inner joins.

• Multiple occurrences of the same implicit join always refer to the same SQL join.

This query:

results in just one SQL join, and is just a different way to write:

When a join involves a collection or many-valued association, the declared identification variable refers to theelements of the collection, that is:

• to the elements of aSet,

• to the elements of aList, not to their indices in the list, or

• to the values of aMap, not to their keys.

In this example, the identification variableauthor is of typeAuthor, the element type of the listBook.authors.But if we need to refer to the index of anAuthor in the list, we need some extra syntax.

You might recall that we mentionedList indexes andMap keys and values a bit earlier.These functions may be applied to the identification variable declared in a collection join or many-valued association join.

In particular,index() andkey() obtain a reference to a list index or map key.

A path expression likebook.authors.name is not considered legal.We can’t just navigate a many-valued association with this syntax.

Instead, the functionselement(),index(),key(), andvalue() may be applied to a path expression to express an implicit join.So we must writeelement(book.authors).name orindex(book.authors).

An element of an indexed collection (an array, list, or map) may even be identified using the index operator:

Thegroup by clause looks quite similar to theselect clause—it has a list of grouped items, but:

• if there’s just one item, then the query will have a single result for each unique value of that item, or

• if there are multiple items, the query will have a result for each uniquecombination or their values.

The BNF for a grouped item is just: