JoinedSubclassMapping to pull base object without joins

[fairking]

NH v. 5.2.7, 5.3.0

I got a situation when I need to get a base object without any joins.
Is it possible?
If I remove abstract class I still get a query with joins to all derived tables.

Eg.

// Entities
public ~~abstract~~ class Document
{
    public virtual Guid Id { get; set; }
    public virtual string Name { get; set; }
}
public class Order : Document
{
    public virtual decimal OrderTotal { get; set; }
}
public class Invoice : Document
{
    public virtual decimal InvoiceTotal { get; set; }
}

// Mappings
public class DocumentMapping : ClassMapping<Document>
{
	public DocumentMapping()
	{
                Table("documents");
		Id(x => x.Id);
		Property(x => x.Name);
	}
}
public class OrderMapping : JoinedSubclassMapping<Order>
{
	public OrderMapping()
	{
                Table("orders");
		Key(x => x.Column("Id"));
		Property(x => x.OrderTotal);
	}
}
public class InvoiceMapping : JoinedSubclassMapping<Invoice>
{
	public InvoiceMapping()
	{
                Table("invoices");
		Key(x => x.Column("Id"));
		Property(x => x.InvoiceTotal);
	}
}

The following code:

var list = _session.Query<Document>().ToList();

Produces the following query:

select 
    doc.id, 
    doc.name, 
    inv.invoice_total, 
    ord.order_total, 
    case 
        when inv.id is not null then 1 
        when ord.id is not null then 2 
        when doc.id is not null then 0 
    end as clazz_ 
from documents doc 
    left outer join invoices inv on doc.id=inv.id 
    left outer join orders ord on doc.id=ord.id

The same applied to the references:

public class Customer
{
    public virtual Document ParentDocument { get; set; } // two joins

    public virtual Invoice InitialInvoice { get; set; } // one join to [invoices] table

    public virtual ICollection<Document> AllDocuments { get; set; } // two joins

    public virtual ICollection<Order> AllOrders { get; set; } // one join to [orders] table
}

[fairking]

I can create a separate class and map it to the documents table but it will violate the principle that only one class/instance must control one table/row (per session).

[maca88]

Is it possible?

As far as I know, it is not.

I can create a separate class and map it to the documents table but it will violate the principle that only one class/instance must control one table/row (per session).

You can map a class as a subselect and set it to be immutable.

public class DocumentView : Document
{
}

public class DocumentMapping : ClassMapping<DocumentView>
{
	public DocumentMapping()
	{
		Id(x => x.Id);
		Property(x => x.Name);
		Subselect("select * from Document");
		SchemaAction(Mapping.ByCode.SchemaAction.None);
		Mutable(false);
	}
}

[fairking]

You can map a class as a subselect and set it to be immutable.

Should it be ClassMapping<DocumentView> instead?

The only problem with the separate class is I cannot normally operate with all derived classes of Document.
Eg.

public class Customer
{
    public virtual ~~DocumentView~~ InitialDocument { get; protected set; }

    public virtual void SetInitialDocument(~~DocumentView~~ document)
    {
        InitialDocument = document ?? throw new ArgumentNullException(nameof(document));
    }
}

...

customer.SetInitialDocument(invoice); // ??? won't work

The reason I wanna get rid of those joins is If I have dozens of derives classes (which I expect in a future) it will be very expensive to load those objects (because of all those joins).

However I understand that the nature of NH might not allow for it.

[fairking]

Thanks @maca88 for your idea. I know it is challenging so I am closing the ticket. I will leave a comment if I find any better solution.

[maca88]

Should it be ClassMapping instead?

Yes my bad, corrected.

The reason I wanna get rid of those joins is If I have dozens of derives classes (which I expect in a future) it will be very expensive to load those objects (because of all those joins).

A possible solution would be to support flagging a subclass with lazy="true", which would prevent adding a join for it and it would be lazy loaded when one of its properties would be accessed. I think this is a valid feature request so it can be reopened.

The method IsSubclassTableLazy would need to be overriden for JoinedSubclassEntityPersister, which can be used to avoid appending a join:

nhibernate-core/src/NHibernate/Persister/Entity/AbstractEntityPersister.cs

Lines 3779 to 3781 in 752fd62

	bool joinIsIncluded = IsClassOrSuperclassTable(j) ||
	(includeSubclasses && !IsSubclassTableSequentialSelect(j) && !IsSubclassTableLazy(j));
	if (joinIsIncluded)

[fairking]

It is an interesting idea. I was thinking about solutions but always ended up with the question how the base class would be persisted.
But if you think the subclass can be lazy, so when we already have a base class instance we can use discriminator to load that subclass with just one join later on lazy loading. So the discriminator needs to be implemented in JoinedSubclassMapping to achieve the functionality.