Java SqlExceptionHelper类代码示例

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
/**
 * Create a schema exporter for the given Configuration, with the given
 * database connection properties.
 *
 * @param configuration The configuration from which to build a schema export.
 * @param properties The properties from which to configure connectivity etc.
 * @throws HibernateException Indicates problem preparing for schema export.
 *
 * @deprecated properties may be specified via the Configuration object
 */
@Deprecated
   public SchemaExport(Configuration configuration, Properties properties) throws HibernateException {
	final Dialect dialect = Dialect.getDialect( properties );

	Properties props = new Properties();
	props.putAll( dialect.getDefaultProperties() );
	props.putAll( properties );
	this.connectionHelper = new ManagedProviderConnectionHelper( props );

	this.sqlStatementLogger = new SqlStatementLogger( false, true );
	this.formatter = FormatStyle.DDL.getFormatter();
	this.sqlExceptionHelper = new SqlExceptionHelper();

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

	this.dropSQL = configuration.generateDropSchemaScript( dialect );
	this.createSQL = configuration.generateSchemaCreationScript( dialect );
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
private void execute(boolean script, boolean export, Writer fileOutput, Statement statement, final String sql)
		throws IOException, SQLException {
	final SqlExceptionHelper sqlExceptionHelper = new SqlExceptionHelper();

	String formatted = formatter.format( sql );
       if (delimiter != null) formatted += delimiter;
       if (script) System.out.println(formatted);
       LOG.debug(formatted);
	if ( outputFile != null ) {
		fileOutput.write( formatted + "\n" );
	}
	if ( export ) {

		statement.executeUpdate( sql );
		try {
			SQLWarning warnings = statement.getWarnings();
			if ( warnings != null) {
				sqlExceptionHelper.logAndClearWarnings( connectionHelper.getConnection() );
			}
		}
		catch( SQLException sqle ) {
               LOG.unableToLogSqlWarnings(sqle);
		}
	}

}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
@Ignore
@Test(expected = PersistenceException.class)
public void testDeleteStorageConstraintViolation() throws Exception
{
    // Create a storage unit entity that refers to a newly created storage.
    final StorageUnitEntity storageUnitEntity = storageUnitDaoTestHelper
        .createStorageUnitEntity(STORAGE_NAME, BDEF_NAMESPACE, BDEF_NAME, FORMAT_USAGE_CODE, FORMAT_FILE_TYPE_CODE, FORMAT_VERSION, PARTITION_VALUE,
            SUBPARTITION_VALUES, DATA_VERSION, LATEST_VERSION_FLAG_SET, BDATA_STATUS, STORAGE_UNIT_STATUS, NO_STORAGE_DIRECTORY_PATH);

    executeWithoutLogging(SqlExceptionHelper.class, new Command()
    {
        @Override
        public void execute()
        {
            // Delete the storage which is invalid because there still exists a storage unit entity that references it.
            StorageKey alternateKey = new StorageKey(storageUnitEntity.getStorage().getName());
            storageService.deleteStorage(alternateKey);
        }
    });
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
@Test(expected = PersistenceException.class)
public void testCreateBusinessObjectDataAttributeValueTooLarge() throws Exception
{
    final BusinessObjectDataCreateRequest businessObjectDataCreateRequest = businessObjectDataServiceTestHelper.getNewBusinessObjectDataCreateRequest();

    // Create and add a duplicate attribute which is not allowed.
    Attribute newAttribute = new Attribute();
    newAttribute.setName("Valid Name");
    newAttribute.setValue(new String(new char[4001]).replace('\0', 'A')); // Test value greater than 4000 byte limit.
    businessObjectDataCreateRequest.getAttributes().add(newAttribute);

    executeWithoutLogging(SqlExceptionHelper.class, new Command()
    {
        @Override
        public void execute()
        {
            // Create the business object data which is invalid.
            businessObjectDataService.createBusinessObjectData(businessObjectDataCreateRequest);
        }
    });
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
private void releaseConnection() throws SQLException {
	if ( connection != null ) {
		try {
			new SqlExceptionHelper().logAndClearWarnings( connection );
		}
		finally {
			try  {
				serviceRegistry.getService( ConnectionProvider.class ).closeConnection( connection );
			}
			finally {
				connection = null;
			}
		}
	}
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
public void release() throws SQLException {
	// we only release the connection
	if ( connection != null ) {
		new SqlExceptionHelper().logAndClearWarnings( connection );
		if ( toggleAutoCommit ) {
			connection.setAutoCommit( false );
		}
		provider.closeConnection( connection );
		connection = null;
	}
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
public void release() throws SQLException {
	new SqlExceptionHelper().logAndClearWarnings( connection );
	if ( toggleAutoCommit ) {
		connection.setAutoCommit( false );
	}
	connection = null;
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
public SchemaUpdate(Configuration configuration, Properties properties) throws HibernateException {
	this.configuration = configuration;
	this.dialect = Dialect.getDialect( properties );

	Properties props = new Properties();
	props.putAll( dialect.getDefaultProperties() );
	props.putAll( properties );
	this.connectionHelper = new ManagedProviderConnectionHelper( props );

	this.sqlExceptionHelper = new SqlExceptionHelper();
	this.sqlStatementLogger = new SqlStatementLogger( false, true );
	this.formatter = FormatStyle.DDL.getFormatter();
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
public DatabaseExporter(ConnectionHelper connectionHelper, SqlExceptionHelper sqlExceptionHelper) throws SQLException {
	this.connectionHelper = connectionHelper;
	this.sqlExceptionHelper = sqlExceptionHelper;

	connectionHelper.prepare( true );
	connection = connectionHelper.getConnection();
	statement = connection.createStatement();
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
public SqlExceptionHelper getSQLExceptionHelper() {
	return getJdbcServices().getSqlExceptionHelper();
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
@Test
public void testCreateBusinessObjectFormatIncorrectLatestVersion() throws Exception
{
    // Create relative database entities.
    businessObjectFormatServiceTestHelper.createTestDatabaseEntitiesForBusinessObjectFormatTesting();

    // Create a first version of the format with the latest flag set to false.
    businessObjectFormatDaoTestHelper
        .createBusinessObjectFormatEntity(NAMESPACE, BDEF_NAME, FORMAT_USAGE_CODE, FORMAT_FILE_TYPE_CODE, INITIAL_FORMAT_VERSION, FORMAT_DESCRIPTION, false,
            PARTITION_KEY);

    try
    {
        // Try to create a new format version for this format.
        final BusinessObjectFormatCreateRequest businessObjectFormatCreateRequest = businessObjectFormatServiceTestHelper
            .createBusinessObjectFormatCreateRequest(NAMESPACE, BDEF_NAME, FORMAT_USAGE_CODE, FORMAT_FILE_TYPE_CODE, PARTITION_KEY, FORMAT_DESCRIPTION,
                businessObjectDefinitionServiceTestHelper.getNewAttributes(), businessObjectFormatServiceTestHelper.getTestAttributeDefinitions(),
                businessObjectFormatServiceTestHelper.getTestSchema());
        executeWithoutLogging(SqlExceptionHelper.class, new Command()
        {
            @Override
            public void execute()
            {
                businessObjectFormatService.createBusinessObjectFormat(businessObjectFormatCreateRequest);
                fail("Should throw a PersistenceException since the latest flag does not identify the maximum format version.");
            }
        });
    }
    catch (PersistenceException e)
    {
        assertTrue(e.getMessage().contains("ConstraintViolationException: could not execute statement"));
    }
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
private void releaseConnection() throws SQLException {
    if (connection != null) {
        try {
            new SqlExceptionHelper().logAndClearWarnings(connection);
        } finally {
            try {
                serviceRegistry.getService(ConnectionProvider.class).closeConnection(connection);
            } finally {
                connection = null;
            }
        }
    }
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
@Override
public void release() throws SQLException {
    // we only release the connection
    if ( connection != null ) {
        new SqlExceptionHelper().logAndClearWarnings( connection );
        if ( toggleAutoCommit ) {
            connection.setAutoCommit( false );
        }
        provider.closeConnection( connection );
        connection = null;
    }
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
public SqlExceptionHelper getSQLExceptionHelper() {
    return sessionFactoryImplementor.getSQLExceptionHelper();
}
 

import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; //导入依赖的package包/类
protected SqlExceptionHelper getSQLExceptionHelper() {
	return sqlExceptionHelper;
}