Nhibernate duplicating column

I want to mapping following simple entities:

public class AnimalsOwner
{
    public AnimalsOwner()
    {
        Cats = new List<Cat>();
        Dogs = new List<Dog>();
    }

    public virtual int Id { get; set; }

    public virtual IList<Cat> Cats { get; set; }

    public virtual IList<Dog> Dogs { get; set; }
}

public abstract class Animal
{
    public virtual int Id { get; set; }

    public virtual AnimalsOwner AnimalsOwner { get; set; }
}

public class Dog : Animal
{
    public virtual string DogsProperty { get; s开发者_如何学运维et; }
}

public class Cat : Animal
{
    public virtual string CatsProperty { get; set; }
}

With the following mappings:

public OwnerMapping()
    {
        this.Table("Owners");
        Id(x => x.Id)
            .GeneratedBy.Native();

        HasMany(x => x.Cats).AsBag().Cascade.SaveUpdate();
        HasMany(x => x.Dogs).AsBag().Cascade.SaveUpdate();
    }
}

public class AnimalMapping : ClassMap<Animal>
{
    public AnimalMapping()
    {
        this.Table("Animals");
        Id(x => x.Id).GeneratedBy.Native();

        References(x => x.AnimalsOwner).Not.Nullable();
    }
}

public class DogMap : SubclassMap<Dog>
{
    public DogMap()
    {
        this.Table("Dogs");
        this.KeyColumn("AnimalId");
        Map(x => x.DogsProperty);
    }
}

public class CatMap : SubclassMap<Cat>
{
    public CatMap()
    {
        this.Table("Cats");
        this.KeyColumn("AnimalId");
        Map(x => x.CatsProperty);
    }
}

With such mappings everything works fine, but generated schema looks like following:

And such code:

 var owner = new AnimalsOwner();
                    owner.Cats.Add(new Cat()
                    {
                        AnimalsOwner = owner,
                        CatsProperty = "cat"
                    });

Makes inserts in all three tables (Animals, Cats, Dogs) of column OwnderId. But isn't it enough to have it only in Animals table? If yes then how to achieve it? If NHibernate acts as expected then why is he doing such a duplication?

I would map this using table-per-class strategy and filter the public collections by type. This database structure is much easier to work with and more efficient to query.

public class AnimalMapping : ClassMap<Animal>
{
    public AnimalMapping()
    {
        Table("Animals");
        Id(x => x.Id).GeneratedBy.Native();    
        References(x => x.AnimalsOwner);
        DiscriminateSubClassesOnColumn("AnimalType");
    }
}

public class DogMap : SubclassMap<Dog>
{
    public DogMap()
    {
        DiscriminatorValue("DOG");
        Map(x => x.DogsProperty);
    }
}

public class CatMap : SubclassMap<Cat>
{
    public CatMap()
    {
        DiscriminatorValue("CAT");
        Map(x => x.CatsProperty);
    }
}

The Dogs and Cats collection can be exposed by mapping the Animals collection as a private member and filtering by type:

public class AnimalsOwner
{
    private IList<Animal> _animals;

    public AnimalsOwner()
    {
        _animals = new List<Animal>();
    }

    public virtual int Id { get; set; }

    public virtual IEnumerable<Animal> Animals { get { return _animals; } }

    public virtual IEnumerable<Cat> Cats { get { return _animals.OfType<Cat>(); } }

    public virtual IEnumerable<Dog> Dogs { get { return _animals.OfType<Dog>(); } }

    public virtual void AddAnimal(Animal animal)
    {
        if (!_animals.Contains(animal))
        {
            animal.AnimalsOwner = this;
            _animals.Add(animal); 
        }
    }

    public virtual void RemoveAnimal(Animal animal)
    {
        if (_animals.Contains(animal))
        {
            animal.AnimalsOwner = null;
            _animals.Remove(animal);
        |
     }   
}

The mapping for this class would be:

public OwnerMapping()
    {
        this.Table("Owners");
        Id(x => x.Id).GeneratedBy.Native();

        HasMany(x => x.Animals.AsBag.Cascade.AllDeleteOrphan()
            .Inverse().LazyLoad()
            .Access.CamelCaseField(Prefix.Underscore);
    }
}

And the code for adding a cat would be:

var owner = new AnimalsOwner();
owner.AddAnimal(new Cat()
                {
                    CatsProperty = "cat"
                });

You're getting the duplicates becuse you have HasMany Cats and Dogs defined in the owner mapping (and Cat & Dog collections in the Owner class). Perhaps what you really want is a collection of Animals in the owners class (not individually dogs and cats) and just one HasMany Animals in the Owner mapping?