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));
}
}
public void bindFetchProfiles(
List<XMLFetchProfileElement> fetchProfiles, String containingEntityName) {
for (XMLFetchProfileElement fetchProfile : fetchProfiles) {
String profileName = fetchProfile.getName();
Set<FetchProfile.Fetch> fetches = new HashSet<FetchProfile.Fetch>();
for (XMLFetchProfileElement.XMLFetch fetch : fetchProfile.getFetch()) {
String entityName = fetch.getEntity() == null ? containingEntityName : fetch.getEntity();
if (entityName == null) {
throw new MappingException(
"could not determine entity for fetch-profile fetch ["
+ profileName
+ "]:["
+ fetch.getAssociation()
+ "]",
jaxbRoot.getOrigin());
}
fetches.add(new FetchProfile.Fetch(entityName, fetch.getAssociation(), fetch.getStyle()));
}
metadata.addFetchProfile(new FetchProfile(profileName, fetches));
}
}
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 static void bind(
String name, String typeClass, Map<String, String> prms, MetadataImplementor metadata) {
LOG.debugf("Binding type definition: %s", name);
metadata.addTypeDefinition(new TypeDef(name, typeClass, prms));
}
private ClassLoaderService classLoaderService() {
if (classLoaderService == null) {
classLoaderService = metadata.getServiceRegistry().getService(ClassLoaderService.class);
}
return classLoaderService;
}
@Override
public JavaType makeJavaType(String className) {
return metadata.makeJavaType(className);
}
@Override
public <T> Class<T> locateClassByName(String name) {
return metadata.locateClassByName(name);
}
@Override
public boolean isGloballyQuotedIdentifiers() {
return metadata.isGloballyQuotedIdentifiers();
}
@Override
public NamingStrategy getNamingStrategy() {
return metadata.getOptions().getNamingStrategy();
}
@Override
public ServiceRegistry getServiceRegistry() {
return metadata.getServiceRegistry();
}
private MetaAttributeContext extractMetaAttributes() {
return hibernateMapping.getMeta() == null
? new MetaAttributeContext(metadata.getMetaAttributeContext())
: HbmHelper.extractMetaAttributeContext(
hibernateMapping.getMeta(), true, metadata.getMetaAttributeContext());
}