Exemple #1
0
        public void HandleUnionSubclass(PersistentClass model, HbmUnionSubclass unionSubclassMapping, IDictionary <string, MetaAttribute> inheritedMetas)
        {
            var unionSubclass = new UnionSubclass(model);

            BindClass(unionSubclassMapping, unionSubclass, inheritedMetas);
            inheritedMetas = GetMetas(unionSubclassMapping, inheritedMetas, true);             // get meta's from <union-subclass>

            // union subclass
            if (unionSubclass.EntityPersisterClass == null)
            {
                unionSubclass.RootClazz.EntityPersisterClass = typeof(UnionSubclassEntityPersister);
            }

            //table + schema names
            string schema  = unionSubclassMapping.schema ?? mappings.SchemaName;
            string catalog = unionSubclassMapping.catalog ?? mappings.CatalogName;

            Table denormalizedSuperTable = unionSubclass.Superclass.Table;
            Table mytable =
                mappings.AddDenormalizedTable(schema, catalog, GetClassTableName(unionSubclass, unionSubclassMapping.table),
                                              unionSubclass.IsAbstract.GetValueOrDefault(), unionSubclassMapping.Subselect, denormalizedSuperTable);

            ((ITableOwner)unionSubclass).Table = mytable;

            log.Info("Mapping union-subclass: {0} -> {1}", unionSubclass.EntityName, unionSubclass.Table.Name);

            // properties
            new PropertiesBinder(mappings, unionSubclass, dialect).Bind(unionSubclassMapping.Properties, inheritedMetas);
            BindUnionSubclasses(unionSubclassMapping.UnionSubclasses, unionSubclass, inheritedMetas);

            model.AddSubclass(unionSubclass);
            mappings.AddClass(unionSubclass);
        }
Exemple #2
0
        public void HandleUnionSubclass(PersistentClass model, XmlNode subnode, IDictionary <string, MetaAttribute> inheritedMetas)
        {
            var unionSubclass = new UnionSubclass(model);

            BindClass(subnode, null, unionSubclass, inheritedMetas);
            inheritedMetas = GetMetas(subnode.SelectNodes(HbmConstants.nsMeta, namespaceManager), inheritedMetas, true);             // get meta's from <union-subclass>

            // union subclass
            if (unionSubclass.EntityPersisterClass == null)
            {
                unionSubclass.RootClazz.EntityPersisterClass = typeof(UnionSubclassEntityPersister);
            }

            //table + schema names
            XmlAttribute schemaNode  = subnode.Attributes["schema"];
            string       schema      = schemaNode == null ? mappings.SchemaName : schemaNode.Value;
            XmlAttribute catalogNode = subnode.Attributes["catalog"];
            string       catalog     = catalogNode == null ? mappings.CatalogName : catalogNode.Value;

            Table denormalizedSuperTable = unionSubclass.Superclass.Table;
            Table mytable =
                mappings.AddDenormalizedTable(schema, catalog, GetClassTableName(unionSubclass, subnode),
                                              unionSubclass.IsAbstract.GetValueOrDefault(), null, denormalizedSuperTable);

            ((ITableOwner)unionSubclass).Table = mytable;

            log.InfoFormat("Mapping union-subclass: {0} -> {1}", unionSubclass.EntityName, unionSubclass.Table.Name);

            // properties
            PropertiesFromXML(subnode, unionSubclass, inheritedMetas);

            model.AddSubclass(unionSubclass);
            mappings.AddClass(unionSubclass);
        }
