public Type getType() throws MappingException {
if (type != null) {
return type;
}
if (typeName == null) {
throw new MappingException("No type name");
}
if (typeParameters != null
&& Boolean.valueOf(typeParameters.getProperty(DynamicParameterizedType.IS_DYNAMIC))
&& typeParameters.get(DynamicParameterizedType.PARAMETER_TYPE) == null) {
createParameterImpl();
}
Type result = metadata.getTypeResolver().heuristicType(typeName, typeParameters);
if (result == null) {
String msg = "Could not determine type for: " + typeName;
if (table != null) {
msg += ", at table: " + table.getName();
}
if (columns != null && columns.size() > 0) {
msg += ", for columns: " + columns;
}
throw new MappingException(msg);
}
return result;
}
private SchemaExport createSchemaExport(Class[] annotatedClasses) {
final MetadataSources metadataSources = new MetadataSources(ssr);
for (Class c : annotatedClasses) {
metadataSources.addAnnotatedClass(c);
}
metadata = (MetadataImplementor) metadataSources.buildMetadata();
metadata.validate();
SchemaExport schemaExport = new SchemaExport(metadata);
schemaExport.setHaltOnError(false).setFormat(false);
return schemaExport;
}
public void setTypeUsingReflection(String className, String propertyName)
throws MappingException {
// NOTE : this is called as the last piece in setting SimpleValue type information, and
// implementations
// rely on that fact, using it as a signal that all information it is going to get is defined at
// this point...
if (typeName != null) {
// assume either (a) explicit type was specified or (b) determine was already performed
return;
}
if (type != null) {
return;
}
if (attributeConverterDefinition == null) {
// this is here to work like legacy. This should change when we integrate with metamodel to
// look for SqlTypeDescriptor and JavaTypeDescriptor individually and create the BasicType
// (well, really
// keep a registry of [SqlTypeDescriptor,JavaTypeDescriptor] -> BasicType...)
if (className == null) {
throw new MappingException(
"Attribute types for a dynamic entity must be explicitly specified: " + propertyName);
}
typeName =
ReflectHelper.reflectedPropertyClass(
className,
propertyName,
metadata
.getMetadataBuildingOptions()
.getServiceRegistry()
.getService(ClassLoaderService.class))
.getName();
// todo : to fully support isNationalized here we need do the process hinted at above
// essentially, much of the logic from #buildAttributeConverterTypeAdapter wrt resolving
// a (1) SqlTypeDescriptor, a (2) JavaTypeDescriptor and dynamically building a BasicType
// combining them.
return;
}
// we had an AttributeConverter...
type = buildAttributeConverterTypeAdapter();
}
private EntityType getEntityType() {
return metadata
.getTypeResolver()
.getTypeFactory()
.manyToOne(getReferencedEntityName(), true, null, false, false, isIgnoreNotFound(), false);
}
@Override
public ServiceRegistry getServiceRegistry() {
return metadata.getMetadataBuildingOptions().getServiceRegistry();
}
@Override
public IdentifierGenerator createIdentifierGenerator(
IdentifierGeneratorFactory identifierGeneratorFactory,
Dialect dialect,
String defaultCatalog,
String defaultSchema,
RootClass rootClass)
throws MappingException {
if (identifierGenerator != null) {
return identifierGenerator;
}
Properties params = new Properties();
// if the hibernate-mapping did not specify a schema/catalog, use the defaults
// specified by properties - but note that if the schema/catalog were specified
// in hibernate-mapping, or as params, they will already be initialized and
// will override the values set here (they are in identifierGeneratorProperties)
if (defaultSchema != null) {
params.setProperty(PersistentIdentifierGenerator.SCHEMA, defaultSchema);
}
if (defaultCatalog != null) {
params.setProperty(PersistentIdentifierGenerator.CATALOG, defaultCatalog);
}
// pass the entity-name, if not a collection-id
if (rootClass != null) {
params.setProperty(IdentifierGenerator.ENTITY_NAME, rootClass.getEntityName());
params.setProperty(IdentifierGenerator.JPA_ENTITY_NAME, rootClass.getJpaEntityName());
}
// init the table here instead of earlier, so that we can get a quoted table name
// TODO: would it be better to simply pass the qualified table name, instead of
// splitting it up into schema/catalog/table names
String tableName = getTable().getQuotedName(dialect);
params.setProperty(PersistentIdentifierGenerator.TABLE, tableName);
// pass the column name (a generated id almost always has a single column)
String columnName = ((Column) getColumnIterator().next()).getQuotedName(dialect);
params.setProperty(PersistentIdentifierGenerator.PK, columnName);
if (rootClass != null) {
StringBuilder tables = new StringBuilder();
Iterator iter = rootClass.getIdentityTables().iterator();
while (iter.hasNext()) {
Table table = (Table) iter.next();
tables.append(table.getQuotedName(dialect));
if (iter.hasNext()) {
tables.append(", ");
}
}
params.setProperty(PersistentIdentifierGenerator.TABLES, tables.toString());
} else {
params.setProperty(PersistentIdentifierGenerator.TABLES, tableName);
}
if (identifierGeneratorProperties != null) {
params.putAll(identifierGeneratorProperties);
}
// TODO : we should pass along all settings once "config lifecycle" is hashed out...
final ConfigurationService cs =
metadata
.getMetadataBuildingOptions()
.getServiceRegistry()
.getService(ConfigurationService.class);
params.put(
AvailableSettings.PREFER_POOLED_VALUES_LO,
cs.getSetting(
AvailableSettings.PREFER_POOLED_VALUES_LO, StandardConverters.BOOLEAN, false));
if (cs.getSettings().get(AvailableSettings.PREFERRED_POOLED_OPTIMIZER) != null) {
params.put(
AvailableSettings.PREFERRED_POOLED_OPTIMIZER,
cs.getSettings().get(AvailableSettings.PREFERRED_POOLED_OPTIMIZER));
}
identifierGeneratorFactory.setDialect(dialect);
identifierGenerator =
identifierGeneratorFactory.createIdentifierGenerator(
identifierGeneratorStrategy, getType(), params);
return identifierGenerator;
}
