Mapping Relationships and Roles in LightSpeed

Hello,

Consider the following object model which I'm trying to map to LightSpeed:

public class Document
{
    public string Name
    {
        get;
        set;
    }

    public ICollection<DocumentRelationship> Relationships
    {
        get;
        private set;
    }
}

public abstract class DocumentRelationship
{
  // Properties common to all relationships
}

public sealed class DocumentComparison : DocumentRelationship
{
    public Document Original
    {
        get;
        set;
    }

    public Document Modified
    {
        get;
        set;
    }

    public Document Result
    {
        get;
        set;
    }
}

public sealed class DocumentVersion : DocumentRelationship
{
    public Document Previous
    {
        get;
        set;
    }

    public Document Current
    {
        get;
        set;
    }
}

This however doesn't map well to a LightSpeed model due to inheritance. So I refactored it looks as follows:

public abstract class DocumentRelationship
{
    public IList<DocumentRole> Roles
    {
        get;
        set;
    }

    protected void SetDocumentWithRole(string roleType, Document value)
    {
        DocumentRole role =
            Roles.SingleOrDefault(
                r =>
                r.Relationship == this &&
                r.RoleType.Name == roleType &&
                r.RoleType.Discriminator == GetType().Name);
        if (role != null)
        {
            if (role.Document != value)
            {
                Roles.Remove(role);
            }
            else
            {
                return;
            }
        }
        Roles.Add(new DocumentRole { Document = value, Relationship = this, RoleType = GetRoleType(roleType) });
    }

    protected Document FindDocumentWithRole(string roleType)
    {
        return
            Roles.Where(
                r =>
                r.Relationship == this &&
                r.RoleType.Name == roleType &&
                r.RoleType.Discriminator == GetType().Name)
                .Select(r => r.Document).SingleOrDefault();
    }

    protected DocumentRoleType GetRoleType(string name)
    {
        /* some implementation to lookup the role type */
        return null;
    }

    // Should be hidden from external access
}

public class Document
{
    public string Name
    {
        get;
        set;
    }

    public IEnumerable<DocumentRelationship> Relationships
    {
        get
        {
            return Roles.Where(d => d.Document == this).Select(r => r.Relationship).Distinct();
        }
    }

    public IEnumerable<DocumentComparison> Comparisons
    {
        get
        {
            return Relationships.OfType<DocumentComparison>();
        }
    }

    public IEnumerable<DocumentVersion> Versions
    {
        get
        {
            return Relationships.OfType<DocumentVersion>().OrderByDescending(v => v.VersionNumber);
        }
    }

    // Should be hidden from external access
    public IList<DocumentRole> Roles
    {
        get;
        private set;
    }
}

public sealed class DocumentComparison : DocumentRelationship
{
    public Document Original
    {
        get
        {
            return FindDocumentWithRole("Original");
        }
        set
        {
            SetDocumentWithRole("Original", value);
        }
    }

    public Document Modified
    {
        get
        {
            return FindDocumentWithRole("Modified");
        }
        set
        {
            SetDocumentWithRole("Modified", value);
        }
    }

    public Document Result
    {
        get
        {
            return FindDocumentWithRole("Result");
        }
        set
        {
            SetDocumentWithRole("Result", value);
        }
    }
}

public sealed class DocumentRole
{
    public DocumentRoleType RoleType
    {
        get;
        set;
    }

    public Document Document
    {
        get;
        set;
    }

    public DocumentRelationship Relationship
    {
        get;
        set;
    }
}

public sealed class DocumentRoleType
{
    public string Name
    {
        get;
        set;
    }

    public string Discriminator
    {
        get;
        set;
    }
}

public class DocumentVersion : DocumentRelationship
{
    public Document Previous
    {
        get
        {
            return FindDocumentWithRole("Previous");
        }
        set
        {
            SetDocumentWithRole("Previous", value);
        }
    }

    public Document Current
    {
        get
        {
            return FindDocumentWithRole("Current");
        }
        set
        {
            SetDocumentWithRole("Current", value);
        }
    }

    public int VersionNumber
    {
        get;
        set;
    }
}

For most part, I can map this with ease. Is it possible in LightSpeed to define the Original, Modified and Result properties of the DocumentComparison, without me having to write the query as I did? The following LINQ statement, which tries to find a list of "original documents" involved in comparisons, generates inefficient sql.