Exemple #3
0
        public void HandleJoinedSubclass(PersistentClass model, HbmJoinedSubclass joinedSubclassMapping, IDictionary <string, MetaAttribute> inheritedMetas)
        {
            var subclass = new JoinedSubclass(model);

            BindClass(joinedSubclassMapping, subclass, inheritedMetas);
            inheritedMetas = GetMetas(joinedSubclassMapping, inheritedMetas, true);             // get meta's from <joined-subclass>

            // joined subclass
            if (subclass.EntityPersisterClass == null)
            {
                subclass.RootClazz.EntityPersisterClass = typeof(JoinedSubclassEntityPersister);
            }

            //table + schema names
            string schema  = joinedSubclassMapping.schema ?? mappings.SchemaName;
            string catalog = joinedSubclassMapping.catalog ?? mappings.CatalogName;

            // TODO: very strange, the schema does not support it
            //XmlAttribute actionNode = subnode.Attributes["schema-action"];
            //string action = actionNode == null ? "all" : actionNode.Value;
            string action = "all";

            Table mytable = mappings.AddTable(schema, catalog, GetClassTableName(subclass, joinedSubclassMapping.table), null, false, action);

            ((ITableOwner)subclass).Table = mytable;

            log.InfoFormat("Mapping joined-subclass: {0} -> {1}", subclass.EntityName, subclass.Table.Name);

            // KEY
            BindKey(subclass, joinedSubclassMapping.key, mytable);

            subclass.CreatePrimaryKey(dialect);

            if (!subclass.IsJoinedSubclass)
            {
                throw new MappingException(
                          "Cannot map joined-subclass " + subclass.EntityName + " to table " +
                          subclass.Table.Name + ", the same table as its base class.");
            }

            subclass.CreateForeignKey();
            // CHECK
            mytable.AddCheckConstraint(joinedSubclassMapping.check);

            // properties
            new PropertiesBinder(mappings, subclass, dialect).Bind(joinedSubclassMapping.Properties, inheritedMetas);

            BindJoinedSubclasses(joinedSubclassMapping.JoinedSubclasses, subclass, inheritedMetas);

            model.AddSubclass(subclass);
            mappings.AddClass(subclass);
        }
        public void HandleSubclass(PersistentClass model, XmlNode subnode, IDictionary <string, MetaAttribute> inheritedMetas)
        {
            Subclass subclass = new SingleTableSubclass(model);

            BindClass(subnode, null, subclass, inheritedMetas);

            inheritedMetas = GetMetas(subnode.SelectNodes(HbmConstants.nsMeta, namespaceManager), inheritedMetas, true);             // get meta's from <subclass>

            if (subclass.EntityPersisterClass == null)
            {
                subclass.RootClazz.EntityPersisterClass = typeof(SingleTableEntityPersister);
            }

            log.InfoFormat("Mapping subclass: {0} -> {1}", subclass.EntityName, subclass.Table.Name);

            // properties
            PropertiesFromXML(subnode, subclass, inheritedMetas);

            model.AddSubclass(subclass);
            mappings.AddClass(subclass);
        }
        public void HandleSubclass(PersistentClass model, HbmSubclass subClassMapping, IDictionary <string, MetaAttribute> inheritedMetas)
        {
            Subclass subclass = new SingleTableSubclass(model);

            BindClass(subClassMapping, subclass, inheritedMetas);
            inheritedMetas = GetMetas(subClassMapping, inheritedMetas, true);             // get meta's from <subclass>

            if (subclass.EntityPersisterClass == null)
            {
                subclass.RootClazz.EntityPersisterClass = typeof(SingleTableEntityPersister);
            }

            log.InfoFormat("Mapping subclass: {0} -> {1}", subclass.EntityName, subclass.Table.Name);

            // properties
            new PropertiesBinder(mappings, subclass, dialect).Bind(subClassMapping.Properties, inheritedMetas);
            BindJoins(subClassMapping.Joins, subclass, inheritedMetas);
            BindSubclasses(subClassMapping.Subclasses, subclass, inheritedMetas);

            model.AddSubclass(subclass);
            mappings.AddClass(subclass);
        }
Exemple #6
0
        public void HandleJoinedSubclass(PersistentClass model, XmlNode subnode, IDictionary <string, MetaAttribute> inheritedMetas)
        {
            JoinedSubclass subclass = new JoinedSubclass(model);

            BindClass(subnode, null, subclass, inheritedMetas);
            inheritedMetas = GetMetas(subnode.SelectNodes(HbmConstants.nsMeta, namespaceManager), inheritedMetas, true);             // get meta's from <joined-subclass>
            // joined subclass
            if (subclass.EntityPersisterClass == null)
            {
                subclass.RootClazz.EntityPersisterClass = typeof(JoinedSubclassEntityPersister);
            }

            //table + schema names
            XmlAttribute schemaNode  = subnode.Attributes["schema"];
            string       schema      = schemaNode == null ? mappings.SchemaName : schemaNode.Value;
            XmlAttribute catalogNode = subnode.Attributes["catalog"];
            string       catalog     = catalogNode == null ? mappings.CatalogName : catalogNode.Value;

            XmlAttribute actionNode = subnode.Attributes["schema-action"];
            string       action     = actionNode == null ? "all" : actionNode.Value;

            Table mytable = mappings.AddTable(schema, catalog, GetClassTableName(subclass, subnode), null, false, action);

            ((ITableOwner)subclass).Table = mytable;

            log.InfoFormat("Mapping joined-subclass: {0} -> {1}", subclass.EntityName, subclass.Table.Name);

            // KEY
            XmlNode     keyNode = subnode.SelectSingleNode(HbmConstants.nsKey, namespaceManager);
            SimpleValue key     = new DependantValue(mytable, subclass.Identifier);

            subclass.Key = key;
            if (keyNode.Attributes["on-delete"] != null)
            {
                key.IsCascadeDeleteEnabled = "cascade".Equals(keyNode.Attributes["on-delete"].Value);
            }
            BindSimpleValue(keyNode, key, false, subclass.EntityName);

            subclass.CreatePrimaryKey(dialect);

            if (!subclass.IsJoinedSubclass)
            {
                throw new MappingException(
                          "Cannot map joined-subclass " + subclass.EntityName + " to table " +
                          subclass.Table.Name + ", the same table as its base class.");
            }

            subclass.CreateForeignKey();

            // CHECK
            XmlAttribute chNode = subnode.Attributes["check"];

            if (chNode != null)
            {
                mytable.AddCheckConstraint(chNode.Value);
            }

            // properties
            PropertiesFromXML(subnode, subclass, inheritedMetas);

            model.AddSubclass(subclass);
            mappings.AddClass(subclass);
        }