protected void applyCacheSettings(Configuration configuration) {
if (getCacheConcurrencyStrategy() != null) {
Iterator itr = configuration.getClassMappings();
while (itr.hasNext()) {
PersistentClass clazz = (PersistentClass) itr.next();
Iterator props = clazz.getPropertyClosureIterator();
boolean hasLob = false;
while (props.hasNext()) {
Property prop = (Property) props.next();
if (prop.getValue().isSimpleValue()) {
String type = ((SimpleValue) prop.getValue()).getTypeName();
if ("blob".equals(type) || "clob".equals(type)) {
hasLob = true;
}
if (Blob.class.getName().equals(type) || Clob.class.getName().equals(type)) {
hasLob = true;
}
}
}
if (!hasLob && !clazz.isInherited() && overrideCacheStrategy()) {
configuration.setCacheConcurrencyStrategy(
clazz.getEntityName(), getCacheConcurrencyStrategy());
}
}
itr = configuration.getCollectionMappings();
while (itr.hasNext()) {
Collection coll = (Collection) itr.next();
configuration.setCollectionCacheConcurrencyStrategy(
coll.getRole(), getCacheConcurrencyStrategy());
}
}
}
private void buildSessionFactory(String[] files) throws Exception {
if (getSessions() != null) getSessions().close();
try {
setCfg(new Configuration());
cfg.addProperties(getExtraProperties());
if (recreateSchema()) {
cfg.setProperty(Environment.HBM2DDL_AUTO, "create-drop");
}
for (int i = 0; i < files.length; i++) {
if (!files[i].startsWith("net/")) files[i] = getBaseForMappings() + files[i];
getCfg().addResource(files[i], TestCase.class.getClassLoader());
}
setDialect(Dialect.getDialect());
configure(cfg);
if (getCacheConcurrencyStrategy() != null) {
Iterator iter = cfg.getClassMappings();
while (iter.hasNext()) {
PersistentClass clazz = (PersistentClass) iter.next();
Iterator props = clazz.getPropertyClosureIterator();
boolean hasLob = false;
while (props.hasNext()) {
Property prop = (Property) props.next();
if (prop.getValue().isSimpleValue()) {
String type = ((SimpleValue) prop.getValue()).getTypeName();
if ("blob".equals(type) || "clob".equals(type)) hasLob = true;
if (Blob.class.getName().equals(type) || Clob.class.getName().equals(type))
hasLob = true;
}
}
if (!hasLob && !clazz.isInherited() && overrideCacheStrategy()) {
cfg.setCacheConcurrencyStrategy(clazz.getEntityName(), getCacheConcurrencyStrategy());
}
}
iter = cfg.getCollectionMappings();
while (iter.hasNext()) {
Collection coll = (Collection) iter.next();
cfg.setCollectionCacheConcurrencyStrategy(coll.getRole(), getCacheConcurrencyStrategy());
}
}
setSessions(getCfg().buildSessionFactory(/*new TestInterceptor()*/ ));
afterSessionFactoryBuilt();
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
public void doSecondPass(java.util.Map persistentClasses, java.util.Map inheritedMetas)
throws MappingException {
if (log.isDebugEnabled()) log.debug("Second pass for collection: " + collection.getRole());
secondPass(persistentClasses, inheritedMetas);
collection.createAllKeys();
if (log.isDebugEnabled()) {
String msg = "Mapped collection key: " + columns(collection.getKey());
if (collection.isIndexed())
msg += ", index: " + columns(((IndexedCollection) collection).getIndex());
if (collection.isOneToMany()) {
msg += ", one-to-many: " + ((OneToMany) collection.getElement()).getReferencedEntityName();
} else {
msg += ", element: " + columns(collection.getElement());
}
log.debug(msg);
}
}
public void doSecondPass(java.util.Map persistentClasses) throws MappingException {
if (log.isDebugEnabled()) log.debug("Second pass for collection: " + collection.getRole());
secondPass(
persistentClasses,
localInheritedMetas); // using local since the inheritedMetas at this point is not the
// correct map since it is always the empty map
collection.createAllKeys();
if (log.isDebugEnabled()) {
String msg = "Mapped collection key: " + columns(collection.getKey());
if (collection.isIndexed())
msg += ", index: " + columns(((IndexedCollection) collection).getIndex());
if (collection.isOneToMany()) {
msg += ", one-to-many: " + ((OneToMany) collection.getElement()).getReferencedEntityName();
} else {
msg += ", element: " + columns(collection.getElement());
}
log.debug(msg);
}
}
public static void bindCollectionSecondPass(
Collection collection,
java.util.Map persistentClasses,
Mappings mappings,
java.util.Map inheritedMetas)
throws MappingException {
if (collection.isOneToMany()) {
OneToMany oneToMany = (OneToMany) collection.getElement();
PersistentClass persistentClass = mappings.getClass(oneToMany.getReferencedEntityName());
if (persistentClass == null)
throw new MappingException(
"Association "
+ collection.getRole()
+ " references unmapped class: "
+ oneToMany.getReferencedEntityName());
oneToMany.setAssociatedClass(persistentClass); // Child
}
}
private void bindIndex(final ExtendedMappings mappings) {
if (indexColumn.isImplicit() == false) {
PropertyHolder valueHolder =
PropertyHolderBuilder.buildPropertyHolder(
this.collection,
IndexedCollection.DEFAULT_INDEX_COLUMN_NAME,
(XClass) null,
(XProperty) null);
List list = (List) this.collection;
if (!list.isOneToMany()) indexColumn.forceNotNull();
indexColumn.setPropertyHolder(valueHolder);
SimpleValueBinder value = new SimpleValueBinder();
value.setColumns(new Ejb3Column[] {indexColumn});
value.setExplicitType("integer");
value.setMappings(mappings);
SimpleValue indexValue = value.make();
indexColumn.linkWithValue(indexValue);
list.setIndex(indexValue);
list.setBaseIndex(indexColumn.getBase());
if (list.isOneToMany() && !list.getKey().isNullable() && !list.isInverse()) {
String entityName = ((OneToMany) list.getElement()).getReferencedEntityName();
PersistentClass referenced = mappings.getClass(entityName);
IndexBackref ib = new IndexBackref();
ib.setName('_' + propertyName + "IndexBackref");
ib.setUpdateable(false);
ib.setSelectable(false);
ib.setCollectionRole(list.getRole());
ib.setEntityName(list.getOwner().getEntityName());
ib.setValue(list.getIndex());
referenced.addProperty(ib);
}
} else {
Collection coll = this.collection;
throw new AnnotationException(
"List/array has to be annotated with an @IndexColumn: " + coll.getRole());
}
}
public SessionFactoryImpl(
Configuration cfg,
Mapping mapping,
Settings settings,
EventListeners listeners,
SessionFactoryObserver observer)
throws HibernateException {
log.info("building session factory");
Statistics concurrentStatistics = null;
try {
Class concurrentStatsClass =
ReflectHelper.classForName("org.hibernate.stat.ConcurrentStatisticsImpl");
Constructor constructor =
concurrentStatsClass.getConstructor(new Class[] {SessionFactoryImplementor.class});
concurrentStatistics = (Statistics) constructor.newInstance(new Object[] {this});
log.trace("JDK 1.5 concurrent classes present");
} catch (NoClassDefFoundError noJava5) {
log.trace("JDK 1.5 concurrent classes missing");
} catch (Exception noJava5) {
log.trace("JDK 1.5 concurrent classes missing");
}
if (concurrentStatistics != null) {
this.statistics = concurrentStatistics;
} else {
this.statistics = new StatisticsImpl(this);
}
if (log.isTraceEnabled()) {
log.trace("Statistics initialized with " + statistics.getClass().getName());
}
this.properties = new Properties();
this.properties.putAll(cfg.getProperties());
this.interceptor = cfg.getInterceptor();
this.settings = settings;
this.sqlFunctionRegistry =
new SQLFunctionRegistry(settings.getDialect(), cfg.getSqlFunctions());
this.eventListeners = listeners;
this.observer =
observer != null
? observer
: new SessionFactoryObserver() {
public void sessionFactoryCreated(SessionFactory factory) {}
public void sessionFactoryClosed(SessionFactory factory) {}
};
this.filters = new HashMap();
this.filters.putAll(cfg.getFilterDefinitions());
if (log.isDebugEnabled()) {
log.debug("Session factory constructed with filter configurations : " + filters);
}
if (log.isDebugEnabled()) {
log.debug("instantiating session factory with properties: " + properties);
}
// Caches
settings.getRegionFactory().start(settings, properties);
// Generators:
identifierGenerators = new HashMap();
Iterator classes = cfg.getClassMappings();
while (classes.hasNext()) {
PersistentClass model = (PersistentClass) classes.next();
if (!model.isInherited()) {
IdentifierGenerator generator =
model
.getIdentifier()
.createIdentifierGenerator(
cfg.getIdentifierGeneratorFactory(),
settings.getDialect(),
settings.getDefaultCatalogName(),
settings.getDefaultSchemaName(),
(RootClass) model);
identifierGenerators.put(model.getEntityName(), generator);
}
}
///////////////////////////////////////////////////////////////////////
// Prepare persisters and link them up with their cache
// region/access-strategy
final String cacheRegionPrefix =
settings.getCacheRegionPrefix() == null ? "" : settings.getCacheRegionPrefix() + ".";
entityPersisters = new HashMap();
Map entityAccessStrategies = new HashMap();
Map classMeta = new HashMap();
classes = cfg.getClassMappings();
while (classes.hasNext()) {
final PersistentClass model = (PersistentClass) classes.next();
model.prepareTemporaryTables(mapping, settings.getDialect());
final String cacheRegionName = cacheRegionPrefix + model.getRootClass().getCacheRegionName();
// cache region is defined by the root-class in the hierarchy...
EntityRegionAccessStrategy accessStrategy =
(EntityRegionAccessStrategy) entityAccessStrategies.get(cacheRegionName);
if (accessStrategy == null && settings.isSecondLevelCacheEnabled()) {
final AccessType accessType = AccessType.parse(model.getCacheConcurrencyStrategy());
if (accessType != null) {
log.trace("Building cache for entity data [" + model.getEntityName() + "]");
EntityRegion entityRegion =
settings
.getRegionFactory()
.buildEntityRegion(
cacheRegionName, properties, CacheDataDescriptionImpl.decode(model));
accessStrategy = entityRegion.buildAccessStrategy(accessType);
entityAccessStrategies.put(cacheRegionName, accessStrategy);
allCacheRegions.put(cacheRegionName, entityRegion);
}
}
EntityPersister cp =
PersisterFactory.createClassPersister(model, accessStrategy, this, mapping);
entityPersisters.put(model.getEntityName(), cp);
classMeta.put(model.getEntityName(), cp.getClassMetadata());
}
classMetadata = Collections.unmodifiableMap(classMeta);
Map tmpEntityToCollectionRoleMap = new HashMap();
collectionPersisters = new HashMap();
Iterator collections = cfg.getCollectionMappings();
while (collections.hasNext()) {
Collection model = (Collection) collections.next();
final String cacheRegionName = cacheRegionPrefix + model.getCacheRegionName();
final AccessType accessType = AccessType.parse(model.getCacheConcurrencyStrategy());
CollectionRegionAccessStrategy accessStrategy = null;
if (accessType != null && settings.isSecondLevelCacheEnabled()) {
log.trace("Building cache for collection data [" + model.getRole() + "]");
CollectionRegion collectionRegion =
settings
.getRegionFactory()
.buildCollectionRegion(
cacheRegionName, properties, CacheDataDescriptionImpl.decode(model));
accessStrategy = collectionRegion.buildAccessStrategy(accessType);
entityAccessStrategies.put(cacheRegionName, accessStrategy);
allCacheRegions.put(cacheRegionName, collectionRegion);
}
CollectionPersister persister =
PersisterFactory.createCollectionPersister(cfg, model, accessStrategy, this);
collectionPersisters.put(model.getRole(), persister.getCollectionMetadata());
Type indexType = persister.getIndexType();
if (indexType != null && indexType.isAssociationType() && !indexType.isAnyType()) {
String entityName = ((AssociationType) indexType).getAssociatedEntityName(this);
Set roles = (Set) tmpEntityToCollectionRoleMap.get(entityName);
if (roles == null) {
roles = new HashSet();
tmpEntityToCollectionRoleMap.put(entityName, roles);
}
roles.add(persister.getRole());
}
Type elementType = persister.getElementType();
if (elementType.isAssociationType() && !elementType.isAnyType()) {
String entityName = ((AssociationType) elementType).getAssociatedEntityName(this);
Set roles = (Set) tmpEntityToCollectionRoleMap.get(entityName);
if (roles == null) {
roles = new HashSet();
tmpEntityToCollectionRoleMap.put(entityName, roles);
}
roles.add(persister.getRole());
}
}
collectionMetadata = Collections.unmodifiableMap(collectionPersisters);
Iterator itr = tmpEntityToCollectionRoleMap.entrySet().iterator();
while (itr.hasNext()) {
final Map.Entry entry = (Map.Entry) itr.next();
entry.setValue(Collections.unmodifiableSet((Set) entry.getValue()));
}
collectionRolesByEntityParticipant = Collections.unmodifiableMap(tmpEntityToCollectionRoleMap);
// Named Queries:
namedQueries = new HashMap(cfg.getNamedQueries());
namedSqlQueries = new HashMap(cfg.getNamedSQLQueries());
sqlResultSetMappings = new HashMap(cfg.getSqlResultSetMappings());
imports = new HashMap(cfg.getImports());
// after *all* persisters and named queries are registered
Iterator iter = entityPersisters.values().iterator();
while (iter.hasNext()) {
final EntityPersister persister = ((EntityPersister) iter.next());
persister.postInstantiate();
registerEntityNameResolvers(persister);
}
iter = collectionPersisters.values().iterator();
while (iter.hasNext()) {
final CollectionPersister persister = ((CollectionPersister) iter.next());
persister.postInstantiate();
}
// JNDI + Serialization:
name = settings.getSessionFactoryName();
try {
uuid = (String) UUID_GENERATOR.generate(null, null);
} catch (Exception e) {
throw new AssertionFailure("Could not generate UUID");
}
SessionFactoryObjectFactory.addInstance(uuid, name, this, properties);
log.debug("instantiated session factory");
if (settings.isAutoCreateSchema()) {
new SchemaExport(cfg, settings).create(false, true);
}
if (settings.isAutoUpdateSchema()) {
new SchemaUpdate(cfg, settings).execute(false, true);
}
if (settings.isAutoValidateSchema()) {
new SchemaValidator(cfg, settings).validate();
}
if (settings.isAutoDropSchema()) {
schemaExport = new SchemaExport(cfg, settings);
}
if (settings.getTransactionManagerLookup() != null) {
log.debug("obtaining JTA TransactionManager");
transactionManager = settings.getTransactionManagerLookup().getTransactionManager(properties);
} else {
if (settings.getTransactionFactory().isTransactionManagerRequired()) {
throw new HibernateException(
"The chosen transaction strategy requires access to the JTA TransactionManager");
}
transactionManager = null;
}
currentSessionContext = buildCurrentSessionContext();
if (settings.isQueryCacheEnabled()) {
updateTimestampsCache = new UpdateTimestampsCache(settings, properties);
queryCache =
settings
.getQueryCacheFactory()
.getQueryCache(null, updateTimestampsCache, settings, properties);
queryCaches = new HashMap();
allCacheRegions.put(
updateTimestampsCache.getRegion().getName(), updateTimestampsCache.getRegion());
allCacheRegions.put(queryCache.getRegion().getName(), queryCache.getRegion());
} else {
updateTimestampsCache = null;
queryCache = null;
queryCaches = null;
}
// checking for named queries
if (settings.isNamedQueryStartupCheckingEnabled()) {
Map errors = checkNamedQueries();
if (!errors.isEmpty()) {
Set keys = errors.keySet();
StringBuffer failingQueries = new StringBuffer("Errors in named queries: ");
for (Iterator iterator = keys.iterator(); iterator.hasNext(); ) {
String queryName = (String) iterator.next();
HibernateException e = (HibernateException) errors.get(queryName);
failingQueries.append(queryName);
if (iterator.hasNext()) {
failingQueries.append(", ");
}
log.error("Error in named query: " + queryName, e);
}
throw new HibernateException(failingQueries.toString());
}
}
// stats
getStatistics().setStatisticsEnabled(settings.isStatisticsEnabled());
// EntityNotFoundDelegate
EntityNotFoundDelegate entityNotFoundDelegate = cfg.getEntityNotFoundDelegate();
if (entityNotFoundDelegate == null) {
entityNotFoundDelegate =
new EntityNotFoundDelegate() {
public void handleEntityNotFound(String entityName, Serializable id) {
throw new ObjectNotFoundException(id, entityName);
}
public boolean isEntityNotFoundException(RuntimeException exception) {
return ObjectNotFoundException.class.isInstance(exception);
}
};
}
this.entityNotFoundDelegate = entityNotFoundDelegate;
// this needs to happen after persisters are all ready to go...
this.fetchProfiles = new HashMap();
itr = cfg.iterateFetchProfiles();
while (itr.hasNext()) {
final org.hibernate.mapping.FetchProfile mappingProfile =
(org.hibernate.mapping.FetchProfile) itr.next();
final FetchProfile fetchProfile = new FetchProfile(mappingProfile.getName());
Iterator fetches = mappingProfile.getFetches().iterator();
while (fetches.hasNext()) {
final org.hibernate.mapping.FetchProfile.Fetch mappingFetch =
(org.hibernate.mapping.FetchProfile.Fetch) fetches.next();
// resolve the persister owning the fetch
final String entityName = getImportedClassName(mappingFetch.getEntity());
final EntityPersister owner =
(EntityPersister) (entityName == null ? null : entityPersisters.get(entityName));
if (owner == null) {
throw new HibernateException(
"Unable to resolve entity reference ["
+ mappingFetch.getEntity()
+ "] in fetch profile ["
+ fetchProfile.getName()
+ "]");
}
// validate the specified association fetch
Type associationType = owner.getPropertyType(mappingFetch.getAssociation());
if (associationType == null || !associationType.isAssociationType()) {
throw new HibernateException(
"Fetch profile [" + fetchProfile.getName() + "] specified an invalid association");
}
// resolve the style
final Fetch.Style fetchStyle = Fetch.Style.parse(mappingFetch.getStyle());
// then construct the fetch instance...
fetchProfile.addFetch(new Association(owner, mappingFetch.getAssociation()), fetchStyle);
((Loadable) owner).registerAffectingFetchProfile(fetchProfile.getName());
}
fetchProfiles.put(fetchProfile.getName(), fetchProfile);
}
this.observer.sessionFactoryCreated(this);
}
/**
* @param rc
* @param processed
* @param table
* @param object
*/
private Property bindOneToMany(
PersistentClass rc, ForeignKey foreignKey, Set processed, Mapping mapping) {
Table collectionTable = foreignKey.getTable();
// Collection collection = new org.hibernate.mapping.Set(rc); // MASTER TODO: allow overriding
// collection type
Collection collection =
new org.hibernate.mapping.List(rc); // MASTER TODO: allow overriding collection type
collection.setCollectionTable(collectionTable); // CHILD+
boolean manyToMany = revengStrategy.isManyToManyTable(collectionTable);
if (manyToMany) {
// log.debug("Rev.eng said here is a many-to-many");
// TODO: handle "the other side should influence the name"
}
if (manyToMany) {
ManyToOne element = new ManyToOne(collection.getCollectionTable());
// TODO: find the other foreignkey and choose the other side.
Iterator foreignKeyIterator = foreignKey.getTable().getForeignKeyIterator();
List keys = new ArrayList();
while (foreignKeyIterator.hasNext()) {
Object next = foreignKeyIterator.next();
if (next != foreignKey) {
keys.add(next);
}
}
if (keys.size() > 1) {
throw new JDBCBinderException(
"more than one other foreign key to choose from!"); // todo: handle better ?
}
ForeignKey fk = (ForeignKey) keys.get(0);
String tableToClassName = bindCollection(rc, foreignKey, fk, collection);
element.setReferencedEntityName(tableToClassName);
element.addColumn(fk.getColumn(0));
collection.setElement(element);
} else {
String tableToClassName = bindCollection(rc, foreignKey, null, collection);
OneToMany oneToMany = new OneToMany(collection.getOwner());
oneToMany.setReferencedEntityName(tableToClassName); // Child
mappings.addSecondPass(new JDBCCollectionSecondPass(mappings, collection));
collection.setElement(oneToMany);
}
// bind keyvalue
KeyValue referencedKeyValue;
String propRef = collection.getReferencedPropertyName();
if (propRef == null) {
referencedKeyValue = collection.getOwner().getIdentifier();
} else {
referencedKeyValue = (KeyValue) collection.getOwner().getProperty(propRef).getValue();
}
SimpleValue keyValue = new DependantValue(collectionTable, referencedKeyValue);
// keyValue.setForeignKeyName("none"); // Avoid creating the foreignkey
// key.setCascadeDeleteEnabled( "cascade".equals( subnode.attributeValue("on-delete") ) );
Iterator columnIterator = foreignKey.getColumnIterator();
while (columnIterator.hasNext()) {
Column fkcolumn = (Column) columnIterator.next();
if (fkcolumn.getSqlTypeCode()
!= null) { // TODO: user defined foreign ref columns does not have a type set.
guessAndAlignType(
collectionTable,
fkcolumn,
mapping,
false); // needed to ensure foreign key columns has same type as the "property" column.
}
keyValue.addColumn(fkcolumn);
}
collection.setKey(keyValue);
mappings.addCollection(collection);
return makeCollectionProperty(
StringHelper.unqualify(collection.getRole()),
true,
rc.getTable(),
foreignKey,
collection,
true);
// return makeProperty(TableIdentifier.create( rc.getTable() ), StringHelper.unqualify(
// collection.getRole() ), collection, true, true, true, "none", null); // TODO: cascade isn't
// all by default
}
