QueryOver ProjectionList with different root entit

问题:

I'm having issues trying to reuse ProjectionLists in NHibernate QueryOvers. I can't work out how to reuse things for different root entities.

Object model is roughly represented as:

Breakfast one to many Pastry many to zero-or-one Coffee

The two separate queries are roughly:

session.QueryOver<Breakfast>()
    .Where(b => b.Id == searchId)
    .Inner.JoinQueryOver(b => b.Pastries, () => pastry)
    .Left.JoinAlias(p => p.Coffee, () => coffee)
    .Select(projections)
    .TransformUsing(Transformers.AliasToBean<TargetDto>())
    .List<TargetDto>();

session.QueryOver<Coffee>()
    .Where(c => c.Id == searchId)
    .Inner.JoinQueryOver(c => c.Pastries, () => pastry)
    .Select(projections)
    .TransformUsing(Transformers.AliasToBean<TargetDto>())
    .List<TargetDto>();

The common projections I'm trying to reuse looks like this:

var projections = Projections.ProjectionList()
    .Add(Projections.Property(() => pastry.Name, () => target.PastryName))
    .Add(Projections.Property(() => coffee.Name, () => target.CoffeeName));

These projections, using the aliases, work fine for the first query (root: Breakfast), because they're not trying to pull off properties that are on that root entity. On the second query (root: Coffee), it explodes saying it can't find 'coffee.Name' on Coffee, because it doesn't like the alias. The QueryOver(() => coffee) syntax doesn't help because it doesn't actually register 'coffee' as an alias, it just uses it for type inference. Oh bloody hell that was the problem. There's a stupid piece of application infrastructure that is breaking the alias syntax to not actually use the alias version underneath.

The second query wants the projections to look like:

var projections = Projections.ProjectionList()
    .Add(Projections.Property(() => pastry.Name, () => target.PastryName))
    .Add(Projections.Property<Coffee>(c => c.Name, () => target.CoffeeName));

However this is now incompatible with the first query.

Is there any way of making this work, so the I can project properties without knowing what the root entity type is?

回答1:

I think all you need to do is assign the coffee alias in the session.QueryOver<Coffee> call:

Coffee coffee = null;

session.QueryOver<Coffee>(() => coffee)
    /* etc */

The below might be completely unrelated to what you're doing, but I figured I'd include it in case anyone else is writing code that passes around QueryOver aliases.

---

I'd add a word of caution-- reusing aliases across different queries like this can be a little dangerous.

NHibernate takes the expression () => coffee and grabs the name of the alias you're using from the expression (in this case, "coffee") and then uses it in the generated SQL as an alias. This means that depending on how your code is structured, shared projections like this could break if alias names change.

For example, say you had the following method to return some shared projections:

public ProjectionList GetSharedProjections()
{
    Coffee coffee = null;
    TargetDTO target;

    var projections = Projections.ProjectionList()
        .Add(Projections.Property(() => coffee.CoffeeName)
            .WithAlias(() => target.CoffeeName));

    return projections;
}

Then you had some code calling your helper method:

session.QueryOver<Coffee>(() => coffee)
    .Select(GetSharedProjections());

Everything will work fine-- as long as your aliases match. The second anyone changes either of the aliases though, the query will fail.

You might be tempted to pass in an alias to a method like this:

public ProjectionList GetSharedProjections(Coffee coffeeAlias)
{
    /* Same as above except with "coffeeAlias"
}

And then pass in your alias:

session.QueryOver<Coffee>(() => coffee)
    .Select(GetSharedProjections(coffee));

But this won't work either. Remember that NHibernate is grabbing the name of the alias and using it directly in the generated SQL. The above code will try to use both "coffee" and "coffeeAlias" in the generated SQL and will fail.

One way to properly do this (without just hoping nobody changes alias names) is to pass around expressions and use those to reconstruct property names with the correct aliases.

You'd create a helper method that builds property access using an alias and a property:

public static PropertyProjection BuildProjection<T>(
    Expression<Func<object>> aliasExpression,
    Expression<Func<T, object>> propertyExpression)
{
    string alias = ExpressionProcessor.FindMemberExpression(aliasExpression.Body);
    string property = ExpressionProcessor.FindMemberExpression(propertyExpression.Body);

    return Projections.Property(string.Format("{0}.{1}", alias, property));
}

Then, you could change the GetSharedProjections method to take an alias in the form of an expression:

public ProjectionList GetSharedProjection(Expression<Func<Coffee>> coffeeAlias)
{
    TargetDTO target = null; 

    var projections = Projections.ProjectionList()
        .Add(BuildProjection<Coffee>(coffeeAlias, c => c.CoffeeName))
            .WithAlias(() => target.CoffeeName);
}

Now, calling your method would look like this:

session.QueryOver<Coffee>(() => coffee)
    .Select(GetSharedProjections(() => coffee));

When someone changes your alias name you're covered. You can also safely use this method among many queries without worrying about what the name of the alias variable actually is.

Disclaimer: The following is a link to my personal blog

You can find more information about building QueryOver queries this way here.