return _session.Query<Movie>()
    .Where(x => x.Director == directorName)
    .ToList();

This should be rather obvious. We are fetching the IQueryable<Movie> and apply a Where restriction to it. But why the ToList call? Well, since the IQueries interface specified that it expected an IEnumerable<Movie> to be returned, we don't want to cause confusion and problems by returning the IQueryable<Movie> (although it implements IEnumerable<Movie>), which at that point has not yet been executed.

The following SQL query will be executed:

SELECT   this_.Id          as Id1_0_,
         this_.Name        as Name1_0_,
         this_.Description as Descript4_1_0_,
         this_.UnitPrice   as UnitPrice1_0_,
         this_.Director    as Director1_0_
FROM     Product this_
WHERE    this_.ProductType = 'Movie'
AND      this_.Director = 'Steven Spielberg' 

Note that an extra criterion was added to the query, in order to make sure that we only query on Movie entities.

 _session.Query<Movie>()
    .Where(x => x.Actors.Any(ar=>ar.Actor==actorName))
    .ToList();

Again, we use the Movie queryable, but this time we want the restriction to apply to the Actors list on the Movie entity. You could read the query as:

Return all movies where any of the actors' name is equal to the actorName parameter.

The query executed looks something similar to this:

SELECT
        movie0_.Id as Id0_,
        movie0_.Name as Name0_,
        movie0_.Description as Descript4_0_,
        movie0_.UnitPrice as UnitPrice0_,
        movie0_.Director as Director0_ 
    FROM
        Product movie0_ 
    WHERE
        movie0_.ProductType='Movie' 
        AND (
            EXISTS (
                SELECT
                    actors1_.Id 
                FROM
                    ActorRole actors1_ 
                WHERE
                    movie0_.Id=actors1_.MovieId 
                    AND actors1_.Actor='Morgan Freeman'
            )
        );

Here, the WHERE clause contains an EXISTS subquery on the ActorRole table, restricted by the actor name we supplied, and the movie Id from the outer query.

In the next few recipes, you will see the same queries getting implemented using a JOIN instead of a subquery. Why didn't we do that here?

For starters, while LINQ provides a Join method, its syntax quickly becomes a bit convoluted and it requires the collection entity (ActorRole in this case) to expose a property that can be used to join the two entities. Also, unless we apply Distinct to the query result, a join can potentially return duplicates, for example if Morgan Freeman played more than one role in a movie.

For reference, a LINQ Join query would look similar to the following code:

 _session.Query<Movie>() 
    .Join(
        _session.Query<ActorRole>(),
        movie => movie,  
        actorRole => actorRole.Movie, 
        (movie, actorRole) => new
        {
            Movie = movie,
            ActorRole = actorRole
        })
    .Where(ar => ar.ActorRole.Actor==actorName)
    .Select(ar => ar.Movie)
    .Distinct()
    .ToList();

_session.Query<Book>()
    .FirstOrDefault(x => x.ISBN == isbn);

In this query, we're searching for a particular book by its ISBN. We could have used the Where method to specify the criterion, followed by an empty FirstOrDefault(), but this terser format will result in exactly the same query.

Since FirstOrDefault means "only the first result, return null if nothing is found", NHibernate can apply a limit to the number of rows it requests.

The resulting SQL Server query looks similar to this:

SELECT
        book0_.Id as Id0_,
        book0_.Name as Name0_,
        book0_.Description as Descript4_0_,
        book0_.UnitPrice as UnitPrice0_,
        book0_.ISBN as ISBN0_,
        book0_.Author as Author0_ 
    FROM
        Product book0_ 
    WHERE
        book0_.ProductType='Book' 
        and book0_.ISBN='978-1-849513-04-3' 
    ORDER BY
        CURRENT_TIMESTAMP 
    OFFSET 0 ROWS FETCH FIRST 1 ROWS ONLY

NHibernate applies the limit using the recommended syntax of the configured database. In this case, an OFFSET/FETCH in the ORDER BY clause is used and since we didn't specify a sort order in the query, CURRENT_TIMESTAMP is used as a fallback. Other databases can use other constructs, such as SELECT TOP or LIMIT.

If Single or SingleOrDefault had been used instead of FirstOrDefault, an exception is expected if the query returns more than one row. In that scenario, no limit will be added to the query, potentially leading to the consumption of more resources.

_session.Query<Product>()
    .Where(x => 
        x.UnitPrice >= minPrice && 
        x.UnitPrice <= maxPrice
    )
    .OrderBy(x=>x.UnitPrice)
    .ToList();

Just like GetMoviesDirectedBy, this query is very straightforward. The requested restriction is simply expressed in the Where expression and we also order the results by UnitPrice (ascending).

SQL Server executes the following query:

SELECT
        product0_.Id as Id0_,
        product0_.Name as Name0_,
        product0_.Description as Descript4_0_,
        product0_.UnitPrice as UnitPrice0_,
        product0_.ISBN as ISBN0_,
        product0_.Author as Author0_,
        product0_.Director as Director0_,
        product0_.ProductType as ProductT2_0_ 
    FROM
        Product product0_ 
    WHERE
        product0_.UnitPrice>=0 
        and product0_.UnitPrice<=15
    ORDER BY
        product0_.UnitPrice ASC

Since the query was on the base class Product, no restriction on the ProductType column is present. Instead it is included in the SELECT clause, together with all the properties required for both Movie and Book.