[Serializable]
      public sealed class ImageUserType : IUserType, IParameterizedType
      {
        private Byte[] data = null;

        public ImageUserType() : this(ImageFormat.Png)
        {
        }

        public ImageUserType(ImageFormat imageFormat)
        {
          this.ImageFormat = imageFormat;
        }

        public ImageFormat ImageFormat { get; private set; }

        public override Int32 GetHashCode()
        {
          return ((this as IUserType).GetHashCode(this.data));
        }

        public override Boolean Equals(Object obj)
        {
          ImageUserType other = obj as ImageUserType;

          if (other == null)
          {
            return (false);
          }

          if (Object.ReferenceEquals(this, other) == true)
          {
            return (true);
          }

          return (this.data.SequenceEqual(other.data));
        }

        Boolean IUserType.IsMutable
        {
          get
          {
            return (true);
          }
        }

        Object IUserType.Assemble(Object cached, Object owner)
        {
          return (cached);
        }

        Object IUserType.DeepCopy(Object value)
        {
          if (value is ICloneable)
          {
            return ((value as ICloneable).Clone());
          }
          else
          {
            return (value);
          }
        }

        Object IUserType.Disassemble(Object value)
        {
          return ((this as IUserType).DeepCopy(value));
        }

        Boolean IUserType.Equals(Object x, Object y)
        {
          return (Object.Equals(x, y));
        }

        Int32 IUserType.GetHashCode(Object x)
        {
          return ((x != null) ? x.GetHashCode() : 0);
        }

        Object IUserType.NullSafeGet(IDataReader rs, String[] names, Object owner)
        {
          this.data = NHibernateUtil.Binary.NullSafeGet(rs, names) as Byte[];

          if (data == null)
          {
            return (null);
          }

          using (Stream stream = new MemoryStream(this.data ?? new Byte[0]))
          {
            return (Image.FromStream(stream));
          }
        }

        void IUserType.NullSafeSet(IDbCommand cmd, Object value, Int32 index)
        {
          if (value != null)
          {
            Image data = value as Image;

            using (MemoryStream stream = new MemoryStream())
            {
              data.Save(stream, this.ImageFormat);
              value = stream.ToArray();
            }
          }

          NHibernateUtil.Binary.NullSafeSet(cmd, value, index);
        }

        Object IUserType.Replace(Object original, Object target, Object owner)
        {
          return (original);
        }

        Type IUserType.ReturnedType
        {
          get
          {
            return (typeof(Image));
          }
        }

        SqlType[] IUserType.SqlTypes
        {
          get
          {
            return (new SqlType[] { NHibernateUtil.BinaryBlob.SqlType });
          }
        }

        void IParameterizedType.SetParameterValues(IDictionary<String, String> parameters)
        {
          if ((parameters != null) && (parameters.ContainsKey("ImageFormat") == true))
          {
            this.ImageFormat = typeof(ImageFormat).GetProperty(parameters["ImageFormat"], 
      BindingFlags.Static | BindingFlags.Public | BindingFlags.GetProperty).GetValue(null, null) as ImageFormat;
          }
        }
      }

      public virtual Iesi.Collections.Generic.ISet<Comment> Comments { get; protected set; }

      public virtual IList<Post> Posts { get; protected set; }

      public class User
      {
        public virtual Iesi.Collections.Generic.ISet<Blog> Blogs { get; protected set; }
      }

      public class Blog
      {
        public virtual Iesi.Collections.Generic.ISet<User> Users { get; protected set; }
      }

      public virtual IDictionary<String, String> Attributes { get; protected set; }

      <?xml version="1.0" encoding="utf-8"?>
      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" >
        <class name="User" lazy="true" table="`user`">
          <id name="UserId" column="`user_id`" generator="hilo" />
          <property name="Username" column="`username`" length="10" not-null="true" />
          <property name="Birthday" column="`birthday`" not-null="false" />
          <component name="Details">
            <property name="Fullname" column="`fullname`" length="50" not-null="true" />
            <property name="Email" column="`email`" length="50" not-null="true" />
            <property name="Url" column="`url`" length="50" not-null="false" />
          </component>
          <set cascade="all-delete-orphan" inverse="true" lazy="true" name="Blogs">
            <key column="`user_id`" />
            <one-to-many class="Blog" />
          </set>
        </class>
      </hibernate-mapping>

      <?xml version="1.0" encoding="utf-8"?>
      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" >
        <class name="Blog" lazy="true" table="`blog`">
          <id name="BlogId" column="`blog_id `" generator="hilo" />
          <property name="Name" column="`NAME`" length="50" not-null="true" />
          <property name="Creation" column="`creation`" not-null="true" />
          <property name="PostCount" 
      formula="(SELECT COUNT(1) FROM post WHERE post.blog_id = blog_id)" />
          <property name="Picture" column="`PICTURE`" not-null="false" lazy="true">
            <type name="Succinctly.Common.ImageUserType, Succinctly.Common"/>
          </property>
          <many-to-one name="Owner" column="`user_id`" not-null="true" lazy="no-proxy" cascade="save-update"/>
          <list cascade="all-delete-orphan" inverse="true" lazy="true" name="Posts">
            <key column="`blog_id`" />
            <index column="`number`" />
            <one-to-many class="Post" />
          </list>
        </class>
      </hibernate-mapping>

      <?xml version="1.0" encoding="utf-8"?>
      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" >
        <class name="Post" lazy="true" table="`post`">
          <id name="PostId" column="`post_id`" generator="hilo" />
          <property name="Title" column="`title`" length="50" not-null="true" />
          <property name="Timestamp" column="`timestamp`" not-null="true" />
          <property name="Content" type="StringClob" column="`content`" length="2000" not-null="true" lazy="true" />
          <many-to-one name="Blog" column="`blog_id`" not-null="true" lazy="no-proxy" />
          <set cascade="all" lazy="true" name="Tags" table="`tag`" order-by="`tag`">
            <key column="`post_id`" />
            <element column="`tag`" type="String" length="20" not-null="true" unique="true" />
          </set>
          <set cascade="all-delete-orphan" inverse="true" lazy="true" name="Attachments">
            <key column="`post_id`" />
            <one-to-many class="Attachment" />
          </set>
          <bag cascade="all-delete-orphan" inverse="true" lazy="true" name="Comments">
            <key column="`post_id`" />
            <one-to-many class="Comment" />
          </bag>
        </class>
      </hibernate-mapping>

      <?xml version="1.0" encoding="utf-8"?>
      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" >
        <class name="Comment" lazy="true" table="`comment`">
          <id name="CommentId" column="`comment_id`" generator="hilo" />
          <property name="Timestamp" column="`timestamp`" not-null="true" />
          <property name="Content" type="StringClob" column="`content`" length="2000" not-null="true" lazy="true" />
          <component name="Details">
            <property name="Fullname" column="`fullname`" length="50" not-null="true" />
            <property name="Email" column="`email`" length="50" not-null="true" />
            <property name="Url" column="`url`" length="50" not-null="false" />
          </component>
          <many-to-one name="Post" column="`post_id`" not-null="true" lazy="no-proxy" />
        </class>
      </hibernate-mapping>

      <?xml version="1.0" encoding="utf-8"?>
      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" >
        <class name="Attachment" lazy="true" table="`attachment`">
          <id name="AttachmentId" column="`attachment_id`" generator="hilo" />
          <property name="Filename" column="`filename`" length="50" not-null="true" />
          <property name="Timestamp" column="`timestamp`" not-null="true" />
          <property name="Contents" type="BinaryBlob" column="`contents`" length="100000" not-null="true" lazy="true" />
          <many-to-one name="Post" column="`post_id`" not-null="true" lazy="no-proxy" />
        </class>
      </hibernate-mapping>

      <?xml version="1.0" encoding="utf-8"?>
      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" >
        <class name="Attachment" lazy="true" table="`attachment`">
          <id name="AttachmentId" column="`attachment_id`" generator="hilo">
            <param name="sequence">ATTACHMENT_SEQUENCE</param>
          </id>
        <!-- … ->
      </hibernate-mapping>

        //add an assembly by name
        cfg.AddAssembly("Succinctly.Model");
        //add an Assembly instance
        cfg.AddAssembly(typeof(Blog).Assembly);

      <session-factory>
        <!-- … ->
        <mapping assembly="Succinctly.Model" />
      </session-factory>

      //add a single file
      cfg.AddFile("Blog.hbm.xml");
      //add all .HBM.XML files in a directory
      cfg.AddDirectory(new DirectoryInfo("."));

      public class UserMapping : ClassMapping<User>
      {
        public UserMapping()
        {
          this.Table("user");
          this.Lazy(true);

          this.Id(x => x.UserId, x =>
          {
            x.Column("user_id");
            x.Generator(Generators.HighLow);
          });

          this.Property(x => x.Username, x =>
          {
            x.Column("username");
            x.Length(20);
            x.NotNullable(true);
          });
          this.Property(x => x.Birthday, x =>
          {
            x.Column("birthday");
            x.NotNullable(false);
          });
          this.Component(x => x.Details, x =>
          {
            x.Property(y => y.Fullname, z =>
            {
              z.Column("fullname");
              z.Length(50);
              z.NotNullable(true);
            });
            x.Property(y => y.Email, z =>
            {
              z.Column("email");
              z.Length(50);
              z.NotNullable(true);
            });
            x.Property(y => y.Url, z =>
            {
              z.Column("url");
              z.Length(50);
              z.NotNullable(false);
            });
          });

          this.Set(x => x.Blogs, x =>
          {
            x.Key(y =>
            {
              y.Column("user_id");
              y.NotNullable(true);
            });
            x.Cascade(Cascade.All | Cascade.DeleteOrphans);
            x.Inverse(true);
            x.Lazy(CollectionLazy.Lazy);
          }, x =>
          {
            x.OneToMany();
          });
        }
      }

      public class BlogMapping : ClassMapping<Blog>
      {
        public BlogMapping()
        {
          this.Table("blog");
          this.Lazy(true);

          this.Id(x => x.BlogId, x =>
          {
            x.Column("blog_id");
            x.Generator(Generators.HighLow);
          });

          this.Property(x => x.Name, x =>
          {
            x.Column("name");
            x.Length(50);
            x.NotNullable(true);
          });
          this.Property(x => x.Picture, x =>
          {
            x.Column("picture");
            x.NotNullable(false);
            x.Type<ImageUserType>();
            x.Lazy(true);
          });
          this.Property(x => x.Creation, x =>
          {
            x.Column("creation");
            x.NotNullable(true);
          });
          this.Property(x => x.PostCount, x =>
          {
            x.Formula("(SELECT COUNT(1) FROM post WHERE post.blog_id = blog_id)");
          });

          this.ManyToOne(x => x.Owner, x =>
          {
            x.Cascade(Cascade.Persist);
            x.Column("user_id");
            x.NotNullable(true);
            x.Lazy(.NoProxy);
          });

          this.List(x => x.Posts, x =>
          {
            x.Key(y =>
            {
              y.Column("blog_id");
              y.NotNullable(true);
            });
            x.Index(y =>
            {
              y.Column("number");
            });
            x.Lazy(CollectionLazy.Lazy);
            x.Cascade(Cascade.All | Cascade.DeleteOrphans);
            x.Inverse(true);
          }, x =>
          {
            x.OneToMany();
          });
        }
      }

      public class PostMapping : ClassMapping<Post>
        {
          public PostMapping()
          {
            this.Table("post");
            this.Lazy(true);

            this.Id(x => x.PostId, x =>
            {
              x.Column("post_id");
              x.Generator(Generators.HighLow);
            });

            this.Property(x => x.Title, x =>
            {
              x.Column("title");
              x.Length(50);
              x.NotNullable(true);
            });
            this.Property(x => x.Timestamp, x =>
            {
              x.Column("timestamp");
              x.NotNullable(true);
            });
            this.Property(x => x.Content, x =>
            {
              x.Column("content");
              x.Length(2000);
              x.NotNullable(true);
              x.Type(NHibernateUtil.StringClob);
            });

            this.ManyToOne(x => x.Blog, x =>
            {
              x.Column("blog_id");
              x.NotNullable(true);
              x.Lazy(.NoProxy);
            });

            this.Set(x => x.Tags, x =>
            {
              x.Key(y =>
              {
                y.Column("post_id");
                y.NotNullable(true);
              });
              x.Cascade(Cascade.All);
              x.Lazy(CollectionLazy.NoLazy);
              x.Fetch(CollectionFetchMode.Join);
              x.Table("tag");
            }, x =>
            {
              x.Element(y =>
              {
                y.Column("tag");
                y.Length(20);
                y.NotNullable(true);
                y.Unique(true);
              });
            });
            this.Set(x => x.Attachments, x =>
            {
              x.Key(y =>
              {
                y.Column("post_id");
                y.NotNullable(true);
              });
              x.Cascade(Cascade.All | Cascade.DeleteOrphans);
              x.Lazy(CollectionLazy.Lazy);
              x.Inverse(true);
            }, x =>
            {
              x.OneToMany();
            });
            this.Bag(x => x.Comments, x =>
            {
              x.Key(y =>
              {
                y.Column("post_id");
              });
              x.Cascade(Cascade.All | Cascade.DeleteOrphans);
              x.Lazy(CollectionLazy.Lazy);
              x.Inverse(true);
            }, x =>
            {
              x.OneToMany();
            });
          }
        }

      public class CommentMapping : ClassMapping<Comment>
      {
        public CommentMapping()
        {
          this.Table("comment");
          this.Lazy(true);

          this.Id(x => x.CommentId, x =>
          {
            x.Column("comment_id");
            x.Generator(Generators.HighLow);
          });

          this.Property(x => x.Content, x =>
          {
            x.Column("content");
            x.NotNullable(true);
            x.Length(2000);
            x.Lazy(true);
            x.Type(NHibernateUtil.StringClob);
          });
          this.Property(x => x.Timestamp, x =>
          {
            x.Column("timestamp");
            x.NotNullable(true);
          });

          this.Component(x => x.Details, x =>
          {
            x.Property(y => y.Fullname, z =>
            {
              z.Column("fullname");
              z.Length(50);
              z.NotNullable(true);
            });
            x.Property(y => y.Email, z =>
            {
              z.Column("email");
              z.Length(50);
              z.NotNullable(true);
            });
            x.Property(y => y.Url, z =>
            {
              z.Column("url");
              z.Length(50);
              z.NotNullable(false);
            });
          });

          this.ManyToOne(x => x.Post, x =>
          {
            x.Column("post_id");
            x.NotNullable(true);
            x.Lazy(LazyRelation.NoProxy);
          });
        }
      }

      public class AttachmentMapping : ClassMapping<Attachment>
      {
        public AttachmentMapping()
        {
          this.Table("attachment");
          this.Lazy(true);

          this.Id(x => x.AttachmentId, x =>
          {
            x.Column("attachment_id");
            x.Generator(Generators.HighLow);
          });

          this.Property(x => x.Filename, x =>
          {
            x.Column("filename");
            x.Length(50);
            x.NotNullable(true);
          });
          this.Property(x => x.Timestamp, x =>
          {
            x.Column("timestamp");
            x.NotNullable(true);
          });
          this.Property(x => x.Contents, x =>
          {
            x.Column("contents");
            x.Length(100000);
            x.Type<BinaryBlobType>();
            x.NotNullable(true);
            x.Lazy(true);
          });

          this.ManyToOne(x => x.Post, x =>
          {
            x.Column("post_id");
            x.Lazy(LazyRelation.NoProxy);
            x.NotNullable(true);
          });
        }
      }

      public class AttachmentMapping : ClassMapping<Attachment>
      {
        public AttachmentMapping()
        {
          this.Table("attachment");
          this.Lazy(true);

          this.Id(x => x.AttachmentId, x =>
          {
            x.Column("attachment_id");
            x.Generator(Generators.HighLow, x => x.Params(new { sequence = "ATTACHMENT_SEQUENCE" } ));
          });
          //…
      }

      this.Id("AttachmentId", x =>
      {
      >  //…
      });

      this.Property("Filename", x =>
      {
      >  //…
      });

      this.ManyToOne("Post", x =>
      {
        //…
      });

      Configuration cfg = BuildConfiguration(); //whatever way you like
      ModelMapper mapper = new ModelMapper();

      >//1: one class at a time
      mapper.AddMapping<BlogMapping>();
      mapper.AddMapping<UserMapping>();
      mapper.AddMapping<PostMapping>();
      mapper.AddMapping<CommentMapping>();
      mapper.AddMapping<AttachmentMapping>();

      >//2: or all at once (pick one or the other, not both)
      mapper.AddMappings(new Type[] { typeof(BlogMapping), typeof(UserMapping), typeof(PostMapping),
      typeof(CommentMapping), typeof(AttachmentMapping) });

      //3: or even dynamically found types (pick one or the other, not both)
      mapper.AddMappings(typeof(BlogMapping).Assembly.GetTypes().Where(x => x.BaseType.IsGenericType && x.BaseType.GetGenericTypeDefinition() == typeof(ClassMapping<>)));

      //code to be executed in all cases.
      HbmMapping mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();
      cfg.AddDeserializedMapping(mappings, null);

      mapper.Class<Blog>(ca =>
      {
        ca.Table("blog");
        ca.Lazy(true);
        ca.Id(x => x.BlogId, map =>
        {
          map.Column("blog_id");
          map.Generator(Generators.HighLow);
        });
      //…

      [Class(Table = "user", Lazy = true)]
      public class User
      {
        public User()
        {
          this.Blogs = new Iesi.Collections.Generic.HashedSet<Blog>();
          this.Details = new UserDetail();
        }

        [Id(0, Column = "user_id", Name = "UserId")]
        [Generator(1, Class = "hilo")]
        public virtual Int32 UserId { get; protected set; }

        [Property(Name = "Username", Column = "username", Length = 20, NotNull = true)]
        public virtual String Username { get; set; }

        [ComponentProperty(PropertyName = "Details")]
        public virtual UserDetail Details { get; set; }

        [Property(Name = "Birthday", Column = "birthday", NotNull = false)]
        public virtual DateTime? Birthday { get; set; }

        [Set(0, Name = "Blogs", Cascade = "all-delete-orphan", Lazy = CollectionLazy.True, Inverse = true, 
      Generic = true)]
        [Key(1, Column = "user_id", NotNull = true)]
        [OneToMany(2, ClassType = typeof(Blog))]
        public virtual Iesi.Collections.Generic.ISet<Blog> Blogs { get; protected set; }
      }

      [Class(Table = "blog", Lazy = true)]
      public class Blog
      {
        public Blog()
        {
          this.Posts = new List<Post>();
        }

        [Id(0, Column = "blog_id", Name = "BlogId")]
        [Generator(1, Class = "hilo")]
        public virtual Int32 BlogId { get; protected set; }

        [Property(Column = "picture", NotNull = false, TypeType = typeof(ImageUserType), Lazy = true)]
        public virtual Image Picture { get; set; }

        [Property(Name = "PostCount", Formula = "(SELECT COUNT(1) FROM post WHERE post.blog_id = blog_id)")]
        public virtual Int64 PostCount { get; protected set; }

        [ManyToOne(0, Column = "user_id", NotNull = true, Lazy = Laziness.NoProxy, Name = "Owner", 
      Cascade = "save-update")]
        [Key(1)]
        public virtual User Owner { get; set; }

        [Property(Name = "Name", Column = "name", NotNull = true, Length = 50)]
        public virtual String Name { get; set; }

        [Property(Name = "Creation", Column = "creation", NotNull = true)]
        public virtual DateTime Creation { get; set; }

        [List(0, Name = "Posts", Cascade = "all-delete-orphan", Lazy =  CollectionLazy.True, Inverse = true, 
      Generic = true)]
        [Key(1, Column = "blog_id", NotNull = true)]
        [Index(2, Column = "number")]
        [OneToMany(3, ClassType = typeof(Post))]
        public virtual IList<Post> Posts { get; protected set; }
      }

      [Class(Table = "post", Lazy = true)]
      public class Post
      {
        public Post()
        {
          this.Tags = new Iesi.Collections.Generic.HashedSet<String>();
          this.Attachments = new Iesi.Collections.Generic.HashedSet<Attachment>();
          this.Comments = new List<Comment>();
        }

        [Id(0, Column = "post_id", Name = "PostId")]
        [Generator(1, Class = "hilo")]
        public virtual Int32 PostId { get; protected set; }

        [ManyToOne(0, Column = "blog_id", NotNull = true, Lazy = Laziness.NoProxy, Name = "Blog")]
        [Key(1)]
        public virtual Blog Blog { get; set; }

        [Property(Name = "Timestamp", Column = "timestamp", NotNull = true)]
        public virtual DateTime Timestamp { get; set; }

        [Property(Name = "Title", Column = "title", Length = 50, NotNull = true)]
        public virtual String Title { get; set; }

        [Property(Name = "Content", Column = "content", Length = 2000, NotNull = true, Lazy = true, 
      Type = "StringClob")]
        public virtual String Content { get; set; }

        [Set(0, Name = "Tags", Table = "tag", OrderBy = "tag", Lazy = CollectionLazy.False, 
      Cascade = "all", Generic = true)]
        [Key(1, Column = "post_id", Unique = true, NotNull = true)]
        [Element(2, Column = "tag", Length = 20, NotNull = true, Unique = true)]
        public virtual Iesi.Collections.Generic.ISet<String> Tags { get; protected set; }

        [Set(0, Name = "Attachments", Inverse = true, Lazy = CollectionLazy.True, Generic = true, 
      Cascade = "all-delete-orphan")]
        [Key(1, Column = "post_id", NotNull = true)]
        [OneToMany(2, ClassType = typeof(Attachment))]
        public virtual Iesi.Collections.Generic.ISet<Attachment> Attachments { get; protected set; }

        [Bag(0, Name = "Comments", Inverse = true, Lazy = CollectionLazy.True, Generic = true, 
      Cascade = "all-delete-orphan")]
        [Key(1, Column = "post_id", NotNull = true)]
        [OneToMany(2, ClassType = typeof(Comment))]
        public virtual IList<Comment> Comments { get; protected set; }
      }

      [Class(Table = "comment", Lazy = true)]
      public class Comment
      {
        public Comment()
        {
          this.Details = new UserDetail();
        }

        [Id(0, Column = "comment_id", Name = "CommentId")]
        [Generator(1, Class = "hilo")]
        public virtual Int32 CommentId { get; protected set; }

        [ComponentProperty(PropertyName = "Details")]
        public virtual UserDetail Details { get; set; }

        [Property(Name = "Timestamp", Column = "timestamp", NotNull = true)]
        public virtual DateTime Timestamp { get; set; }

        [Property(Name = "Content", Column = "content", NotNull = true, Length = 2000, Lazy = true, 
      Type = "StringClob")]
        public virtual String Content { get; set; }

        [ManyToOne(0, Column = "post_id", NotNull = true, Lazy = Laziness.NoProxy, Name = "Post")]
        [Key(1)]
        public virtual Post Post { get; set; }
      }

      [Class(Table = "attachment", Lazy = true)]
      public class Attachment
      {
        [Id(0, Column = "attachment_id", Name = "AttachmentId")]
        [Generator(1, Class = "hilo")]
        public virtual Int32 AttachmentId { get; protected set; }

        [Property(Name = "Filename", Column = "filename", Length = 50, NotNull = true)]
        public virtual String Filename { get; set; }

        [Property(Name = "Contents", Column = "contents", NotNull = true, Length = 100000, 
      Type = "BinaryBlob")]
        public virtual Byte[] Contents { get; set; }

        [Property(Name = "Timestamp", Column = "timestamp", NotNull = true)]
        public virtual DateTime Timestamp { get; set; }

        [ManyToOne(0, Column = "post_id", NotNull = true, Lazy = Laziness.NoProxy, Name = "Post")]
        [Key(1)]
        public virtual Post Post { get; set; }
      }

      [Component]
      public class UserDetail
      {
        [Property(Name = "Url", Column = "url", Length = 50, NotNull = false)]
        public String Url { get; set; }

        [Property(Name = "Fullname", Column = "fullname", Length = 50, NotNull = true)]
        public String Fullname { get; set; }

        [Property(Name = "Email", Column = "email", Length = 50, NotNull = true)]
        public String Email { get; set; }
      }

      HbmSerializer serializer = new HbmSerializer() { Validate = true };

      using (MemoryStream stream = serializer.Serialize(typeof(Blog).Assembly))
      {
        cfg.AddInputStream(stream);
      }

      [Class(Table = "attachment", Lazy = true)]
      public class Attachment
      {
        [Id(0, Column = "attachment_id", Name = "AttachmentId")]
        [Generator(1, Class = "hilo")]
        [Param(Name = "sequence", Content = "ATTACHMENT_SEQUENCE")]
        public virtual Int32 AttachmentId { get; protected set; }
        //
      }

      public class PersonMapping : ClassMapping<Person>
      {
        public PersonMapping()
        {
          this.Table("person");
          this.Lazy(true);

          this.Discriminator(x =>
          {
            x.Column("class");
            x.NotNullable(true);
          });

          this.Id(x => x.PersonId, x =>
          {
            x.Column("person_id");
            x.Generator(Generators.HighLow);
          });

          this.Property(x => x.Name, x =>
          {
            x.Column("name");
            x.NotNullable(true);
            x.Length(100);
          });

          this.Property(x => x.Gender, x =>
          {
            x.Column("gender");
            x.NotNullable(true);
            x.Type<EnumType<Gender>>();
          });
        }
      }

      public class NationalCitizenMappping : SubclassMapping<NationalCitizen>
      {
        public NationalCitizenMappping()
        {
          this.DiscriminatorValue("national_citizen");
          this.Lazy(true);

          this.Property(x => x.NationalIdentityCard, x =>
          {
            x.Column("national_identity_card");
            x.Length(20);
            x.NotNullable(true);
          });
        }
      }

      public class ForeignCitizenMapping : SubclassMapping<ForeignCitizen>
      {
        public ForeignCitizenMapping()
        {
          this.DiscriminatorValue("foreign_citizen");
          this.Lazy(true);

          this.Property(x => x.Country, x =>
          {
            x.Column("country");
            x.Length(20);
            x.NotNullable(true);
          });

          this.Property(x => x.Passport, x =>
          {
            x.Column("passport");
            x.Length(20);
            x.NotNullable(true);
          });
        }
      }

      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" >
        <class name="Person" lazy="true" table="`person`" abstract="true">
          <id column="`person_id`" name="PersonId" generator="hilo"/>
          <discriminator column="`class`"/>
          <property name="Name" column="`name`" length="100" not-null="true"/>
          <property name="Gender" column="gender"/>
        </class>
      </hibernate-mapping>

      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" 
      >
        <subclass name="NationalCitizen" lazy="true" extends="Person" discriminator-value="national_citizen">
          <property name="NationalIdentityCard" column="`national_identity_card`" length="20" not-null="false"/>
        </subclass>
      </hibernate-mapping>

      <hibernate-mapping namespace="Succinctly.Model" assembly="Succinctly.Model" 
      >
        <subclass name="ForeignCitizen" lazy="true" extends="Person" discriminator-value="foreign_citizen">
          <property name="Country" column="`country`" length="20" not-null="false"/>
          <property name="Passport" column="`passport`" length="20" not-null="false"/>
        </subclass>
      </hibernate-mapping>

      [Class(0, Table = "person", Lazy = true, Abstract = true)]
      [Discriminator(1, Column = "class")]
      public abstract class Person
      {
        [Id(0, Name = "PersonId", Column = "person_id")]
        [Generator(1, Class = "hilo")]
        public virtual Int32 PersonId { get; protected set; }

        [Property(Name = "Name", Column = "name", Length = 100, NotNull = true)]
        public virtual String Name { get; set; }

        [Property(Name = "Gender", Column = "gender", TypeType = typeof(EnumType<Gender>), NotNull = true)]
        public virtual Gender Gender { get; set; }
      }

      [Subclass(DiscriminatorValue = "national_citizen", ExtendsType = typeof(Person), Lazy = true)]
      public class NationalCitizen : Person
      {
        [Property(Name = "NationalIdentityCard", Column = "national_identity_card", Length = 50, NotNull = false)]
        public virtual String NationalIdentityCard { get; set; }
      }

      [Subclass(DiscriminatorValue = "foreign_citizen", ExtendsType = typeof(Person), Lazy = true)]
      public class ForeignCitizen : Person
      {
        [Property(Name = "Passport", Column = "passport", Length = 50, NotNull = false)]
        public virtual String Passport { get; set; }

        [Property(Name = "Country", Column = "country", Length = 50, NotNull = false)]
        public virtual String Country { get; set; }
      }

      IEnumerable<Person> allPeopleFromLinq = session.Query<Person>().ToList();

      SELECT
      person0_.person_id AS person1_2_,
      person0_.name AS name2_,
      person0_.gender AS gender2_,
      person0_.passport AS passport2_,
      person0_.country AS country2_,
      person0_.national_identity_card AS national7_2_,
      person0_.[class] AS class2_2_
      FROM
           person person0_

      IEnumerable<NationalCitizen> nationalCitizensFromLinq = session.Query<NationalCitizen>().ToList();

      SELECT
      nationalci0_.person_id AS person1_2_,
      nationalci0_.name AS name2_,
      nationalci0_.gender AS gender2_,
      nationalci0_.national_identity_card AS national7_2_
      FROM
      person nationalci0_
      WHERE
          nationalci0_.[class] = 'national_citizen'

      public class PersonMapping : ClassMapping<Person>
      {
        public PersonMapping()
        {
          this.Table("person");
          this.Lazy(true);

          this.Id(x => x.PersonId, x =>
          {
            x.Column("person_id");
            x.Generator(Generators.HighLow);
          });

          this.Property(x => x.Name, x =>
          {
            x.Column("name");
            x.NotNullable(true);
            x.Length(100);
          });

          this.Property(x => x.Gender, x =>
          {
            x.Column("gender");
            x.NotNullable(true);
            x.Type<EnumType<Gender>>();
          });
        }
      }

      public class NationalCitizenMappping : JoinedSubclassMapping<NationalCitizen>
      {
        public NationalCitizenMappping()
        {

          this.Table("national_citizen");
          this.Lazy(true);

          this.Key(x =>
          {
            x.Column("person_id");
            x.NotNullable(true);
          });

          this.Property(x => x.NationalIdentityCard, x =>
          {
            x.Column("national_identity_card");
            x.Length(20);
            x.NotNullable(true);
          });
        }
      }

      public class ForeignCitizenMapping : JoinedSubclassMapping<ForeignCitizen>
      {
        public ForeignCitizenMapping()
        {

          this.Table("foreign_citizen");
          this.Lazy(true);

          this.Key(x =>
          {
            x.Column("person_id");
            x.NotNullable(true);
          });

          this.Property(x => x.Country, x =>
          {
            x.Column("country");
            x.Length(20);
            x.NotNullable(true);
          });

          this.Property(x => x.Passport, x =>
          {
            x.Column("passport");
            x.Length(20);
            x.NotNullable(true);
          });
        }
      }