var document = /* get a document */
var originals = _unitOfWork.Query<DocumentComparison>().Where(c => c.Original == document).Distinct();

I'm looking to see if there is a way for LightSpeed to generate a single statement for the above query. The only work around I have is to create a method with a query that alomost looks the same as FindDocumentWIthRole in DocumentRelationship. I have about four different cases where the same pattern emerges, like relationships between parties (people and organizations).

One thing to note is that I do this a bit:

var comparison = new Comparison();
comparison.Original = new Document() { /* ... */ };
comparison.Modified = new Document() { /* ... */ };

And when we perform the comparison, I simply do the following:

var comparison = _unitOfWork.FindById<DocumentComparison>(id);
comparison.Result = _comparisonEngine.Compare(comparison.Original, comparison.Modified);

This is the reason I use a property and do not return IQueryable.

I'd be happy consider changing the model if that helps.

Thanks, Werner

Hmm, I'm not sure if I have fully grasped the structure or the query you're trying to run -- you describe it as 'find a list of "original" documents' but the code finds a list of comparisons in which a particular document acts as original. Assuming the code is correct, what you need to do is transform this into a query that relies only on mapped fields, not on helper methods (which cannot be translated to SQL and therefore force the query to run on the client).

Here is my effort based on what I've understood of your model -- it could be wrong though...!

Your original version:

.Where(c => c.Original == document);

Now we translate c.Original into mappable fields:

.Where(c => c.Roles.Where(r => r.Relationship == c && r.RoleType.Name == "Original")
                   .Any(r => r.DocumentId == document.Id))

We can combine the Where with the Any:

.Where(c => c.Roles.Any(r => r.Relationship == c
                               && r.RoleType.Name == "Original"
                                 && r.DocumentId == document.Id)

But if c.Roles is an association then for any DocumentRole in c.Roles its Relationship must be c, because that's just the reverse association (I think):

.Where(c => c.Roles.Any(r => r.RoleType.Name == "Original"
                               && r.DocumentId == document.Id)

Now we do have some restrictions on using traversals (r.RoleType.Name) with an Any so this may still not work. In that case, assuming the set of RoleTypes is reasonably static, you can cache the IDs of the role types (or even create an enum for them if they are fixed at the database level) and use the FK field:

.Where(c => c.Roles.Any(r => r.RoleTypeId == RoleTypeIds.Original
                               && r.DocumentId == document.Id)

Does that help or have I completely misunderstood how the associations go?

Ivan, you understood the model perfectly. The role types are static. Writing the where clause is feasible. What I was really looking for is whether LightSpeed can do this: http://docs.jboss.org/hibernate/orm/3.3/reference/en/html/associations.html#assoc-complex

Lets consider another (simpler) example:

class Person {
    public PersonName Name {  get; set; }
    public IList<PersonName> OtherNames { get; private set; }
    /*...*/
}

class PersonName {
    bool IsPrimary { get; set; }
    Person Person { get; set; } 
    /*...*/
}

Currently the model looks more like this:

class Person : Entity<long> {
    public EntityCollection<PersonName> Names { /*...*/ }
    /*...*/
}

class PersonName : Entity<long>{
    bool IsPrimary { /*...*/ }
    Person Person { /*...*/ } 
    /*...*/
}

This requires that I write helper methods to return the Primary name and OtherNames. What I'm was really wondering is whether I can tell LightSpeed that when Person.Name is referenced to ensure "IsPrimary = true" and in the case of Person.OtherNames, IsPrimary should be false. In a similar case if I wrote code like:

var person = /* ... */
person.Name = new PersonName() { /*...*/}

that the IsPrimary would be true when the new name is inserted. If I did something like this:

var person = /* ... */
person.OtherNames.Add(new PersonName() { /*...*/});

Then IsPrimary would be false. When I do a search, which is easy to understand:

var people = _unitOfWork.Query<Person>().Where(p => p.Name.FamilyName == "Doe")

Then somehow, LightSpeed will inject IsPrimary = true in the queries that searches for people with a family name of "Doe".

I hope it makes sense.

Thanks, Werner

You might be able to do this using our LINQ property-expression mapping, though I'm not sure whether this would work with a traversal as in your p.Name.FamilyName example. See http://www.mindscapehq.com/blog/index.php/2010/09/14/ninja-domain-properties-in-lightspeed/ for info.