@Configuration
public Option[] config() throws Exception {
final Properties paxExamEnvironment = loadPaxExamEnvironmentProperties();
final boolean debug =
ConfigurationHelper.getBoolean(
"org.hibernate.testing.osgi.paxExam.debug", Environment.getProperties(), DEBUG);
return options(
when(debug).useOptions(debugConfiguration("5005", true)),
karafDistributionConfiguration()
.frameworkUrl(
paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.distroUrl"))
.karafVersion(
paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.version"))
.name("Apache Karaf")
.unpackDirectory(
new File(
paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.unpackDir")))
.useDeployFolder(false),
editConfigurationFileExtend(
"etc/org.ops4j.pax.url.mvn.cfg",
"org.ops4j.pax.url.mvn.repositories",
"https://repository.jboss.org/nexus/content/groups/public/"),
configureConsole().ignoreLocalConsole().ignoreRemoteShell(),
when(debug).useOptions(keepRuntimeFolder()),
logLevel(LogLevelOption.LogLevel.INFO),
features(featureXmlUrl(paxExamEnvironment), "hibernate-orm"),
features(testingFeatureXmlUrl(), "hibernate-osgi-testing"));
}
static {
try {
Map<Object, Object> properties = getEntityManagerProperties();
Environment.verifyProperties(properties);
ConfigurationHelper.resolvePlaceHolders(properties);
ServiceRegistry reg =
new ServiceRegistryBuilder().applySettings(properties).buildServiceRegistry();
DbOpenHelper openHelper =
new DbOpenHelper(reg) {
@Override
public void onCreate() throws Exception {
executeAllScript(0);
}
@Override
public void onUpgrade(int oldVersion, int newVersion) throws Exception {
// TODO Auto-generated method stub
}
};
openHelper.open();
emfInstance =
Persistence.createEntityManagerFactory(
"transactions-optional", getEntityManagerProperties());
} catch (Throwable t) {
log.error("Error creating EMF", t);
}
}
public static ServiceRegistryImpl buildServiceRegistry(Map serviceRegistryConfig) {
Properties properties = new Properties();
properties.putAll(serviceRegistryConfig);
Environment.verifyProperties(properties);
ConfigurationHelper.resolvePlaceHolders(properties);
return new ServiceRegistryImpl(properties);
}
public void setSqlOrderBy(OrderBy orderByAnn) {
if (orderByAnn != null) {
if (Environment.jvmSupportsLinkedHashCollections()) {
super.setSqlOrderBy(orderByAnn);
} else {
log.warn("Attribute \"order-by\" ignored in JDK1.3 or less");
}
}
}
private static Properties createProperties() {
final Properties properties = new Properties();
// If configured in the environment, add configuration file name to properties.
final String cfgFileName =
(String)
Environment.getProperties()
.get(InfinispanRegionFactory.INFINISPAN_CONFIG_RESOURCE_PROP);
if (cfgFileName != null) {
properties.put(InfinispanRegionFactory.INFINISPAN_CONFIG_RESOURCE_PROP, cfgFileName);
}
return properties;
}
protected StandardServiceRegistryImpl buildServiceRegistry(Configuration configuration) {
Properties properties = new Properties();
properties.putAll(configuration.getProperties());
Environment.verifyProperties(properties);
ConfigurationHelper.resolvePlaceHolders(properties);
final BootstrapServiceRegistry bootstrapServiceRegistry = generateBootstrapRegistry(properties);
ServiceRegistryBuilder registryBuilder =
new ServiceRegistryBuilder(bootstrapServiceRegistry).applySettings(properties);
prepareBasicRegistryBuilder(registryBuilder);
return (StandardServiceRegistryImpl) registryBuilder.buildServiceRegistry();
}
private SessionFactory buildSessionFactory() {
// Extra options located in src/test/resources/hibernate.properties
Properties envProps = Environment.getProperties();
envProps.setProperty(Environment.DIALECT, "HSQL");
envProps.setProperty(Environment.HBM2DDL_AUTO, "create-drop");
envProps.setProperty(
Environment.CONNECTION_PROVIDER, JtaAwareConnectionProviderImpl.class.getName());
envProps.setProperty(Environment.JNDI_CLASS, "org.jnp.interfaces.NamingContextFactory");
envProps.setProperty(Environment.TRANSACTION_STRATEGY, "jta");
envProps.setProperty(Environment.CURRENT_SESSION_CONTEXT_CLASS, "jta");
envProps.setProperty(Environment.RELEASE_CONNECTIONS, "auto");
envProps.setProperty(Environment.USE_SECOND_LEVEL_CACHE, "true");
envProps.setProperty(Environment.USE_QUERY_CACHE, "true");
envProps.put(AvailableSettings.JTA_PLATFORM, new JBossStandAloneJtaPlatform());
envProps.setProperty(
Environment.CACHE_REGION_FACTORY,
"org.hibernate.test.cache.infinispan.functional.SingleNodeTestCase$TestInfinispanRegionFactory");
serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(envProps);
MetadataSources sources = new MetadataSources(serviceRegistry);
String[] mappings =
new String[] {"org/hibernate/test/cache/infinispan/functional/Item.hbm.xml"};
for (String mapping : mappings) {
sources.addResource(mapping);
}
Metadata metadata = sources.buildMetadata();
Iterator<EntityBinding> entityIter = metadata.getEntityBindings().iterator();
while (entityIter.hasNext()) {
EntityBinding binding = entityIter.next();
binding.getHierarchyDetails().getCaching().setAccessType(AccessType.TRANSACTIONAL);
binding.getHierarchyDetails().getCaching().setRequested(TruthValue.TRUE);
binding.getHierarchyDetails().getCaching().setRegion(binding.getEntityName());
binding.getHierarchyDetails().getCaching().setCacheLazyProperties(true);
}
Iterator<PluralAttributeBinding> collectionIter = metadata.getCollectionBindings().iterator();
while (collectionIter.hasNext()) {
PluralAttributeBinding binding = collectionIter.next();
binding.getCaching().setAccessType(AccessType.TRANSACTIONAL);
binding.getCaching().setRequested(TruthValue.TRUE);
binding
.getCaching()
.setRegion(
StringHelper.qualify(
binding.getContainer().seekEntityBinding().getEntityName(),
binding.getAttribute().getName()));
binding.getCaching().setCacheLazyProperties(true);
}
return metadata.buildSessionFactory();
}
public SchemaFilterTest() {
Map settings = new HashMap();
settings.putAll(Environment.getProperties());
settings.put(AvailableSettings.DIALECT, SQLServerDialect.class.getName());
this.serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(settings);
MetadataSources ms = new MetadataSources(serviceRegistry);
ms.addAnnotatedClass(SchemaNoneEntity0.class);
ms.addAnnotatedClass(Schema1Entity1.class);
ms.addAnnotatedClass(Schema1Entity2.class);
ms.addAnnotatedClass(Schema2Entity3.class);
ms.addAnnotatedClass(Schema2Entity4.class);
this.metadata = ms.buildMetadata();
}
@Override
public boolean areEqual(Date one, Date another) {
if (one == another) {
return true;
}
if (one == null || another == null) {
return false;
}
long t1 = one.getTime();
long t2 = another.getTime();
boolean oneIsTimestamp = Timestamp.class.isInstance(one);
boolean anotherIsTimestamp = Timestamp.class.isInstance(another);
int n1 = oneIsTimestamp ? ((Timestamp) one).getNanos() : 0;
int n2 = anotherIsTimestamp ? ((Timestamp) another).getNanos() : 0;
if (!Environment.jvmHasJDK14Timestamp()) {
t1 += n1 / 1000000;
t2 += n2 / 1000000;
}
if (t1 != t2) {
return false;
}
if (oneIsTimestamp && anotherIsTimestamp) {
// both are Timestamps
int nn1 = n1 % 1000000;
int nn2 = n2 % 1000000;
return nn1 == nn2;
} else {
// at least one is a plain old Date
return true;
}
}
protected void setUp() {
serviceRegistryHolder = new ServiceRegistryHolder(Environment.getProperties());
}
public EntityMetamodel(
PersistentClass persistentClass,
AbstractEntityPersister persister,
SessionFactoryImplementor sessionFactory) {
this.sessionFactory = sessionFactory;
this.persister = persister;
name = persistentClass.getEntityName();
rootName = persistentClass.getRootClass().getEntityName();
entityType = sessionFactory.getTypeResolver().getTypeFactory().manyToOne(name);
identifierAttribute =
PropertyFactory.buildIdentifierAttribute(
persistentClass, sessionFactory.getIdentifierGenerator(rootName));
versioned = persistentClass.isVersioned();
instrumentationMetadata =
persistentClass.hasPojoRepresentation()
? Environment.getBytecodeProvider()
.getEntityInstrumentationMetadata(persistentClass.getMappedClass())
: new NonPojoInstrumentationMetadata(persistentClass.getEntityName());
boolean hasLazy = false;
propertySpan = persistentClass.getPropertyClosureSpan();
properties = new NonIdentifierAttribute[propertySpan];
List<Integer> naturalIdNumbers = new ArrayList<Integer>();
// temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
propertyNames = new String[propertySpan];
propertyTypes = new Type[propertySpan];
propertyUpdateability = new boolean[propertySpan];
propertyInsertability = new boolean[propertySpan];
nonlazyPropertyUpdateability = new boolean[propertySpan];
propertyCheckability = new boolean[propertySpan];
propertyNullability = new boolean[propertySpan];
propertyVersionability = new boolean[propertySpan];
propertyLaziness = new boolean[propertySpan];
cascadeStyles = new CascadeStyle[propertySpan];
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// generated value strategies
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
this.inMemoryValueGenerationStrategies = new InMemoryValueGenerationStrategy[propertySpan];
this.inDatabaseValueGenerationStrategies = new InDatabaseValueGenerationStrategy[propertySpan];
boolean foundPreInsertGeneratedValues = false;
boolean foundPreUpdateGeneratedValues = false;
boolean foundPostInsertGeneratedValues = false;
boolean foundPostUpdateGeneratedValues = false;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Iterator iter = persistentClass.getPropertyClosureIterator();
int i = 0;
int tempVersionProperty = NO_VERSION_INDX;
boolean foundCascade = false;
boolean foundCollection = false;
boolean foundMutable = false;
boolean foundNonIdentifierPropertyNamedId = false;
boolean foundInsertGeneratedValue = false;
boolean foundUpdateGeneratedValue = false;
boolean foundUpdateableNaturalIdProperty = false;
while (iter.hasNext()) {
Property prop = (Property) iter.next();
if (prop == persistentClass.getVersion()) {
tempVersionProperty = i;
properties[i] =
PropertyFactory.buildVersionProperty(
persister, sessionFactory, i, prop, instrumentationMetadata.isInstrumented());
} else {
properties[i] =
PropertyFactory.buildEntityBasedAttribute(
persister, sessionFactory, i, prop, instrumentationMetadata.isInstrumented());
}
if (prop.isNaturalIdentifier()) {
naturalIdNumbers.add(i);
if (prop.isUpdateable()) {
foundUpdateableNaturalIdProperty = true;
}
}
if ("id".equals(prop.getName())) {
foundNonIdentifierPropertyNamedId = true;
}
// temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
boolean lazy = prop.isLazy() && instrumentationMetadata.isInstrumented();
if (lazy) hasLazy = true;
propertyLaziness[i] = lazy;
propertyNames[i] = properties[i].getName();
propertyTypes[i] = properties[i].getType();
propertyNullability[i] = properties[i].isNullable();
propertyUpdateability[i] = properties[i].isUpdateable();
propertyInsertability[i] = properties[i].isInsertable();
propertyVersionability[i] = properties[i].isVersionable();
nonlazyPropertyUpdateability[i] = properties[i].isUpdateable() && !lazy;
propertyCheckability[i] =
propertyUpdateability[i]
|| (propertyTypes[i].isAssociationType()
&& ((AssociationType) propertyTypes[i]).isAlwaysDirtyChecked());
cascadeStyles[i] = properties[i].getCascadeStyle();
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// generated value strategies
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
GenerationStrategyPair pair = buildGenerationStrategyPair(sessionFactory, prop);
inMemoryValueGenerationStrategies[i] = pair.getInMemoryStrategy();
inDatabaseValueGenerationStrategies[i] = pair.getInDatabaseStrategy();
if (pair.getInMemoryStrategy() != null) {
final GenerationTiming timing = pair.getInMemoryStrategy().getGenerationTiming();
if (timing != GenerationTiming.NEVER) {
final ValueGenerator generator = pair.getInMemoryStrategy().getValueGenerator();
if (generator != null) {
// we have some level of generation indicated
if (timing == GenerationTiming.INSERT) {
foundPreInsertGeneratedValues = true;
} else if (timing == GenerationTiming.ALWAYS) {
foundPreInsertGeneratedValues = true;
foundPreUpdateGeneratedValues = true;
}
}
}
}
if (pair.getInDatabaseStrategy() != null) {
final GenerationTiming timing = pair.getInDatabaseStrategy().getGenerationTiming();
if (timing == GenerationTiming.INSERT) {
foundPostInsertGeneratedValues = true;
} else if (timing == GenerationTiming.ALWAYS) {
foundPostInsertGeneratedValues = true;
foundPostUpdateGeneratedValues = true;
}
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (properties[i].isLazy()) {
hasLazy = true;
}
if (properties[i].getCascadeStyle() != CascadeStyles.NONE) {
foundCascade = true;
}
if (indicatesCollection(properties[i].getType())) {
foundCollection = true;
}
if (propertyTypes[i].isMutable() && propertyCheckability[i]) {
foundMutable = true;
}
mapPropertyToIndex(prop, i);
i++;
}
if (naturalIdNumbers.size() == 0) {
naturalIdPropertyNumbers = null;
hasImmutableNaturalId = false;
hasCacheableNaturalId = false;
} else {
naturalIdPropertyNumbers = ArrayHelper.toIntArray(naturalIdNumbers);
hasImmutableNaturalId = !foundUpdateableNaturalIdProperty;
hasCacheableNaturalId = persistentClass.getNaturalIdCacheRegionName() != null;
}
this.hasPreInsertGeneratedValues = foundPreInsertGeneratedValues;
this.hasPreUpdateGeneratedValues = foundPreUpdateGeneratedValues;
this.hasInsertGeneratedValues = foundPostInsertGeneratedValues;
this.hasUpdateGeneratedValues = foundPostUpdateGeneratedValues;
hasCascades = foundCascade;
hasNonIdentifierPropertyNamedId = foundNonIdentifierPropertyNamedId;
versionPropertyIndex = tempVersionProperty;
hasLazyProperties = hasLazy;
if (hasLazyProperties) LOG.lazyPropertyFetchingAvailable(name);
lazy =
persistentClass.isLazy()
&& (
// TODO: this disables laziness even in non-pojo entity modes:
!persistentClass.hasPojoRepresentation()
|| !ReflectHelper.isFinalClass(persistentClass.getProxyInterface()));
mutable = persistentClass.isMutable();
if (persistentClass.isAbstract() == null) {
// legacy behavior (with no abstract attribute specified)
isAbstract =
persistentClass.hasPojoRepresentation()
&& ReflectHelper.isAbstractClass(persistentClass.getMappedClass());
} else {
isAbstract = persistentClass.isAbstract().booleanValue();
if (!isAbstract
&& persistentClass.hasPojoRepresentation()
&& ReflectHelper.isAbstractClass(persistentClass.getMappedClass())) {
LOG.entityMappedAsNonAbstract(name);
}
}
selectBeforeUpdate = persistentClass.hasSelectBeforeUpdate();
dynamicUpdate = persistentClass.useDynamicUpdate();
dynamicInsert = persistentClass.useDynamicInsert();
polymorphic = persistentClass.isPolymorphic();
explicitPolymorphism = persistentClass.isExplicitPolymorphism();
inherited = persistentClass.isInherited();
superclass = inherited ? persistentClass.getSuperclass().getEntityName() : null;
hasSubclasses = persistentClass.hasSubclasses();
optimisticLockStyle = persistentClass.getOptimisticLockStyle();
final boolean isAllOrDirty =
optimisticLockStyle == OptimisticLockStyle.ALL
|| optimisticLockStyle == OptimisticLockStyle.DIRTY;
if (isAllOrDirty && !dynamicUpdate) {
throw new MappingException(
"optimistic-lock=all|dirty requires dynamic-update=\"true\": " + name);
}
if (versionPropertyIndex != NO_VERSION_INDX && isAllOrDirty) {
throw new MappingException(
"version and optimistic-lock=all|dirty are not a valid combination : " + name);
}
hasCollections = foundCollection;
hasMutableProperties = foundMutable;
iter = persistentClass.getSubclassIterator();
while (iter.hasNext()) {
subclassEntityNames.add(((PersistentClass) iter.next()).getEntityName());
}
subclassEntityNames.add(name);
if (persistentClass.hasPojoRepresentation()) {
entityNameByInheritenceClassMap.put(
persistentClass.getMappedClass(), persistentClass.getEntityName());
iter = persistentClass.getSubclassIterator();
while (iter.hasNext()) {
final PersistentClass pc = (PersistentClass) iter.next();
entityNameByInheritenceClassMap.put(pc.getMappedClass(), pc.getEntityName());
}
}
entityMode = persistentClass.hasPojoRepresentation() ? EntityMode.POJO : EntityMode.MAP;
final EntityTuplizerFactory entityTuplizerFactory =
sessionFactory.getSettings().getEntityTuplizerFactory();
final String tuplizerClassName = persistentClass.getTuplizerImplClassName(entityMode);
if (tuplizerClassName == null) {
entityTuplizer =
entityTuplizerFactory.constructDefaultTuplizer(entityMode, this, persistentClass);
} else {
entityTuplizer =
entityTuplizerFactory.constructTuplizer(tuplizerClassName, this, persistentClass);
}
}
/**
* Discription:[已过时]
*
* @return
* @author:[代超]
* @update:[日期YYYY-MM-DD] [更改人姓名][变更描述]
*/
public static Properties getHibernateProperties() {
return Environment.getProperties();
}
public String getDialect() {
return Environment.getProperties().getProperty(Environment.DIALECT);
}
@Before
public void setUp() {
serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(Environment.getProperties());
}
private static StandardServiceRegistryImpl createServiceRegistry(Properties properties) {
Environment.verifyProperties(properties);
ConfigurationHelper.resolvePlaceHolders(properties);
return (StandardServiceRegistryImpl)
new ServiceRegistryBuilder().applySettings(properties).buildServiceRegistry();
}
public EntityMetamodel(EntityBinding entityBinding, SessionFactoryImplementor sessionFactory) {
this.sessionFactory = sessionFactory;
name = entityBinding.getEntity().getName();
rootName = entityBinding.getHierarchyDetails().getRootEntityBinding().getEntity().getName();
entityType = sessionFactory.getTypeResolver().getTypeFactory().manyToOne(name);
identifierProperty =
PropertyFactory.buildIdentifierProperty(
entityBinding, sessionFactory.getIdentifierGenerator(rootName));
versioned = entityBinding.isVersioned();
boolean hasPojoRepresentation = false;
Class<?> mappedClass = null;
Class<?> proxyInterfaceClass = null;
if (entityBinding.getEntity().getClassReferenceUnresolved() != null) {
hasPojoRepresentation = true;
mappedClass = entityBinding.getEntity().getClassReference();
proxyInterfaceClass = entityBinding.getProxyInterfaceType().getValue();
}
instrumentationMetadata =
Environment.getBytecodeProvider().getEntityInstrumentationMetadata(mappedClass);
boolean hasLazy = false;
// TODO: Fix after HHH-6337 is fixed; for now assume entityBinding is the root binding
BasicAttributeBinding rootEntityIdentifier =
entityBinding.getHierarchyDetails().getEntityIdentifier().getValueBinding();
// entityBinding.getAttributeClosureSpan() includes the identifier binding;
// "properties" here excludes the ID, so subtract 1 if the identifier binding is non-null
propertySpan =
rootEntityIdentifier == null
? entityBinding.getAttributeBindingClosureSpan()
: entityBinding.getAttributeBindingClosureSpan() - 1;
properties = new StandardProperty[propertySpan];
List naturalIdNumbers = new ArrayList();
// temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
propertyNames = new String[propertySpan];
propertyTypes = new Type[propertySpan];
propertyUpdateability = new boolean[propertySpan];
propertyInsertability = new boolean[propertySpan];
insertInclusions = new ValueInclusion[propertySpan];
updateInclusions = new ValueInclusion[propertySpan];
nonlazyPropertyUpdateability = new boolean[propertySpan];
propertyCheckability = new boolean[propertySpan];
propertyNullability = new boolean[propertySpan];
propertyVersionability = new boolean[propertySpan];
propertyLaziness = new boolean[propertySpan];
cascadeStyles = new CascadeStyle[propertySpan];
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
int i = 0;
int tempVersionProperty = NO_VERSION_INDX;
boolean foundCascade = false;
boolean foundCollection = false;
boolean foundMutable = false;
boolean foundNonIdentifierPropertyNamedId = false;
boolean foundInsertGeneratedValue = false;
boolean foundUpdateGeneratedValue = false;
boolean foundUpdateableNaturalIdProperty = false;
for (AttributeBinding attributeBinding : entityBinding.getAttributeBindingClosure()) {
if (attributeBinding == rootEntityIdentifier) {
// skip the identifier attribute binding
continue;
}
if (attributeBinding == entityBinding.getHierarchyDetails().getVersioningAttributeBinding()) {
tempVersionProperty = i;
properties[i] =
PropertyFactory.buildVersionProperty(
entityBinding.getHierarchyDetails().getVersioningAttributeBinding(),
instrumentationMetadata.isInstrumented());
} else {
properties[i] =
PropertyFactory.buildStandardProperty(
attributeBinding, instrumentationMetadata.isInstrumented());
}
// TODO: fix when natural IDs are added (HHH-6354)
// if ( attributeBinding.isNaturalIdentifier() ) {
// naturalIdNumbers.add( i );
// if ( attributeBinding.isUpdateable() ) {
// foundUpdateableNaturalIdProperty = true;
// }
// }
if ("id".equals(attributeBinding.getAttribute().getName())) {
foundNonIdentifierPropertyNamedId = true;
}
// temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
boolean lazy = attributeBinding.isLazy() && instrumentationMetadata.isInstrumented();
if (lazy) hasLazy = true;
propertyLaziness[i] = lazy;
propertyNames[i] = properties[i].getName();
propertyTypes[i] = properties[i].getType();
propertyNullability[i] = properties[i].isNullable();
propertyUpdateability[i] = properties[i].isUpdateable();
propertyInsertability[i] = properties[i].isInsertable();
insertInclusions[i] = determineInsertValueGenerationType(attributeBinding, properties[i]);
updateInclusions[i] = determineUpdateValueGenerationType(attributeBinding, properties[i]);
propertyVersionability[i] = properties[i].isVersionable();
nonlazyPropertyUpdateability[i] = properties[i].isUpdateable() && !lazy;
propertyCheckability[i] =
propertyUpdateability[i]
|| (propertyTypes[i].isAssociationType()
&& ((AssociationType) propertyTypes[i]).isAlwaysDirtyChecked());
cascadeStyles[i] = properties[i].getCascadeStyle();
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (properties[i].isLazy()) {
hasLazy = true;
}
if (properties[i].getCascadeStyle() != CascadeStyles.NONE) {
foundCascade = true;
}
if (indicatesCollection(properties[i].getType())) {
foundCollection = true;
}
if (propertyTypes[i].isMutable() && propertyCheckability[i]) {
foundMutable = true;
}
if (insertInclusions[i] != ValueInclusion.NONE) {
foundInsertGeneratedValue = true;
}
if (updateInclusions[i] != ValueInclusion.NONE) {
foundUpdateGeneratedValue = true;
}
mapPropertyToIndex(attributeBinding.getAttribute(), i);
i++;
}
if (naturalIdNumbers.size() == 0) {
naturalIdPropertyNumbers = null;
hasImmutableNaturalId = false;
hasCacheableNaturalId = false;
} else {
naturalIdPropertyNumbers = ArrayHelper.toIntArray(naturalIdNumbers);
hasImmutableNaturalId = !foundUpdateableNaturalIdProperty;
hasCacheableNaturalId = false; // See previous TODO and HHH-6354
}
hasInsertGeneratedValues = foundInsertGeneratedValue;
hasUpdateGeneratedValues = foundUpdateGeneratedValue;
hasCascades = foundCascade;
hasNonIdentifierPropertyNamedId = foundNonIdentifierPropertyNamedId;
versionPropertyIndex = tempVersionProperty;
hasLazyProperties = hasLazy;
if (hasLazyProperties) {
LOG.lazyPropertyFetchingAvailable(name);
}
lazy =
entityBinding.isLazy()
&& (
// TODO: this disables laziness even in non-pojo entity modes:
!hasPojoRepresentation || !ReflectHelper.isFinalClass(proxyInterfaceClass));
mutable = entityBinding.isMutable();
if (entityBinding.isAbstract() == null) {
// legacy behavior (with no abstract attribute specified)
isAbstract = hasPojoRepresentation && ReflectHelper.isAbstractClass(mappedClass);
} else {
isAbstract = entityBinding.isAbstract().booleanValue();
if (!isAbstract && hasPojoRepresentation && ReflectHelper.isAbstractClass(mappedClass)) {
LOG.entityMappedAsNonAbstract(name);
}
}
selectBeforeUpdate = entityBinding.isSelectBeforeUpdate();
dynamicUpdate = entityBinding.isDynamicUpdate();
dynamicInsert = entityBinding.isDynamicInsert();
hasSubclasses = entityBinding.hasSubEntityBindings();
polymorphic = entityBinding.isPolymorphic();
explicitPolymorphism = entityBinding.getHierarchyDetails().isExplicitPolymorphism();
inherited = !entityBinding.isRoot();
superclass = inherited ? entityBinding.getEntity().getSuperType().getName() : null;
optimisticLockStyle = entityBinding.getHierarchyDetails().getOptimisticLockStyle();
final boolean isAllOrDirty =
optimisticLockStyle == OptimisticLockStyle.ALL
|| optimisticLockStyle == OptimisticLockStyle.DIRTY;
if (isAllOrDirty && !dynamicUpdate) {
throw new MappingException(
"optimistic-lock=all|dirty requires dynamic-update=\"true\": " + name);
}
if (versionPropertyIndex != NO_VERSION_INDX && isAllOrDirty) {
throw new MappingException(
"version and optimistic-lock=all|dirty are not a valid combination : " + name);
}
hasCollections = foundCollection;
hasMutableProperties = foundMutable;
for (EntityBinding subEntityBinding : entityBinding.getPostOrderSubEntityBindingClosure()) {
subclassEntityNames.add(subEntityBinding.getEntity().getName());
if (subEntityBinding.getEntity().getClassReference() != null) {
entityNameByInheritenceClassMap.put(
subEntityBinding.getEntity().getClassReference(),
subEntityBinding.getEntity().getName());
}
}
subclassEntityNames.add(name);
if (mappedClass != null) {
entityNameByInheritenceClassMap.put(mappedClass, name);
}
entityMode = hasPojoRepresentation ? EntityMode.POJO : EntityMode.MAP;
final EntityTuplizerFactory entityTuplizerFactory =
sessionFactory.getSettings().getEntityTuplizerFactory();
Class<? extends EntityTuplizer> tuplizerClass = entityBinding.getCustomEntityTuplizerClass();
if (tuplizerClass == null) {
entityTuplizer =
entityTuplizerFactory.constructDefaultTuplizer(entityMode, this, entityBinding);
} else {
entityTuplizer = entityTuplizerFactory.constructTuplizer(tuplizerClass, this, entityBinding);
}
}
protected void setUp() {
serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(Environment.getProperties());
}