org.dbunit.database.DatabaseConnection Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of xmlc Show documentation
old 2002 version of xmlc
The newest version!
/*
 *
 * The DbUnit Database Testing Framework
 * Copyright (C)2002-2004, DbUnit.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

package org.dbunit.database;

import java.sql.Connection;
import java.sql.SQLException;

import org.dbunit.DatabaseUnitException;
import org.dbunit.util.SQLHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This class adapts a JDBC Connection to a
 * {@link IDatabaseConnection}.
 *
 * @author Manuel Laflamme
 * @version $Revision$
 * @since Feb 21, 2002
 */
public class DatabaseConnection extends AbstractDatabaseConnection
        implements IDatabaseConnection
{

    /**
     * Logger for this class
     */
    private static final Logger logger = LoggerFactory.getLogger(DatabaseConnection.class);

    private final Connection _connection;
    private final String _schema;

    /**
     * Creates a new DatabaseConnection.
     *
     * @param connection the adapted JDBC connection
     * @throws DatabaseUnitException
     */
    public DatabaseConnection(Connection connection) throws DatabaseUnitException
    {
      this( connection, null );
    }

    /**
     * Creates a new DatabaseConnection using a specific schema.
     *
     * @param connection the adapted JDBC connection
     * @param schema the database schema. Note that the schema name is case sensitive. This
     * is necessary because schemas with the same name but different case can coexist on one
     * database. 

     * Here an example that creates two users/schemas for oracle where only the case is different:

     * 
     * create user dbunittest identified by dbunittest;
     * create user "dbunittest" identified by "dbunittest";
     * 
     * The first one creates the "default" user where everything is interpreted by oracle in uppercase.
     * The second one is completely lowercase because of the quotes.
     * @throws DatabaseUnitException 
     */
    public DatabaseConnection(Connection connection, String schema) throws DatabaseUnitException
    {
    	this(connection, schema, false);
    }

    /**
     * Creates a new DatabaseConnection using a specific schema.
     *
     * @param connection the adapted JDBC connection
     * @param schema the database schema. Note that the schema name is case sensitive. This
     * is necessary because schemas with the same name but different case can coexist on one
     * database. 

     * Here an example that creates two users/schemas for oracle where only the case is different:

     * 
     * create user dbunittest identified by dbunittest;
     * create user "dbunittest" identified by "dbunittest";
     * 
     * The first one creates the "default" user where everything is interpreted by oracle in uppercase.
     * The second one is completely lowercase because of the quotes.
     * @param validate If true an exception is thrown when the given schema
     * does not exist according to the DatabaseMetaData. If false the validation
     * will only print a warning if the schema was not found.
     * @since 2.3.0
     * @throws DatabaseUnitException If the validate parameter is true and the 
     * validation of the given connection/schema was not successful (added with 2.3.0). This can happen if the given
     * schema does not exist or if the jdbc driver does not implement the metaData.getSchemas() method properly.
     */
    public DatabaseConnection(Connection connection, String schema, boolean validate) throws DatabaseUnitException
    {
        if(connection == null)
        {
            throw new NullPointerException("The parameter 'connection' must not be null");
        }
        _connection = connection;
        
        if(schema != null)
        {
            _schema = SQLHelper.correctCase(schema, connection);
            SQLHelper.logInfoIfValueChanged(schema, _schema, "Corrected schema name:", DatabaseConnection.class);
        }
        else
        {
            _schema = null;
        }

        printConnectionInfo();
        validateSchema(validate);
    }

	////////////////////////////////////////////////////////////////////////////
    // IDatabaseConnection interface

    public Connection getConnection() throws SQLException
    {
        return _connection;
    }

    public String getSchema()
    {
        return _schema;
    }

    public void close() throws SQLException
    {
        logger.debug("close() - start");
        _connection.close();
    }
    
    
    /**
     * Prints debugging information about the current JDBC connection
     */
    private void printConnectionInfo() 
    {
    	if(logger.isDebugEnabled()) 
    	{
        	try {
    			logger.debug("Database connection info: " + SQLHelper.getDatabaseInfo(_connection.getMetaData()));
    		} 
        	catch (SQLException e) {
    			logger.warn("Exception while trying to retrieve database info from connection", e);
    		}
    	}
	}

    /**
     * Validates if the database schema exists for this connection.
     * @param validateStrict If true an exception is thrown when the given schema
     * does not exist according to the DatabaseMetaData. If false the validation
     * will only print a warning if the schema was not found.
     * @throws DatabaseUnitException
     */
    private void validateSchema(boolean validateStrict) throws DatabaseUnitException
    {
    	if(logger.isDebugEnabled())
    		logger.debug("validateSchema(validateStrict={}) - start", String.valueOf(validateStrict));
        
        if(this._schema == null)
        {
            logger.debug("Schema is null. Nothing to validate.");
            return;
        }
        
        try
        {
            boolean schemaExists = SQLHelper.schemaExists(this._connection, this._schema);
            if(!schemaExists)
            {
            	// Under certain circumstances the cause might be that the JDBC driver
				// implementation of 'DatabaseMetaData.getSchemas()' is not correct 
            	// (known issue of MySQL driver).
            	String msg = "The given schema '" + this._schema + "' does not exist.";
            	// If strict validation is wished throw an exception
            	if(validateStrict)
            		throw new DatabaseUnitException(msg);
            	else
            		logger.warn(msg);
            }
        }
        catch(SQLException e)
        {
            throw new DatabaseUnitException("Exception while checking the schema for validity", e);
        }
    }
    
    public String toString()
    {
        StringBuffer sb = new StringBuffer();
        sb.append(getClass().getName()).append("[");
        sb.append("schema=").append(_schema);
        sb.append(", connection=").append(_connection);
        sb.append(", super=").append(super.toString());
        sb.append("]");
        return sb.toString();
    }
}