org.hibernate.boot.model.naming.PhysicalNamingStrategy Java Examples

private Metadata getMetadata(Set<BeanDefinition> components, PhysicalNamingStrategy namingStrategy,
        MetadataFactory mf) {
    ServiceRegistry registry = metadataSources.getServiceRegistry();
    StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder(
            (BootstrapServiceRegistry) registry).applySetting(AvailableSettings.DIALECT, TeiidDialect.class)
            .build();
    // Generate Hibernate model based on @Entity definitions
    for (BeanDefinition c : components) {
        try {
            Class<?> clazz = Class.forName(c.getBeanClassName());
            metadataSources.addAnnotatedClass(clazz);
        } catch (ClassNotFoundException e) {
        }
    }
    return metadataSources.getMetadataBuilder(serviceRegistry).applyPhysicalNamingStrategy(namingStrategy).build();
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    boolean deploy = true;
    VDBMetaData vdb = this.beanFactory.getBean(VDBMetaData.class);
    TeiidServer server = this.beanFactory.getBean(TeiidServer.class);

    if (Boolean.valueOf(vdb.getPropertyValue(TeiidAutoConfiguration.IMPLICIT_VDB))) {
        PhysicalNamingStrategy namingStrategy = this.beanFactory.getBean(PhysicalNamingStrategy.class);
        deploy = server.findAndConfigureViews(vdb, event.getApplicationContext(), namingStrategy);
    }

    if (deploy) {
        // Deploy at the end when all the data sources are configured
        server.undeployVDB(TeiidConstants.VDBNAME);
        server.undeployVDB(vdb.getName(), vdb.getVersion());
        server.deployVDB(vdb, true, this.context);
    }
}
 

public EntityManagerFactoryServiceImpl(
		ObjectProvider<List<SchemaManagementProvider>> providers,
		ObjectProvider<PhysicalNamingStrategy> physicalNamingStrategy,
		ObjectProvider<ImplicitNamingStrategy> implicitNamingStrategy,
		ObjectProvider<List<HibernatePropertiesCustomizer>> hibernatePropertiesCustomizers) {
	this.defaultDdlAutoProvider = new HibernateDefaultDdlAutoProvider(
			providers.getIfAvailable(Collections::emptyList));
	this.physicalNamingStrategy = physicalNamingStrategy.getIfAvailable();
	this.implicitNamingStrategy = implicitNamingStrategy.getIfAvailable();
	this.hibernatePropertiesCustomizers = hibernatePropertiesCustomizers
			.getIfAvailable(() -> Collections.emptyList());
}
 

@Inject
public DefaultPersistManager(PhysicalNamingStrategy physicalNamingStrategy,
		HibernateProperties properties, Interceptor interceptor, 
		IdManager idManager, Dao dao, EntityValidator validator, 
		TransactionManager transactionManager) {
	this.physicalNamingStrategy = physicalNamingStrategy;
	this.properties = properties;
	this.interceptor = interceptor;
	this.idManager = idManager;
	this.dao = dao;
	this.validator = validator;
	this.transactionManager = transactionManager;
	serviceRegistry = new StandardServiceRegistryBuilder().applySettings(properties).build();
}
 

@Inject
public CleanDatabase(PhysicalNamingStrategy physicalNamingStrategy,
		HibernateProperties properties, Interceptor interceptor, 
		IdManager idManager, Dao dao, EntityValidator validator, 
		TransactionManager transactionManager) {
	super(physicalNamingStrategy, properties, interceptor, idManager, dao, validator, transactionManager);
}
 

@Inject
public ApplyDatabaseConstraints(PhysicalNamingStrategy physicalNamingStrategy,
		HibernateProperties properties, Interceptor interceptor, 
		IdManager idManager, Dao dao, EntityValidator validator,
		TransactionManager transactionManager) {
	super(physicalNamingStrategy, properties, interceptor, idManager, dao, validator, transactionManager);
}
 

@Inject
public RestoreDatabase(PhysicalNamingStrategy physicalNamingStrategy,
		HibernateProperties properties, Interceptor interceptor, 
		IdManager idManager, Dao dao, EntityValidator validator, 
		TransactionManager transactionManager) {
	super(physicalNamingStrategy, properties, interceptor, idManager, dao, validator, transactionManager);
}
 

@Inject
public ResetAdminPassword(PhysicalNamingStrategy physicalNamingStrategy, HibernateProperties properties, 
		Interceptor interceptor, IdManager idManager, Dao dao, 
		EntityValidator validator, UserManager userManager, PasswordService passwordService, 
		TransactionManager transactionManager) {
	super(physicalNamingStrategy, properties, interceptor, idManager, dao, validator, transactionManager);
	this.userManager = userManager;
	this.passwordService = passwordService;
}
 

@Inject
public Upgrade(PhysicalNamingStrategy physicalNamingStrategy,
		HibernateProperties properties, Interceptor interceptor, 
		IdManager idManager, Dao dao, EntityValidator validator, 
		TransactionManager transactionManager) {
	super(physicalNamingStrategy, properties, interceptor, idManager, dao, validator, transactionManager);
}
 

@Inject
public CheckDataVersion(PhysicalNamingStrategy physicalNamingStrategy,
		HibernateProperties properties, Interceptor interceptor, 
		IdManager idManager, Dao dao, EntityValidator validator, 
		TransactionManager transactionManager) {
	super(physicalNamingStrategy, properties, interceptor, idManager, dao, validator, transactionManager);
}
 

