Java JdbcServices类代码示例

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "UnusedParameters"})
private static void applyRelationalConstraints(ValidatorFactory factory, ActivationContext activationContext) {
	final Properties properties = activationContext.getConfiguration().getProperties();
	if ( ! ConfigurationHelper.getBoolean( BeanValidationIntegrator.APPLY_CONSTRAINTS, properties, true ) ){
		LOG.debug( "Skipping application of relational constraints from legacy Hibernate Validator" );
		return;
	}

	final Set<ValidationMode> modes = activationContext.getValidationModes();
	if ( ! ( modes.contains( ValidationMode.DDL ) || modes.contains( ValidationMode.AUTO ) ) ) {
		return;
	}

	applyRelationalConstraints(
			factory,
			activationContext.getConfiguration().createMappings().getClasses().values(),
			properties,
			activationContext.getServiceRegistry().getService( JdbcServices.class ).getDialect()
	);
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
public SchemaExport(ServiceRegistry serviceRegistry, Configuration configuration) {
	this.connectionHelper = new SuppliedConnectionProviderConnectionHelper(
			serviceRegistry.getService( ConnectionProvider.class )
	);
	this.sqlStatementLogger = serviceRegistry.getService( JdbcServices.class ).getSqlStatementLogger();
	this.formatter = ( sqlStatementLogger.isFormat() ? FormatStyle.DDL : FormatStyle.NONE ).getFormatter();
	this.sqlExceptionHelper = serviceRegistry.getService( JdbcServices.class ).getSqlExceptionHelper();

	this.importFiles = ConfigurationHelper.getString(
			AvailableSettings.HBM2DDL_IMPORT_FILES,
			configuration.getProperties(),
			DEFAULT_IMPORT_FILE
	);

	final Dialect dialect = serviceRegistry.getService( JdbcServices.class ).getDialect();
	this.dropSQL = configuration.generateDropSchemaScript( dialect );
	this.createSQL = configuration.generateSchemaCreationScript( dialect );
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
/**
 * Constructs a LogicalConnectionImpl
 *
 * @param userSuppliedConnection The user-supplied connection
 * @param connectionReleaseMode The connection release mode to use
 * @param jdbcServices JdbcServices
 * @param jdbcConnectionAccess JDBC Connection access
 */
public LogicalConnectionImpl(
		Connection userSuppliedConnection,
		ConnectionReleaseMode connectionReleaseMode,
		JdbcServices jdbcServices,
		JdbcConnectionAccess jdbcConnectionAccess) {
	this(
			connectionReleaseMode,
			jdbcServices,
			jdbcConnectionAccess,
			(userSuppliedConnection != null),
			false,
			new ArrayList<ConnectionObserver>()
	);
	this.physicalConnection = userSuppliedConnection;
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
@Override
public void execute(Connection connection) {
	try {
		Statement statement = connection.createStatement();
		try {
			statement.executeUpdate( persister.getTemporaryIdTableDDL() );
			persister.getFactory()
					.getServiceRegistry()
					.getService( JdbcServices.class )
					.getSqlExceptionHelper()
					.handleAndClearWarnings( statement, CREATION_WARNING_HANDLER );
		}
		finally {
			try {
				statement.close();
			}
			catch( Throwable ignore ) {
				// ignore
			}
		}
	}
	catch( Exception e ) {
		log.debug( "unable to create temporary id table [" + e.getMessage() + "]" );
	}
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
@Override
public void execute(Connection connection) {
    try {
        Statement statement = connection.createStatement();
        try {
            statement.executeUpdate( persister.getTemporaryIdTableDDL() );
            persister.getFactory()
                    .getServiceRegistry()
                    .getService( JdbcServices.class )
                    .getSqlExceptionHelper()
                    .handleAndClearWarnings( statement, CREATION_WARNING_HANDLER );
        }
        finally {
            try {
                statement.close();
            }
            catch( Throwable ignore ) {
                // ignore
            }
        }
    }
    catch( Exception e ) {
        log.debug( "unable to create temporary id table [" + e.getMessage() + "]" );
    }
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
protected JDBCException convertSqlException(String message, SQLException e) {
	// if JdbcServices#getSqlExceptionHelper is available, use it...
	final JdbcServices jdbcServices = serviceRegistry.getService( JdbcServices.class );
	if ( jdbcServices != null && jdbcServices.getSqlExceptionHelper() != null ) {
		return jdbcServices.getSqlExceptionHelper().convert( e, message, null );
	}

	// likely we are still in the process of initializing the ServiceRegistry, so use the simplified
	// SQLException conversion
	return simpleConverterAccess.getValue().convert( e, message, null );
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
/**
 * Constructs a ResultSetReturnImpl
 *
 * @param jdbcCoordinator The JdbcCoordinator
 */
public ResultSetReturnImpl(JdbcCoordinator jdbcCoordinator) {
	this.jdbcCoordinator = jdbcCoordinator;

	final JdbcServices jdbcServices = jdbcCoordinator.getTransactionCoordinator().getTransactionContext()
			.getTransactionEnvironment()
			.getJdbcServices();

	this.dialect = jdbcServices.getDialect();
	this.sqlStatementLogger = jdbcServices.getSqlStatementLogger();
	this.sqlExceptionHelper = jdbcServices.getSqlExceptionHelper();
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
protected AbstractBatchImpl(BatchKey key, JdbcCoordinator jdbcCoordinator) {
	if ( key == null ) {
		throw new IllegalArgumentException( "batch key cannot be null" );
	}
	if ( jdbcCoordinator == null ) {
		throw new IllegalArgumentException( "JDBC coordinator cannot be null" );
	}
	this.key = key;
	this.jdbcCoordinator = jdbcCoordinator;

	this.transactionContext = jdbcCoordinator.getTransactionCoordinator().getTransactionContext();
	final JdbcServices jdbcServices = transactionContext.getTransactionEnvironment().getJdbcServices();
	this.sqlStatementLogger = jdbcServices.getSqlStatementLogger();
	this.sqlExceptionHelper = jdbcServices.getSqlExceptionHelper();
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
public TransactionEnvironmentImpl(SessionFactoryImpl sessionFactory) {
    this.sessionFactory = sessionFactory;
    this.statisticsImplementor = sessionFactory.getStatisticsImplementor();
    this.serviceRegistry = sessionFactory.getServiceRegistry();
    this.jdbcServices = serviceRegistry.getService( JdbcServices.class );
    this.jtaPlatform = serviceRegistry.getService( JtaPlatform.class );
    this.transactionFactory = serviceRegistry.getService( TransactionFactory.class );
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
@Override
public void prepare(
		JdbcServices jdbcServices,
		JdbcConnectionAccess connectionAccess,
		Mappings mappings,
		Mapping mapping,
		Map settings) {
	this.catalog = ConfigurationHelper.getString(
			CATALOG,
			settings,
			ConfigurationHelper.getString( AvailableSettings.DEFAULT_CATALOG, settings )
	);
	this.schema = ConfigurationHelper.getString(
			SCHEMA,
			settings,
			ConfigurationHelper.getString( AvailableSettings.DEFAULT_SCHEMA, settings )
	);
	this.cleanUpTables = ConfigurationHelper.getBoolean( CLEAN_UP_ID_TABLES, settings, false );

	final Iterator<PersistentClass> entityMappings = mappings.iterateClasses();
	final List<Table> idTableDefinitions = new ArrayList<Table>();
	while ( entityMappings.hasNext() ) {
		final PersistentClass entityMapping = entityMappings.next();
		final Table idTableDefinition = generateIdTableDefinition( entityMapping );
		idTableDefinitions.add( idTableDefinition );
	}
	exportTableDefinitions( idTableDefinitions, jdbcServices, connectionAccess, mappings, mapping );
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
public static void checkEntityManagerFactoryConfiguration(EntityManagerFactory entityManagerFactory) {
    try {
        SessionFactoryImpl sessionFactoryImpl = entityManagerFactory.unwrap(SessionFactoryImpl.class);
        if (PostgreSQL9Dialect.class
            .isInstance(sessionFactoryImpl.getServiceRegistry().getService(JdbcServices.class).getDialect())) {
            //fix ClassLeftUnique and ClassRightUnique, as PostgreSQL cannot evaluate them on statement level
            modifyConstraints(sessionFactoryImpl);
        }
    } catch (PersistenceException e) {
        LogManager.getLogger()
            .warn("Unsupported EntityManagerFactory found: {}", entityManagerFactory.getClass().getName());
    }
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
@Override
public void prepare(JdbcServices jdbcServices, JdbcConnectionAccess connectionAccess, MetadataImplementor metadata, SessionFactoryOptions sessionFactoryOptions) {
    ConfigurationService configService = sessionFactoryOptions.getServiceRegistry().getService(ConfigurationService.class);
    this.fullyQualifiedTableName = Objects.requireNonNull(configService.getSetting(TABLE, String.class, null), "Property " + TABLE + " must be set.");
    this.idColumn = configService.getSetting(ID_COLUMN, String.class, "ID");
    this.discriminatorColumn = configService.getSetting(DISCRIMINATOR_COLUMN, String.class, "ENTITY_NAME");
    this.cleanRows = configService.getSetting(CLEAN_ROWS, StandardConverters.BOOLEAN, false);
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
@Override
public void prepare(
		JdbcServices jdbcServices,
		JdbcConnectionAccess jdbcConnectionAccess,
		MetadataImplementor metadataImplementor,
		SessionFactoryOptions sessionFactoryOptions) {

}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
public DbOpenHelper(ServiceRegistry serviceRegistry) throws HibernateException {
    final JdbcServices jdbcServices = serviceRegistry.getService(JdbcServices.class);
    connectionHelper = new SuppliedConnectionProviderConnectionHelper(jdbcServices.getConnectionProvider());

    sqlStatementLogger = jdbcServices.getSqlStatementLogger();
    formatter = (sqlStatementLogger.isFormat() ? FormatStyle.DDL : FormatStyle.NONE).getFormatter();
}
 

import org.hibernate.engine.jdbc.spi.JdbcServices; //导入依赖的package包/类
/**
    * Updates (or inserts) table column value with existing id
    * 
    * @param session
    * @param currentValue
    * @return {@link Serializable}
    */
   public Serializable generateIncrementally(final SessionImplementor session,
    final long currentValue) {

final SqlStatementLogger statementLogger = session.getFactory()
	.getServiceRegistry().getService(JdbcServices.class)
	.getSqlStatementLogger();
final AccessCallback callback = new AccessCallbackImpl(session,
	currentValue, statementLogger);

return optimizer.generate(callback);
   }