public void bindMappingMetadata(List<String> processedEntityNames) {
if (hibernateMapping.getClazzOrSubclassOrJoinedSubclass() == null) {
return;
}
for (Object clazzOrSubclass : hibernateMapping.getClazzOrSubclassOrJoinedSubclass()) {
if (XMLHibernateMapping.XMLClass.class.isInstance(clazzOrSubclass)) {
XMLHibernateMapping.XMLClass clazz =
XMLHibernateMapping.XMLClass.class.cast(clazzOrSubclass);
new RootEntityBinder(this, clazz).process(clazz);
} else if (XMLSubclassElement.class.isInstance(clazzOrSubclass)) {
// PersistentClass superModel = getSuperclass( mappings, element );
// handleSubclass( superModel, mappings, element, inheritedMetas );
} else if (XMLJoinedSubclassElement.class.isInstance(clazzOrSubclass)) {
// PersistentClass superModel = getSuperclass( mappings, element );
// handleJoinedSubclass( superModel, mappings, element, inheritedMetas );
} else if (XMLUnionSubclassElement.class.isInstance(clazzOrSubclass)) {
// PersistentClass superModel = getSuperclass( mappings, element );
// handleUnionSubclass( superModel, mappings, element, inheritedMetas );
} else {
throw new org.hibernate.metamodel.source.MappingException(
"unknown type of class or subclass: " + clazzOrSubclass.getClass().getName(),
jaxbRoot.getOrigin());
}
}
}
private void bindFilterDefinitions() {
if (hibernateMapping.getFilterDef() == null) {
return;
}
for (XMLHibernateMapping.XMLFilterDef filterDefinition : hibernateMapping.getFilterDef()) {
final String name = filterDefinition.getName();
final Map<String, Type> parameters = new HashMap<String, Type>();
String condition = null;
for (Object o : filterDefinition.getContent()) {
if (o instanceof String) {
// represents the condition
if (condition != null) {
// log?
}
condition = (String) o;
} else if (o instanceof XMLHibernateMapping.XMLFilterDef.XMLFilterParam) {
final XMLHibernateMapping.XMLFilterDef.XMLFilterParam paramElement =
(XMLHibernateMapping.XMLFilterDef.XMLFilterParam) o;
// todo : should really delay this resolution until later to allow typedef names
parameters.put(
paramElement.getName(),
metadata.getTypeResolver().heuristicType(paramElement.getType()));
} else {
throw new MappingException("Unrecognized nested filter content", jaxbRoot.getOrigin());
}
}
if (condition == null) {
condition = filterDefinition.getCondition();
}
metadata.addFilterDefinition(new FilterDefinition(name, condition, parameters));
}
}
private void bindDatabaseObjectDefinitions() {
if (hibernateMapping.getDatabaseObject() == null) {
return;
}
for (XMLHibernateMapping.XMLDatabaseObject databaseObjectElement :
hibernateMapping.getDatabaseObject()) {
final AuxiliaryDatabaseObject auxiliaryDatabaseObject;
if (databaseObjectElement.getDefinition() != null) {
final String className = databaseObjectElement.getDefinition().getClazz();
try {
auxiliaryDatabaseObject =
(AuxiliaryDatabaseObject) classLoaderService().classForName(className).newInstance();
} catch (ClassLoadingException e) {
throw e;
} catch (Exception e) {
throw new MappingException(
"could not instantiate custom database object class [" + className + "]",
jaxbRoot.getOrigin());
}
} else {
Set<String> dialectScopes = new HashSet<String>();
if (databaseObjectElement.getDialectScope() != null) {
for (XMLHibernateMapping.XMLDatabaseObject.XMLDialectScope dialectScope :
databaseObjectElement.getDialectScope()) {
dialectScopes.add(dialectScope.getName());
}
}
auxiliaryDatabaseObject =
new BasicAuxiliaryDatabaseObjectImpl(
databaseObjectElement.getCreate(), databaseObjectElement.getDrop(), dialectScopes);
}
metadata.addAuxiliaryDatabaseObject(auxiliaryDatabaseObject);
}
}
private void bindIdentifierGenerators() {
if (hibernateMapping.getIdentifierGenerator() == null) {
return;
}
for (XMLHibernateMapping.XMLIdentifierGenerator identifierGeneratorElement :
hibernateMapping.getIdentifierGenerator()) {
metadata.registerIdentifierGenerator(
identifierGeneratorElement.getName(), identifierGeneratorElement.getClazz());
}
}
private void bindImports() {
if (hibernateMapping.getImport() == null) {
return;
}
for (XMLHibernateMapping.XMLImport importValue : hibernateMapping.getImport()) {
String className = getClassName(importValue.getClazz());
String rename = importValue.getRename();
rename = (rename == null) ? StringHelper.unqualify(className) : rename;
metadata.addImport(className, rename);
}
}
private void bindTypeDefinitions() {
if (hibernateMapping.getTypedef() == null) {
return;
}
for (XMLHibernateMapping.XMLTypedef typedef : hibernateMapping.getTypedef()) {
final Map<String, String> parameters = new HashMap<String, String>();
for (XMLParamElement paramElement : typedef.getParam()) {
parameters.put(paramElement.getName(), paramElement.getValue());
}
metadata.addTypeDefinition(new TypeDef(typedef.getName(), typedef.getClazz(), parameters));
}
}
private void bindNamedQueries() {
if (hibernateMapping.getQueryOrSqlQuery() == null) {
return;
}
for (Object queryOrSqlQuery : hibernateMapping.getQueryOrSqlQuery()) {
if (XMLQueryElement.class.isInstance(queryOrSqlQuery)) {
// bindNamedQuery( element, null, mappings );
} else if (XMLSqlQueryElement.class.isInstance(queryOrSqlQuery)) {
// bindNamedSQLQuery( element, null, mappings );
} else {
throw new MappingException(
"unknown type of query: " + queryOrSqlQuery.getClass().getName(), jaxbRoot.getOrigin());
}
}
}
public HibernateMappingProcessor(
MetadataImplementor metadata, JaxbRoot<XMLHibernateMapping> jaxbRoot) {
this.metadata = metadata;
this.jaxbRoot = jaxbRoot;
this.hibernateMapping = jaxbRoot.getRoot();
this.mappingDefaults =
new OverriddenMappingDefaults(
metadata.getMappingDefaults(),
hibernateMapping.getPackage(),
hibernateMapping.getSchema(),
hibernateMapping.getCatalog(),
null,
null,
hibernateMapping.getDefaultCascade(),
hibernateMapping.getDefaultAccess(),
hibernateMapping.isDefaultLazy());
autoImport = hibernateMapping.isAutoImport();
metaAttributeContext = extractMetaAttributes();
}
private void bindResultSetMappings() {
if (hibernateMapping.getResultset() == null) {
return;
}
// bindResultSetMappingDefinitions( element, null, mappings );
}
private void bindFetchProfiles() {
if (hibernateMapping.getFetchProfile() == null) {
return;
}
bindFetchProfiles(hibernateMapping.getFetchProfile(), null);
}
private MetaAttributeContext extractMetaAttributes() {
return hibernateMapping.getMeta() == null
? new MetaAttributeContext(metadata.getMetaAttributeContext())
: HbmHelper.extractMetaAttributeContext(
hibernateMapping.getMeta(), true, metadata.getMetaAttributeContext());
}