@Inject
public BackupDatabase(PhysicalNamingStrategy physicalNamingStrategy,
		HibernateProperties properties, Interceptor interceptor, 
		IdManager idManager, Dao dao, EntityValidator validator, 
		TransactionManager transactionManager) {
	super(physicalNamingStrategy, properties, interceptor, idManager, dao, validator, transactionManager);
}
 

@Bean(name = "teiidNamingStrategy")
public PhysicalNamingStrategy teiidNamingStrategy() {
    try {
        return (PhysicalNamingStrategy) Class.forName(hibernateNamingClass).getDeclaredConstructors()[0]
                .newInstance();
    } catch (InstantiationException | IllegalAccessException | ClassNotFoundException
            | InvocationTargetException e) {
        return null;
    }
}
 

@SuppressWarnings("deprecation")
private void configure(MetadataBuilder metadataBuilder, StandardServiceRegistry serviceRegistry) {
	final StrategySelector strategySelector = serviceRegistry.getService( StrategySelector.class );
	if ( implicitNamingStrategy != null ) {
		metadataBuilder.applyImplicitNamingStrategy(
				strategySelector.resolveStrategy( ImplicitNamingStrategy.class, implicitNamingStrategy )
		);
	}
	if ( physicalNamingStrategy != null ) {
		metadataBuilder.applyPhysicalNamingStrategy(
				strategySelector.resolveStrategy( PhysicalNamingStrategy.class, physicalNamingStrategy )
		);
	}
}
 

@Override
public PhysicalNamingStrategy getPhysicalNamingStrategy() {
	return delegate.getPhysicalNamingStrategy();
}
 

/**
 * Default constructor.
 * @param physicalNamingStrategy The naming strategy
 */
public PhysicalNamingStrategyConfiguration(PhysicalNamingStrategy physicalNamingStrategy) {
    Objects.requireNonNull(physicalNamingStrategy, "PhysicalNamingStrategy cannot be null");
    this.physicalNamingStrategy = physicalNamingStrategy;
}
 

public PhysicalNamingStrategy getPhysicalNamingStrategy() {
	return getBuildingOptions().getPhysicalNamingStrategy();
}
 

@Override
public MetadataBuilder applyPhysicalNamingStrategy(PhysicalNamingStrategy namingStrategy) {
	this.options.physicalNamingStrategy = namingStrategy;
	return this;
}
 

@Override
public PhysicalNamingStrategy getPhysicalNamingStrategy() {
	return physicalNamingStrategy;
}
 

NamingStrategiesHibernatePropertiesCustomizer(PhysicalNamingStrategy physicalNamingStrategy,
    ImplicitNamingStrategy implicitNamingStrategy) {
  this.physicalNamingStrategy = physicalNamingStrategy;
  this.implicitNamingStrategy = implicitNamingStrategy;
}
 

@Override
public MetadataBuilder applyPhysicalNamingStrategy(PhysicalNamingStrategy namingStrategy) {
	delegate.applyPhysicalNamingStrategy( namingStrategy );
	return getThis();
}
 

public void setPhysicalNamingStrategy(PhysicalNamingStrategy physicalNamingStrategy) {
	this.physicalNamingStrategy = physicalNamingStrategy;
}
 

/**
 * Specify the PhysicalNamingStrategy to use in building the Metadata.
 * <p/>
 * Its default is defined by the {@link org.hibernate.cfg.AvailableSettings#PHYSICAL_NAMING_STRATEGY}
 * setting if using property-based configuration.
 *
 * @param namingStrategy The PhysicalNamingStrategy to apply
 *
 * @return {@code this}, for method chaining
 *
 * @see org.hibernate.cfg.AvailableSettings#PHYSICAL_NAMING_STRATEGY
 */
MetadataBuilder applyPhysicalNamingStrategy(PhysicalNamingStrategy namingStrategy);
 

/**
 * Set a Hibernate 5.0 PhysicalNamingStrategy for the SessionFactory.
 * @see Configuration#setPhysicalNamingStrategy
 */
public void setPhysicalNamingStrategy(PhysicalNamingStrategy physicalNamingStrategy) {
	this.physicalNamingStrategy = physicalNamingStrategy;
}
 

/**
 * Set a Hibernate 5 {@link PhysicalNamingStrategy} for the SessionFactory.
 * @see Configuration#setPhysicalNamingStrategy
 */
public void setPhysicalNamingStrategy(PhysicalNamingStrategy physicalNamingStrategy) {
	this.physicalNamingStrategy = physicalNamingStrategy;
}
 

/**
 * Set a Hibernate 5 {@link PhysicalNamingStrategy} for the SessionFactory.
 * @see Configuration#setPhysicalNamingStrategy
 */
public void setPhysicalNamingStrategy(PhysicalNamingStrategy physicalNamingStrategy) {
	this.physicalNamingStrategy = physicalNamingStrategy;
}
 

/**
 * Set a Hibernate 5.0 PhysicalNamingStrategy for the SessionFactory.
 * @see Configuration#setPhysicalNamingStrategy
 */
public void setPhysicalNamingStrategy(PhysicalNamingStrategy physicalNamingStrategy) {
	this.physicalNamingStrategy = physicalNamingStrategy;
}
 

PhysicalNamingStrategy getPhysicalNamingStrategy();