NHibernate ReferencesAny pulling back the wrong type

I've got a table called AdministratorPrivilages that has the following fields:

• ID
• List item
• MemberId
• Value
• MemberType

Now, the members can be of two types (Enterprise and Express). Enterprise members live in the enterprise table. Express members live in the expressmember table. I've tried to do my fluent mapping like so.

public class AdministratorPrivilegesMapping : ClassMap<AdministratorPrivileges>
    {
        public AdministratorPrivilegesMapping()
        {
            Id(x=>x.Id);
            Map(x => x.Value).Column("Value");
            ReferencesAny(x => x.Member)
                .EntityTypeColumn("MemberType")
                .EntityIdentifierColumn("MemberId")
                .IdentityType<Int32>()
                .AddMetaValue<ExpressMember>("Express开发者_Python百科")
                .AddMetaValue<Member>("Enterprise");

        }
    }

Both member tables have integer ids with ascending values. When I try to pull back the privilages associated with enterprise member 10, I'm getting the permission set associated with Express Member 10. Both other tables are mapped with the old school hbm mapping files.

Am I missing something obvious? I'm using NHibernate 2.1 and FluentNhibernate 1.1

I actually found the solution using .Where(). My situation is a little different, I have objectA and objectB. objectA contains objectB, but objectB also contains a collection of objectBs.

"objectA":{ "someProp" : "(string)", "objectB":{ "someProp" : "(string)", "comeCol" : [ "(objectB)" ] } }

So the "Parent" property of objectB can either be of type objectB or objectA, which is why I needed to use ReferencesAny in the mapping of objectB.

Mapping looks like

        ReferencesAny( x => x.Parent )
            .IdentityType< int >()
            .MetaType< string >()
            .EntityTypeColumn( "ParentType" )
            .EntityIdentifierColumn( "ParentId" )
            .AddMetaValue< objectA >( "E" )
            .AddMetaValue< objectB >( "S" )
            .Access.Property()
            .LazyLoad()
            .Cascade.All();

All this works well when saving, however, my problem occured when retrieving, because the framework wasn't told what to retrieve and simply retrieved everything.

So now here is the mapping of the collection that fixed the problem:

        HasMany( x => x.objectBs )
            .KeyColumn( "ParentId" )
            .Where( "ParentType = 'S'" )
            .Cascade.All()
            .LazyLoad();

Hope it will help anyone in the same situation :)

As seems to always be the case when I post on Stackoverflow, I'm being a complete goober and missing something glaringly obvious that cleared itself up with a good night's rest and some caffeine. I needed to look into the mappings for the ExpressMember and Member classes. Turns out the bag declarations there didn't filter by the type of object appropriately. Initially, I thought I had made the breaking change, when in fact it was actually a very old issue. The collision in id numbers between the two different types of members was not an issue for a very long time, as express members typically have either all the permissions or none, as do most of the older members (which were created first under an admin/plebe scheme with privileges being broken out later).