/**
* Generates a VersionProperty representation for an entity mapping given its version mapping
* Property.
*
* @param property The version mapping Property.
* @param lazyAvailable Is property lazy loading currently available.
* @return The appropriate VersionProperty definition.
*/
public static VersionProperty buildVersionProperty(
EntityPersister persister,
SessionFactoryImplementor sessionFactory,
int attributeNumber,
Property property,
boolean lazyAvailable) {
String mappedUnsavedValue = ((KeyValue) property.getValue()).getNullValue();
VersionValue unsavedValue =
UnsavedValueFactory.getUnsavedVersionValue(
mappedUnsavedValue,
getGetter(property),
(VersionType) property.getType(),
getConstructor(property.getPersistentClass()));
boolean lazy = lazyAvailable && property.isLazy();
return new VersionProperty(
persister,
sessionFactory,
attributeNumber,
property.getName(),
property.getValue().getType(),
new BaselineAttributeInformation.Builder()
.setLazy(lazy)
.setInsertable(property.isInsertable())
.setUpdateable(property.isUpdateable())
.setValueGenerationStrategy(property.getValueGenerationStrategy())
.setNullable(property.isOptional())
.setDirtyCheckable(property.isUpdateable() && !lazy)
.setVersionable(property.isOptimisticLocked())
.setCascadeStyle(property.getCascadeStyle())
.createInformation(),
unsavedValue);
}
@SuppressWarnings({"unchecked"})
private boolean addIdProperties(
Element parent,
Iterator<Property> properties,
SimpleMapperBuilder mapper,
boolean key,
boolean audited) {
while (properties.hasNext()) {
Property property = properties.next();
Type propertyType = property.getType();
if (!"_identifierMapper".equals(property.getName())) {
// Last but one parameter: ids are always insertable
boolean added =
mainGenerator
.getBasicMetadataGenerator()
.addBasic(
parent,
getIdPersistentPropertyAuditingData(property),
property.getValue(),
mapper,
true,
key);
if (!added) {
// If the entity is audited, and a non-supported id component is used, throwing an
// exception.
// If the entity is not audited, then we simply don't support this entity, even in
// target relation mode not audited.
if (audited) {
throw new MappingException("Type not supported: " + propertyType.getClass().getName());
} else {
return false;
}
}
}
}
return true;
}
public static InDatabaseValueGenerationStrategyImpl create(
SessionFactoryImplementor sessionFactoryImplementor,
Property mappingProperty,
ValueGeneration valueGeneration) {
final int numberOfMappedColumns =
mappingProperty.getType().getColumnSpan(sessionFactoryImplementor);
if (numberOfMappedColumns == 1) {
return new InDatabaseValueGenerationStrategyImpl(
valueGeneration.getGenerationTiming(),
valueGeneration.referenceColumnInSql(),
new String[] {valueGeneration.getDatabaseGeneratedReferencedColumnValue()});
} else {
if (valueGeneration.getDatabaseGeneratedReferencedColumnValue() != null) {
LOG.debugf(
"Value generator specified column value in reference to multi-column attribute [%s -> %s]; ignoring",
mappingProperty.getPersistentClass(), mappingProperty.getName());
}
return new InDatabaseValueGenerationStrategyImpl(
valueGeneration.getGenerationTiming(),
valueGeneration.referenceColumnInSql(),
new String[numberOfMappedColumns]);
}
}
public boolean isPlural() {
return propertyMapping.getType().isCollectionType();
}
@SuppressWarnings({CompilerWarnings.UNCHECKED})
private void buildEntityMetadatas() throws Exception {
SessionFactoryImpl sessionFactory =
((SessionFactoryImpl) this.entityManagerFactory.getSessionFactory());
Class<?> entityBindingMappedClass;
Class<? extends SdcctEntity> entityMappedClass;
String entityName, entityPropName, entityPropFieldName;
EntityMetadata entityMetadata;
Map<String, PropertyMetadata> entityPropMetadatas;
IndexedTypeDescriptor indexedEntityDesc;
Method entityPropGetterMethod;
boolean entityIndexed, entityPropIndexed;
PropertyDescriptor indexedEntityPropDesc;
PropertyMetadata entityPropMetadata;
BidiMap<Integer, String> entityPropOrder;
String[] entityPropOrderNames;
for (PersistentClass entityBinding : metadata.getEntityBindings()) {
if (((entityBindingMappedClass = entityBinding.getMappedClass()) == null)
|| !SdcctEntity.class.isAssignableFrom(entityBindingMappedClass)) {
continue;
}
entityPropMetadatas =
(entityMetadata =
new EntityMetadataImpl(
(entityName = entityBinding.getEntityName()),
(entityIndexed =
(indexedEntityDesc =
searchIntegrator.getIndexedTypeDescriptor(
(entityMappedClass =
((Class<? extends SdcctEntity>)
entityBindingMappedClass))))
.isIndexed()),
entityMappedClass,
entityBinding.getTable().getName()))
.getProperties();
this.entityMetadatas.put(
((Class<? extends SdcctEntity>) entityMappedClass.getInterfaces()[0]), entityMetadata);
for (Property entityProp :
IteratorUtils.asIterable(
IteratorUtils.chainedIterator(
((Iterator<Property>) entityBinding.getRootClass().getPropertyIterator()),
((Iterator<Property>) entityBinding.getPropertyIterator())))) {
entityPropName = entityProp.getName();
entityPropGetterMethod = entityProp.getGetter(entityMappedClass).getMethod();
if (entityProp.getColumnSpan() == 0) {
continue;
}
entityPropIndexed =
(entityIndexed
&& entityPropGetterMethod.isAnnotationPresent(Fields.class)
&& ((indexedEntityPropDesc = indexedEntityDesc.getProperty(entityPropName)) != null)
&& !indexedEntityPropDesc.isId());
entityPropMetadatas.put(
entityPropName,
(entityPropMetadata =
new PropertyMetadataImpl(
entityPropName,
entityPropIndexed,
((Column) entityProp.getColumnIterator().next()).getName(),
entityProp.getType())));
if (entityPropIndexed) {
for (Field entityPropFieldAnno :
entityPropGetterMethod.getAnnotation(Fields.class).value()) {
if (entityPropFieldAnno.analyze() == Analyze.NO) {
continue;
}
entityPropFieldName = entityPropFieldAnno.name();
switch (entityPropFieldAnno.analyzer().definition()) {
case DbAnalyzerNames.EDGE_NGRAM:
entityPropMetadata.setEdgeNgramFieldName(entityPropFieldName);
break;
case DbAnalyzerNames.LOWERCASE:
entityPropMetadata.setLowercaseFieldName(entityPropFieldName);
break;
case DbAnalyzerNames.NGRAM:
entityPropMetadata.setNgramFieldName(entityPropFieldName);
break;
case DbAnalyzerNames.PHONETIC:
entityPropMetadata.setPhoneticFieldName(entityPropFieldName);
break;
}
}
}
}
entityMetadata.setIdProperty(
entityPropMetadatas.get(entityBinding.getIdentifierProperty().getName()));
entityPropOrder = entityMetadata.getPropertyOrder();
entityPropOrderNames = sessionFactory.getEntityPersister(entityName).getPropertyNames();
for (int a = 0; a < entityPropOrderNames.length; a++) {
entityPropOrder.put(a, entityPropOrderNames[a]);
}
}
LOGGER.debug(
String.format(
"Processed metadata for %d entities: [%s]",
this.entityMetadatas.size(),
this.entityMetadatas
.values()
.stream()
.map(NamedBean::getName)
.collect(Collectors.joining(", "))));
}