DAOUtil.java

/*
 * Copyright (c) 2002-2022, City of Paris
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice
 *     and the following disclaimer.
 *
 *  2. Redistributions in binary form must reproduce the above copyright notice
 *     and the following disclaimer in the documentation and/or other materials
 *     provided with the distribution.
 *
 *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * License 1.0
 */
package fr.paris.lutece.util.sql;

import fr.paris.lutece.portal.service.database.AppConnectionService;
import fr.paris.lutece.portal.service.database.PluginConnectionService;
import fr.paris.lutece.portal.service.plugin.Plugin;
import fr.paris.lutece.portal.service.util.AppException;
import fr.paris.lutece.portal.service.util.AppLogService;
import fr.paris.lutece.portal.service.util.NoDatabaseException;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.jdbc.datasource.DataSourceUtils;

import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

import javax.sql.DataSource;

/**
 * Prepared statement util class
 *
 * @since version 1.3
 */
public class DAOUtil implements AutoCloseable
{
    public static final String MSG_EXCEPTION_SELECT_ERROR = "Error selecting row id : ";
    private static final String DEFAULT_MODULE_NAME = "lutece";
    private static final String LOGGER_DEBUG_SQL = "lutece.debug.sql.";

    /** Connection Service providing connection from a defined pool */
    private PluginConnectionService _connectionService;

    /** JDBC Connection */
    private Connection _connection;
    private List<Array> _arrays;

    /** Plugin name */
    private String _strPluginName;

    /** Prepared statement */
    private PreparedStatement _statement;

    /** result set */
    private ResultSet _resultSet;

    /**
     * GeneratedKeys ResultSet (optional, only when _autoGeneratedKeys is Statement.RETURN_GENERATED_KEYS)
     */
    private Integer _autoGeneratedKeys;
    private ResultSet _generatedKeysResultSet;

    /** True if SQL request are logged */
    private boolean _bReleased;
    private String _strSQL;
    private boolean _bTransactionnal;
    private boolean _bLogQueries;

    /** The debug logger */
    private Logger _logger;
    private StringBuilder _sbLogs = new StringBuilder( );

    /**
     * Creates a new DAOUtil object.
     *
     * @param sql
     *            Sql Query for prepared Statement
     */
    public DAOUtil( String sql )
    {
        this( sql, null, null, true );
    }

    /**
     * Creates a new DAOUtil object.
     *
     * @param sql
     *            Sql Query for prepared Statement
     */
    public DAOUtil( String sql, boolean logQueries )
    {
        this( sql, null, null, logQueries );
    }

    /**
     * Creates a new DAOUtil object.
     *
     * @param strSQL
     *            sql query for prepared Statement
     * @param plugin
     *            The plugin using this database access
     */
    public DAOUtil( String strSQL, Plugin plugin )
    {
        this( strSQL, null, plugin, true );
    }

    /**
     * Creates a new DAOUtil object.
     *
     * @param strSQL
     *            sql query for prepared Statement
     * @param plugin
     *            The plugin using this database access
     */
    public DAOUtil( String strSQL, Plugin plugin, boolean bLogQueries )
    {
        this( strSQL, null, plugin, bLogQueries );
    }

    /**
     * Creates a new DAOUtil object.
     *
     * @since 6.0.0
     * @param sql
     *            Sql Query for prepared Statement
     * @param autoGeneratedKeys
     *            a flag indicating whether auto-generated keys should be returned; For example one of <code>Statement.RETURN_GENERATED_KEYS</code> or
     *            <code>Statement.NO_GENERATED_KEYS</code>. See {@link PreparedStatement#prepareStatement(String, int)}
     */
    public DAOUtil( String sql, Integer autoGeneratedKeys )
    {
        this( sql, autoGeneratedKeys, null, true );
    }

    /**
     * Creates a new DAOUtil object.
     *
     * @since 6.0.0
     * @param strSQL
     *            sql query for prepared Statement
     * @param autoGeneratedKeys
     *            a flag indicating whether auto-generated keys should be returned; For example one of <code>Statement.RETURN_GENERATED_KEYS</code> or
     *            <code>Statement.NO_GENERATED_KEYS</code>. See {@link PreparedStatement#prepareStatement(String, int)}
     * @param plugin
     *            The plugin using this database access
     */
    public DAOUtil( String strSQL, Integer autoGeneratedKeys, Plugin plugin )
    {
        this( strSQL, autoGeneratedKeys, plugin, true );
    }

    /**
     * Creates a new DAOUtil object.
     *
     * @param bLogQueries
     * @since 6.0.0
     * @param strSQL
     *            sql query for prepared Statement
     * @param autoGeneratedKeys
     *            a flag indicating whether auto-generated keys should be returned; For example one of <code>Statement.RETURN_GENERATED_KEYS</code> or
     *            <code>Statement.NO_GENERATED_KEYS</code>. See {@link PreparedStatement#prepareStatement(String, int)}
     * @param plugin
     *            The plugin using this database access
     */
    public DAOUtil( String strSQL, Integer autoGeneratedKeys, Plugin plugin, boolean bLogQueries )
    {
        _bReleased = false;
        _strSQL = strSQL;
        _autoGeneratedKeys = autoGeneratedKeys;
        _bLogQueries = bLogQueries;

        loadPlugin( plugin );

        // Use the logger name "lutece.debug.sql.<plugin_name>" to filter logs by
        // plugins
        _logger = LogManager.getLogger( LOGGER_DEBUG_SQL + _strPluginName );

        if ( _logger.isDebugEnabled( ) )
        {
            log( "Module : '" + _strPluginName + "' - SQL Statement : " + ( _bLogQueries ? _strSQL : "(query log disabled)" ) );
        }

        try
        {
            MultiPluginTransaction transaction = TransactionManager.getCurrentTransaction( plugin );

            if ( transaction != null )
            {
                _bTransactionnal = true;
            }
            else
            {
                // We check if there is a managed transaction to get the transactionnal
                // connection
                if ( TransactionSynchronizationManager.isSynchronizationActive( ) )
                {
                    _bTransactionnal = true;

                    DataSource ds = AppConnectionService.getPoolManager( ).getDataSource( _connectionService.getPoolName( ) );
                    _connection = DataSourceUtils.getConnection( ds );

                    if ( _logger.isDebugEnabled( ) )
                    {
                        _logger.debug( "Transactionnal context is used for pool " + _connectionService.getPoolName( ) );
                    }
                }
                else
                {
                    // no transaction found, use the connection service directly
                    _connection = _connectionService.getConnection( );
                }
            }

            createStatement( transaction );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    private void createStatement( MultiPluginTransaction transaction ) throws SQLException
    {
        if ( transaction != null )
        {
            if ( _autoGeneratedKeys != null )
            {
                _statement = transaction.prepareStatement( _strSQL, _autoGeneratedKeys, _bLogQueries );
            }
            else
            {
                _statement = transaction.prepareStatement( _strSQL, _bLogQueries );
            }
        }
        else
            if ( _connection != null )
            {
                if ( _autoGeneratedKeys != null )
                {
                    _statement = _connection.prepareStatement( _strSQL, _autoGeneratedKeys );
                }
                else
                {
                    _statement = _connection.prepareStatement( _strSQL );
                }
            }
            else
            {
                throw new AppException( "Database access error for component '" + _strPluginName + "'. Please check plugin installation and db.properties." );
            }
    }

    private void loadPlugin( Plugin plugin )
    {
        if ( plugin != null )
        {
            _strPluginName = plugin.getName( );
            _connectionService = plugin.getConnectionService( );
        }
        else
        {
            _strPluginName = DEFAULT_MODULE_NAME;
            _connectionService = AppConnectionService.getDefaultConnectionService( );
        }

        if ( _connectionService == null )
        {
            throw new NoDatabaseException( "Database access error. Please check component installations and db.properties." );
        }
    }

    /**
     * Build a formatted error message for a given exception
     * 
     * @param e
     *            The exception
     * @return The error message
     */
    private String getErrorMessage( Exception e )
    {
        StringBuilder sbError = new StringBuilder( "DAOUtil error : " );
        sbError.append( e.getMessage( ) );
        sbError.append( " - SQL statement : " );
        sbError.append( " - Plugin : " );
        sbError.append( _strPluginName );

        return sbError.toString( );
    }

    /**
     * Executes the update request and throws an error if the result is not 1
     */
    public void executeUpdate( )
    {
        try
        {
            _statement.executeUpdate( );
            if ( _autoGeneratedKeys != null && _autoGeneratedKeys.equals( Statement.RETURN_GENERATED_KEYS ) )
            {
                _generatedKeysResultSet = _statement.getGeneratedKeys( );
            }
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Executes a query
     */
    public void executeQuery( )
    {
        try
        {
            _resultSet = _statement.executeQuery( );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Log a message
     * 
     * @param strMessage
     *            The message to log
     */
    private void log( String strMessage )
    {
        if ( _logger.isDebugEnabled( ) )
        {
            _sbLogs.append( strMessage );
        }
    }

    /**
     * Log a parameter
     * 
     * @param oName
     *            The parameter name
     * @param oValue
     *            The parameter value
     */
    private void logParameter( Object oName, Object oValue )
    {
        if ( _logger.isDebugEnabled( ) )
        {
            Object [ ] args = {
                    oName, oValue
            };
            log( MessageFormat.format( "\n               Index : ''{0}''       Value : ''{1}'' ", args ) );
        }
    }

    /**
     * Free connection
     */
    public final void free( )
    {
        if ( !_bReleased )
        {
            _logger.debug( _sbLogs );
        }

        try
        {
            // Close statement if necessary
            if ( _statement != null )
            {
                _statement.close( );
            }
            if ( _arrays != null )
            {
                for ( Array array : _arrays )
                {
                    array.free( );
                }
            }
        }
        catch( SQLException e )
        {
            throw new AppException( e.getMessage( ), e );
        }
        finally
        {
            // Free the connection - the connection is freed some other way in
            // transactionnal context.
            if ( ( _connectionService != null ) && !_bTransactionnal )
            {
                _connectionService.freeConnection( _connection );
                _connectionService = null;
            }

            _bReleased = true;
        }
    }

    /**
     * Indicates whether the cursor is on the last row of this ResultSet object.
     * 
     * @return true if the cursor is on the last row; false otherwise
     */
    public boolean isLast( )
    {
        try
        {
            return _resultSet.isLast( );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a date value
     *
     * @param nIndex
     *            parameter index
     * @param date
     *            date value
     */
    public void setDate( int nIndex, Date date )
    {
        try
        {
            _statement.setDate( nIndex, date );
            logParameter( nIndex, date );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a date value
     *
     * @see PreparedStatement#setDate(int, Date, Calendar)
     * @since 5.1.1
     * @param nIndex
     *            parameter index
     * @param date
     *            date value
     * @param calendar
     *            the calendar
     */
    public void setDate( int nIndex, Date date, Calendar calendar )
    {
        try
        {
            _statement.setDate( nIndex, date, calendar );
            logParameter( nIndex, date );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a time value
     *
     * @param nIndex
     *            parameter index
     * @param time
     *            time value
     */
    public void setTime( int nIndex, Time time )
    {
        try
        {
            _statement.setTime( nIndex, time );
            logParameter( nIndex, time );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a time value
     *
     * @see PreparedStatement#setTime(int, Time, Calendar)
     * @since 5.1.1
     * @param nIndex
     *            parameter index
     * @param time
     *            time value
     * @param calendar
     *            the calendat
     */
    public void setTime( int nIndex, Time time, Calendar calendar )
    {
        try
        {
            _statement.setTime( nIndex, time, calendar );
            logParameter( nIndex, time );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a binary value stream
     * 
     * @param nIndex
     *            parameter index
     * @param iStream
     *            the java input stream which contains the binary parameter value
     * @param nBlength
     *            the number of bytes in the stream
     */
    public void setBinaryStream( int nIndex, InputStream iStream, int nBlength )
    {
        try
        {
            _statement.setBinaryStream( nIndex, iStream, nBlength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a binary value stream
     * 
     * @see PreparedStatement#setBinaryStream(int, InputStream, long)
     * @since 5.1.1
     * @param nIndex
     *            parameter index
     * @param iStream
     *            the java input stream which contains the binary parameter value
     * @param nBlength
     *            the number of bytes in the stream
     */
    public void setBinaryStream( int nIndex, InputStream iStream, long nBlength )
    {
        try
        {
            _statement.setBinaryStream( nIndex, iStream, nBlength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a binary value stream
     * 
     * @see PreparedStatement#setBinaryStream(int, InputStream)
     * @since 5.1.1
     * @param nIndex
     *            parameter index
     * @param iStream
     *            the java input stream which contains the binary parameter value
     */
    public void setBinaryStream( int nIndex, InputStream iStream )
    {
        try
        {
            _statement.setBinaryStream( nIndex, iStream );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets a binary stream from a resultSet
     *
     * @param nIndex
     *            column index
     * @return InputStream instance
     */
    public InputStream getBinaryStream( int nIndex )
    {
        try
        {
            return _resultSet.getBinaryStream( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets a blob from a resultset
     *
     * @param nIndex
     *            column index
     * @return Blob instance
     */
    public Blob getBlob( int nIndex )
    {
        try
        {
            return _resultSet.getBlob( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets a blob from a resultset
     *
     * @param strColumnName
     *            column name
     *
     * @return Blob instance
     */
    public Blob getBlob( String strColumnName )
    {
        try
        {
            return _resultSet.getBlob( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a blob value from a stream
     * 
     * @see PreparedStatement#setBlob(int, InputStream)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the value
     */
    public void setBlob( int nIndex, InputStream stream )
    {
        try
        {
            _statement.setBlob( nIndex, stream );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a blob value from a stream
     * 
     * @see PreparedStatement#setBlob(int, InputStream, long)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the value
     * @param nLength
     *            the number of bytes to read
     */
    public void setBlob( int nIndex, InputStream stream, long nLength )
    {
        try
        {
            _statement.setBlob( nIndex, stream, nLength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a blob value
     * 
     * @see PreparedStatement#setBlob(int, InputStream)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param blob
     *            the value
     */
    public void setBlob( int nIndex, Blob blob )
    {
        try
        {
            _statement.setBlob( nIndex, blob );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets a byte array from a resultset
     *
     * @param nIndex
     *            column index
     *
     * @return byte[] instance
     */
    public byte [ ] getBytes( int nIndex )
    {
        try
        {
            return _resultSet.getBytes( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets a byte array from a resultset
     *
     * @param strColumnName
     *            column name
     *
     * @return byte[] instance
     */
    public byte [ ] getBytes( String strColumnName )
    {
        try
        {
            return _resultSet.getBytes( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets a byte from a resultset
     *
     * @see ResultSet#getByte(int)
     * @since 5.1.1
     * @param nIndex
     *            column index
     * @return byte instance
     */
    public byte getByte( int nIndex )
    {
        try
        {
            return _resultSet.getByte( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets a byte from a resultset
     *
     * @see ResultSet#getByte(int)
     * @since 5.1.1
     * @param strColumnName
     *            column name
     * @return byte instance
     */
    public byte getByte( String strColumnName )
    {
        try
        {
            return _resultSet.getByte( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a int value
     *
     * @param nIndex
     *            parameter index in the prepared statement
     * @param nValue
     *            int value
     */
    public void setInt( int nIndex, int nValue )
    {
        try
        {
            _statement.setInt( nIndex, nValue );
            logParameter( nIndex, nValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a Boolean value
     *
     * @param nIndex
     *            parameter index in the prepared statement
     * @param bValue
     *            Boolean value
     */
    public void setBoolean( int nIndex, boolean bValue )
    {
        try
        {
            _statement.setInt( nIndex, ( bValue ) ? 1 : 0 );
            logParameter( nIndex, bValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a byte value
     * 
     * @see PreparedStatement#setByte(int, byte)
     * @since 5.1.1
     * @param nIndex
     *            parameter index in the prepared statement
     * @param bValue
     *            byte value
     */
    public void setByte( int nIndex, byte bValue )
    {
        try
        {
            _statement.setByte( nIndex, bValue );
            logParameter( nIndex, bValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a byte array value
     *
     * @param nIndex
     *            parameter index in the prepared statement
     * @param tbValue
     *            byte array value
     */
    public void setBytes( int nIndex, byte [ ] tbValue )
    {
        try
        {
            _statement.setBytes( nIndex, tbValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a string value
     *
     * @param nIndex
     *            parameter index in the prepared statement
     * @param strValue
     *            string value
     */
    public void setString( int nIndex, String strValue )
    {
        try
        {
            _statement.setString( nIndex, strValue );
            logParameter( nIndex, strValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a timestamp value
     *
     * @param nIndex
     *            parameter index in the prepared statement
     * @param ts
     *            timestamp value
     */
    public void setTimestamp( int nIndex, Timestamp ts )
    {
        try
        {
            _statement.setTimestamp( nIndex, ts );
            logParameter( nIndex, ts );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a timestamp value
     *
     * @see PreparedStatement#setTimestamp(int, Timestamp, Calendar)
     * @since 5.1.1
     * @param nIndex
     *            parameter index in the prepared statement
     * @param ts
     *            timestamp value
     * @param calendar
     *            the calendar
     */
    public void setTimestamp( int nIndex, Timestamp ts, Calendar calendar )
    {
        try
        {
            _statement.setTimestamp( nIndex, ts, calendar );
            logParameter( nIndex, ts );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a double value
     * 
     * @param nIndex
     *            parameter index in the prepared statement
     * @param dValue
     *            The value
     */
    public void setDouble( int nIndex, double dValue )
    {
        try
        {
            _statement.setDouble( nIndex, dValue );
            logParameter( nIndex, dValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Sets null value for a "double" column
     * 
     * @param nIndex
     *            the index
     */
    public void setDoubleNull( int nIndex )
    {
        try
        {
            _statement.setNull( nIndex, Types.DOUBLE );
            logParameter( nIndex, "null" );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language.
     *
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is null
     */
    public Date getDate( int nIndex )
    {
        try
        {
            return _resultSet.getDate( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language.
     *
     * @param strColumnName
     *            name of the column, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is null
     */
    public Date getDate( String strColumnName )
    {
        try
        {
            return _resultSet.getDate( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language.
     *
     * @see ResultSet#getDate(int, Calendar)
     * @since 5.1.1
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     * @param calendar
     *            the calendar
     * @return the column value; if the value is SQL NULL, the value returned is null
     */
    public Date getDate( int nIndex, Calendar calendar )
    {
        try
        {
            return _resultSet.getDate( nIndex, calendar );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language.
     *
     * @see ResultSet#getDate(String, Calendar)
     * @since 5.1.1
     * @param strColumnName
     *            name of the column, ...
     * @param calendar
     *            the calendar
     * @return the column value; if the value is SQL NULL, the value returned is null
     */
    public Date getDate( String strColumnName, Calendar calendar )
    {
        try
        {
            return _resultSet.getDate( strColumnName, calendar );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language.
     *
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is null
     */
    public Time getTime( int nIndex )
    {
        try
        {
            return _resultSet.getTime( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language.
     *
     * @param strColumnName
     *            name of the column, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is null
     */
    public Time getTime( String strColumnName )
    {
        try
        {
            return _resultSet.getTime( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language.
     *
     * @see ResultSet#getTime(int, Calendar)
     * @since 5.1.1
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     * @param calendar
     *            the calendar
     * @return the column value; if the value is SQL NULL, the value returned is null
     */
    public Time getTime( int nIndex, Calendar calendar )
    {
        try
        {
            return _resultSet.getTime( nIndex, calendar );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language.
     *
     * @see ResultSet#getTime(String, Calendar)
     * @since 5.1.1
     * @param strColumnName
     *            name of the column, ...
     * @param calendar
     *            the calendar
     * @return the column value; if the value is SQL NULL, the value returned is null
     */
    public Time getTime( String strColumnName, Calendar calendar )
    {
        try
        {
            return _resultSet.getTime( strColumnName, calendar );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a int
     *
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is 0
     */
    public int getInt( int nIndex )
    {
        try
        {
            return _resultSet.getInt( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a int
     *
     * @param strColumnName
     *            column name
     *
     * @return the column value; if the value is SQL NULL, the value returned is 0
     */
    public int getInt( String strColumnName )
    {
        try
        {
            return _resultSet.getInt( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a Boolean
     *
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is FALSE
     */
    public boolean getBoolean( int nIndex )
    {
        try
        {
            return ( _resultSet.getInt( nIndex ) != 0 );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a Boolean
     *
     * @param strColumnName
     *            column name
     *
     * @return the column value; if the value is SQL NULL, the value returned is FALSE
     */
    public boolean getBoolean( String strColumnName )
    {
        try
        {
            return ( _resultSet.getInt( strColumnName ) != 0 );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a string
     *
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public String getString( int nIndex )
    {
        try
        {
            return _resultSet.getString( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a string
     *
     * @param strColumnName
     *            column name
     *
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public String getString( String strColumnName )
    {
        try
        {
            return _resultSet.getString( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a timestamp
     *
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public Timestamp getTimestamp( int nIndex )
    {
        try
        {
            return _resultSet.getTimestamp( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a Timestamp
     *
     * @param strColumnName
     *            column name
     *
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public Timestamp getTimestamp( String strColumnName )
    {
        try
        {
            return _resultSet.getTimestamp( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a timestamp
     *
     * @see ResultSet#getTimestamp(int, Calendar)
     * @since 5.1.1
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     * @param calendar
     *            the calendar
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public Timestamp getTimestamp( int nIndex, Calendar calendar )
    {
        try
        {
            return _resultSet.getTimestamp( nIndex, calendar );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a Timestamp
     *
     * @see ResultSet#getTimestamp(String, Calendar)
     * @since 5.1.1
     * @param strColumnName
     *            column name
     * @param calendar
     *            the calendar
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public Timestamp getTimestamp( String strColumnName, Calendar calendar )
    {
        try
        {
            return _resultSet.getTimestamp( strColumnName, calendar );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a double
     * 
     * @param strColumnName
     *            column name
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public double getDouble( String strColumnName )
    {
        try
        {
            return _resultSet.getDouble( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a double
     * 
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is 0
     */
    public double getDouble( int nIndex )
    {
        try
        {
            return _resultSet.getDouble( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a Object
     *
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public Object getObject( int nIndex )
    {
        try
        {
            return _resultSet.getObject( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a T
     *
     * @see ResultSet#getObject(int, Class)
     * @since 5.1.1
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     * @param type
     *            the type
     * @param <T>
     *            the return type
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public <T> T getObject( int nIndex, Class<T> type )
    {
        try
        {
            return _resultSet.getObject( nIndex, type );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as a Object
     *
     * @see ResultSet#getObject(int, java.util.Map)
     * @since 5.1.1
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     * @param map
     *            the type map
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public Object getObject( int nIndex, java.util.Map<String, Class<?>> map )
    {
        try
        {
            return _resultSet.getObject( nIndex, map );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get the ResultSet
     * 
     * @return the resultSet
     */
    public ResultSet getResultSet( )
    {
        return _resultSet;
    }

    /**
     * Get the GeneratedKeys ResultSet
     *
     * @since 6.0.0
     * @return the GeneratedKeys ResultSet
     */
    public ResultSet getGeneratedKeysResultSet( )
    {
        return _generatedKeysResultSet;
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as an Object
     *
     * @param strColumnName
     *            column name
     *
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public Object getObject( String strColumnName )
    {
        try
        {
            return _resultSet.getObject( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as an Object
     *
     * @see ResultSet#getObject(String, Class)
     * @since 5.1.1
     * @param strColumnName
     *            column name
     * @param type
     *            the type
     * @param <T>
     *            the return type
     *
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public <T> T getObject( String strColumnName, Class<T> type )
    {
        try
        {
            return _resultSet.getObject( strColumnName, type );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this ResultSet object as an Object
     *
     * @see ResultSet#getObject(String, java.util.Map)
     * @since 5.1.1
     * @param strColumnName
     *            column name
     * @param map
     *            type map
     * @return the column value; if the value is SQL NULL, the value returned is NULL
     */
    public Object getObject( String strColumnName, java.util.Map<String, Class<?>> map )
    {
        try
        {
            return _resultSet.getObject( strColumnName, map );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Moves the cursor down one row from its current position in the ResultSet.
     *
     * @return true if the new current row is valid; false if there are no more rows
     */
    public boolean next( )
    {
        try
        {
            return _resultSet.next( );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Moves the cursor down one row from its current position in the GeneratedKeys ResultSet.
     *
     * @since 6.0.0
     * @return true if the new current row is valid; false if there are no more rows
     */
    public boolean nextGeneratedKey( )
    {
        try
        {
            return _generatedKeysResultSet.next( );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this GeneratedKeys ResultSet object as a byte
     *
     * @since 6.0.0
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is 0
     */
    public byte getGeneratedKeyByte( int nIndex )
    {
        try
        {
            return _generatedKeysResultSet.getByte( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this GeneratedKeys ResultSet object as a short
     *
     * @since 6.0.0
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is 0
     */
    public short getGeneratedKeyShort( int nIndex )
    {
        try
        {
            return _generatedKeysResultSet.getShort( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this GeneratedKeys ResultSet object as a int
     *
     * @since 6.0.0
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is 0
     */
    public int getGeneratedKeyInt( int nIndex )
    {
        try
        {
            return _generatedKeysResultSet.getInt( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this GeneratedKeys ResultSet object as a long
     *
     * @since 6.0.0
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is 0
     */
    public long getGeneratedKeyLong( int nIndex )
    {
        try
        {
            return _generatedKeysResultSet.getLong( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the value of the designated column in the current row of this GeneratedKeys ResultSet object as a BigDecimal
     *
     * @since 6.0.0
     * @param nIndex
     *            the first column is 1, the second is 2, ...
     *
     * @return the column value; if the value is SQL NULL, the value returned is 0
     */
    public BigDecimal getGeneratedKeyBigDecimal( int nIndex )
    {
        try
        {
            return _generatedKeysResultSet.getBigDecimal( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a int null value
     * 
     * @param nIndex
     *            parameter index
     */
    public void setIntNull( int nIndex )
    {
        try
        {
            _statement.setNull( nIndex, Types.INTEGER );
            logParameter( nIndex, "null" );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Sets null value for a "long" column
     * 
     * @param nIndex
     *            the index
     */
    public void setLongNull( int nIndex )
    {
        try
        {
            _statement.setNull( nIndex, Types.BIGINT );
            logParameter( nIndex, "null" );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Sets a long value
     * 
     * @param nIndex
     *            the index
     * @param lValue
     *            the value
     */
    public void setLong( int nIndex, long lValue )
    {
        try
        {
            _statement.setLong( nIndex, lValue );
            logParameter( nIndex, lValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the long value
     * 
     * @param nIndex
     *            the index
     * @return the long value
     */
    public long getLong( int nIndex )
    {
        try
        {
            return _resultSet.getLong( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Gets the long value
     * 
     * @param strColumnName
     *            the column name
     * @return the long value
     */
    public long getLong( String strColumnName )
    {
        try
        {
            return _resultSet.getLong( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Set an Array value
     *
     * @see Connection#createArrayOf(String, Object[])
     * @see PreparedStatement#setArray(int, Array)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param strTypename
     *            the type SQL name
     * @param elements
     *            the array value
     */
    public void setArray( int nIndex, String strTypename, Object [ ] elements )
    {
        try
        {
            Array x = _connection.createArrayOf( strTypename, elements );
            registerArray( x );
            _statement.setArray( nIndex, x );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Register an SQL Array to be able to free it later
     * 
     * @param array
     *            the array to register
     */
    private void registerArray( Array array )
    {
        if ( _arrays == null )
        {
            _arrays = new ArrayList<>( );
        }
        _arrays.add( array );
    }

    /**
     * Get an Array value
     * 
     * @see ResultSet#getArray(int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @return the array value
     */
    public Array getArray( int nIndex )
    {
        try
        {
            Array res = _resultSet.getArray( nIndex );
            registerArray( res );
            return res;
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get an Array value
     * 
     * @see ResultSet#getArray(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the array value
     */
    public Array getArray( String strColumnName )
    {
        try
        {
            Array res = _resultSet.getArray( strColumnName );
            registerArray( res );
            return res;
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with an ascii value stream
     * 
     * @see PreparedStatement#setAsciiStream(int, InputStream)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the stream
     */
    public void setAsciiStream( int nIndex, InputStream stream )
    {
        try
        {
            _statement.setAsciiStream( nIndex, stream );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with an ascii value stream
     * 
     * @see PreparedStatement#setAsciiStream(int, InputStream, int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the stream
     * @param nLength
     *            the number of bytes to read
     */
    public void setAsciiStream( int nIndex, InputStream stream, int nLength )
    {
        try
        {
            _statement.setAsciiStream( nIndex, stream, nLength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with an ascii value stream
     * 
     * @see PreparedStatement#setAsciiStream(int, InputStream, long)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the stream
     * @param lLength
     *            the number of bytes to read
     */
    public void setAsciiStream( int nIndex, InputStream stream, long lLength )
    {
        try
        {
            _statement.setAsciiStream( nIndex, stream, lLength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get an ascii value stream
     * 
     * @see ResultSet#getAsciiStream(int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @return the ascii stream
     */
    public InputStream getAsciiString( int nIndex )
    {
        try
        {
            return _resultSet.getAsciiStream( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get an ascii value stream
     * 
     * @see ResultSet#getAsciiStream(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the ascii stream
     */
    public InputStream getAsciiString( String strColumnName )
    {
        try
        {
            return _resultSet.getAsciiStream( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared Statement with a BigDecimal value
     * 
     * @see PreparedStatement#setBigDecimal(int, BigDecimal)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param value
     *            the value
     */
    public void setBigDecimal( int nIndex, BigDecimal value )
    {
        try
        {
            _statement.setBigDecimal( nIndex, value );
            logParameter( nIndex, value );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a BigDecimal value
     * 
     * @see ResultSet#getBigDecimal(int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @return the value
     */
    public BigDecimal getBigDecimal( int nIndex )
    {
        try
        {
            return _resultSet.getBigDecimal( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a BigDecimal value
     * 
     * @see ResultSet#getBigDecimal(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the value
     */
    public BigDecimal getBigDecimal( String strColumnName )
    {
        try
        {
            return _resultSet.getBigDecimal( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a character stream
     *
     * @see PreparedStatement#setCharacterStream(int, Reader)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the stream
     */
    public void setCharacterStream( int nIndex, Reader stream )
    {
        try
        {
            _statement.setCharacterStream( nIndex, stream );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a character stream
     *
     * @see PreparedStatement#setCharacterStream(int, Reader, int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the stream
     * @param nLength
     *            the number of bytes to read
     */
    public void setCharacterStream( int nIndex, Reader stream, int nLength )
    {
        try
        {
            _statement.setCharacterStream( nIndex, stream, nLength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a character stream
     *
     * @see PreparedStatement#setCharacterStream(int, Reader, long)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the stream
     * @param nLength
     *            the number of bytes to read
     */
    public void setCharacterStream( int nIndex, Reader stream, long nLength )
    {
        try
        {
            _statement.setCharacterStream( nIndex, stream, nLength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a character stream value
     *
     * @see ResultSet#getCharacterStream(int)
     * @since 5.1.1
     * @param nIndex
     *            the column index
     * @return the stream value
     */
    public Reader getCharacterStream( int nIndex )
    {
        try
        {
            return _resultSet.getCharacterStream( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a character stream value
     *
     * @see ResultSet#getCharacterStream(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column index
     * @return the stream value
     */
    public Reader getCharacterStream( String strColumnName )
    {
        try
        {
            return _resultSet.getCharacterStream( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a Clob stream
     *
     * @see PreparedStatement#setClob(int, Reader)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the value
     */
    public void setClob( int nIndex, Reader stream )
    {
        try
        {
            _statement.setClob( nIndex, stream );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a Clob stream
     *
     * @see PreparedStatement#setClob(int, Reader, long)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the value
     * @param nLength
     *            the number of bytes to read
     */
    public void setClob( int nIndex, Reader stream, long nLength )
    {
        try
        {
            _statement.setClob( nIndex, stream, nLength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a Clob
     *
     * @see PreparedStatement#setClob(int, Clob)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param clob
     *            the value
     */
    public void setClob( int nIndex, Clob clob )
    {
        try
        {
            _statement.setClob( nIndex, clob );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a Clob value
     *
     * @see ResultSet#getClob(int)
     * @since 5.1.1
     * @param nIndex
     *            the column index
     * @return the value
     */
    public Clob getClob( int nIndex )
    {
        try
        {
            return _resultSet.getClob( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a Clob value
     *
     * @see ResultSet#getClob(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column index
     * @return the value
     */
    public Clob getClob( String strColumnName )
    {
        try
        {
            return _resultSet.getClob( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a NClob stream
     *
     * @see PreparedStatement#setNClob(int, Reader)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the value
     */
    public void setNClob( int nIndex, Reader stream )
    {
        try
        {
            _statement.setNClob( nIndex, stream );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a NClob stream
     *
     * @see PreparedStatement#setNClob(int, Reader, long)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the value
     * @param nLength
     *            the number of bytes to read
     */
    public void setNClob( int nIndex, Reader stream, long nLength )
    {
        try
        {
            _statement.setNClob( nIndex, stream, nLength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a NClob
     *
     * @see PreparedStatement#setNClob(int, NClob)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param clob
     *            the value
     */
    public void setClob( int nIndex, NClob clob )
    {
        try
        {
            _statement.setNClob( nIndex, clob );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a NClob value
     *
     * @see ResultSet#getNClob(int)
     * @since 5.1.1
     * @param nIndex
     *            the column index
     * @return the value
     */
    public NClob getNClob( int nIndex )
    {
        try
        {
            return _resultSet.getNClob( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a Clob value
     *
     * @see ResultSet#getClob(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column index
     * @return the value
     */
    public NClob getNClob( String strColumnName )
    {
        try
        {
            return _resultSet.getNClob( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a float value
     *
     * @see PreparedStatement#setFloat(int, float)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param fValue
     *            the value
     */
    public void setFloat( int nIndex, float fValue )
    {
        try
        {
            _statement.setFloat( nIndex, fValue );
            logParameter( nIndex, fValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a float value
     *
     * @see ResultSet#getFloat(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the value
     */
    public float getFloat( String strColumnName )
    {
        try
        {
            return _resultSet.getFloat( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a float value
     *
     * @see ResultSet#getFloat(int)
     * @since 5.1.1
     * @param nIndex
     *            the column index
     * @return the value
     */
    public float getFloat( int nIndex )
    {
        try
        {
            return _resultSet.getFloat( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a character stream value
     *
     * @see PreparedStatement#setNCharacterStream(int, Reader)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the stream
     */
    public void setNCharacterStream( int nIndex, Reader stream )
    {
        try
        {
            _statement.setNCharacterStream( nIndex, stream );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a character stream value
     *
     * @see PreparedStatement#setNCharacterStream(int, Reader, long)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param stream
     *            the stream
     * @param nLength
     *            the number of characters to read
     */
    public void setNCharacterStream( int nIndex, Reader stream, long nLength )
    {
        try
        {
            _statement.setNCharacterStream( nIndex, stream, nLength );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a character stream value
     *
     * @see ResultSet#getNCharacterStream(int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @return the stream
     */
    public Reader getNCharacterStream( int nIndex )
    {
        try
        {
            return _resultSet.getNCharacterStream( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a character stream value
     *
     * @see ResultSet#getNCharacterStream(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the stream
     */
    public Reader getNCharacterStream( String strColumnName )
    {
        try
        {
            return _resultSet.getNCharacterStream( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a String value
     *
     * @see PreparedStatement#setNString(int, String)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param strValue
     *            the value
     */
    public void setNString( int nIndex, String strValue )
    {
        try
        {
            _statement.setNString( nIndex, strValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a String value
     *
     * @see ResultSet#getNString(int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @return the String
     */
    public String getNString( int nIndex )
    {
        try
        {
            return _resultSet.getNString( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a Stringvalue
     *
     * @see ResultSet#getNString(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the stream
     */
    public String getNString( String strColumnName )
    {
        try
        {
            return _resultSet.getNString( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a null value
     *
     * @see PreparedStatement#setNull(int, int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param nType
     *            the SQL type code defined in java.sql.Types
     */
    public void setNull( int nIndex, int nType )
    {
        try
        {
            _statement.setNull( nIndex, nType );
            logParameter( nIndex, "null" );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a null value
     *
     * @see PreparedStatement#setNull(int, int, String)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param nType
     *            the SQL type code defined in java.sql.Types
     * @param strTypeName
     *            the type name
     */
    public void setNull( int nIndex, int nType, String strTypeName )
    {
        try
        {
            _statement.setNull( nIndex, nType, strTypeName );
            logParameter( nIndex, "null" );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with an object value
     *
     * @see PreparedStatement#setObject(int, Object)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param value
     *            the value
     */
    public void setObject( int nIndex, Object value )
    {
        try
        {
            _statement.setObject( nIndex, value );
            logParameter( nIndex, value );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with an object value
     *
     * @see PreparedStatement#setObject(int, Object, int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param value
     *            the value
     * @param nType
     *            the target SQL type (as defined in java.sql.Types)
     */
    public void setObject( int nIndex, Object value, int nType )
    {
        try
        {
            _statement.setObject( nIndex, value, nType );
            logParameter( nIndex, value );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with an object value
     *
     * @see PreparedStatement#setObject(int, Object, int, int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param value
     *            the value
     * @param nType
     *            the target SQL type (as defined in java.sql.Types)
     * @param nScaleOrLength
     *            the scale or length
     */
    public void setObject( int nIndex, Object value, int nType, int nScaleOrLength )
    {
        try
        {
            _statement.setObject( nIndex, value, nType, nScaleOrLength );
            logParameter( nIndex, value );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a Ref value
     *
     * @see ResultSet#getRef(int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @return the ref
     */
    public Ref getRef( int nIndex )
    {
        try
        {
            return _resultSet.getRef( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a Ref value
     *
     * @see ResultSet#getRef(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the ref
     */
    public Ref getRef( String strColumnName )
    {
        try
        {
            return _resultSet.getRef( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with an Ref value
     *
     * @see PreparedStatement#setRef(int, Ref)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param ref
     *            the Ref
     */
    public void setRef( int nIndex, Ref ref )
    {
        try
        {
            _statement.setRef( nIndex, ref );
            logParameter( nIndex, ref );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a RowId value
     *
     * @see PreparedStatement#setRowId(int, RowId)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param rowId
     *            the value
     */
    public void setRowId( int nIndex, RowId rowId )
    {
        try
        {
            _statement.setRowId( nIndex, rowId );
            logParameter( nIndex, rowId );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a RowId value
     *
     * @see ResultSet#getRowId(int)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @return the rowId
     */
    public RowId getRowId( int nIndex )
    {
        try
        {
            return _resultSet.getRowId( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a RowId value
     *
     * @see ResultSet#getRowId(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the rowId
     */
    public RowId getRowId( String strColumnName )
    {
        try
        {
            return _resultSet.getRowId( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a short value
     *
     * @see PreparedStatement#setShort(int, short)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param shortValue
     *            the value
     */
    public void setShort( int nIndex, short shortValue )
    {
        try
        {
            _statement.setShort( nIndex, shortValue );
            logParameter( nIndex, shortValue );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a short value
     *
     * @see ResultSet#getShort(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the value
     */
    public short getShort( String strColumnName )
    {
        try
        {
            return _resultSet.getShort( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a short value
     *
     * @see ResultSet#getShort(int)
     * @since 5.1.1
     * @param nIndex
     *            the column index
     * @return the value
     */
    public short getShort( int nIndex )
    {
        try
        {
            return _resultSet.getShort( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a SQLXML value
     *
     * @see PreparedStatement#setSQLXML(int, SQLXML)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param value
     *            the value
     */
    public void setSQLXML( int nIndex, SQLXML value )
    {
        try
        {
            _statement.setSQLXML( nIndex, value );
            logParameter( nIndex, value );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a SQLXML value
     *
     * @see ResultSet#getSQLXML(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the value
     */
    public SQLXML getSQLXML( String strColumnName )
    {
        try
        {
            return _resultSet.getSQLXML( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a SQLXML value
     *
     * @see ResultSet#getSQLXML(int)
     * @since 5.1.1
     * @param nIndex
     *            the column index
     * @return the value
     */
    public SQLXML getSQLXML( int nIndex )
    {
        try
        {
            return _resultSet.getSQLXML( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Fills the prepared statement with a URL value
     *
     * @see PreparedStatement#setURL(int, URL)
     * @since 5.1.1
     * @param nIndex
     *            the index
     * @param url
     *            the URL
     */
    public void setURL( int nIndex, URL url )
    {
        try
        {
            _statement.setURL( nIndex, url );
            logParameter( nIndex, url );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a URL value
     *
     * @see ResultSet#getURL(String)
     * @since 5.1.1
     * @param strColumnName
     *            the column name
     * @return the value
     */
    public URL getURL( String strColumnName )
    {
        try
        {
            return _resultSet.getURL( strColumnName );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Get a URL value
     *
     * @see ResultSet#getURL(int)
     * @since 5.1.1
     * @param nIndex
     *            the column index
     * @return the value
     */
    public URL getURL( int nIndex )
    {
        try
        {
            return _resultSet.getURL( nIndex );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Adds a set of parameters to this <code>PreparedStatement</code> object's batch of commands.
     * 
     * @since 7.0.0
     */
    public void addBatch( )
    {
        try
        {
            _statement.addBatch( );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Adds the given SQL command to the current list of commands for this <code>Statement</code> object. The commands in this list can be executed as a batch
     * by calling the method <code>executeBatch</code>.
     * <P>
     * <strong>Note:</strong>This method cannot be called on a <code>PreparedStatement</code> or <code>CallableStatement</code>.
     * 
     * @since 7.0.0
     * @param sql
     *            typically this is a SQL <code>INSERT</code> or <code>UPDATE</code> statement this method is called on a closed <code>Statement</code>, the
     *            driver does not support batch updates, the method is called on a <code>PreparedStatement</code> or <code>CallableStatement</code>
     * @see #executeBatch
     * @see DatabaseMetaData#supportsBatchUpdates
     */
    public void addBatch( String sql )
    {
        try
        {
            _statement.addBatch( sql );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Empties this <code>Statement</code> object's current list of SQL commands.
     * 
     * @since 7.0.0
     * @see #addBatch
     * @see DatabaseMetaData#supportsBatchUpdates
     */
    void clearBatch( )
    {

        try
        {
            _statement.clearBatch( );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Clears the current parameter values immediately.
     * <P>
     * In general, parameter values remain in force for repeated use of a statement. Setting a parameter value automatically clears its previous value. However,
     * in some cases it is useful to immediately release the resources used by the current parameter values; this can be done by calling the method
     * <code>clearParameters</code>.
     * 
     * @since 7.0.0
     */
    public void clearParameters( )
    {
        try
        {
            _statement.clearParameters( );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * Submits a batch of commands to the database for execution and if all commands execute successfully, returns an array of update counts.
     * 
     * @since 7.0.0
     * @return The elements of the array that is returned are ordered to correspond to the commands in the batch, which are ordered according to the order in
     *         which they were added to the batch.
     */
    public int [ ] executeBatch( )
    {
        try
        {
            return _statement.executeBatch( );
        }
        catch( SQLException e )
        {
            free( );
            throw new AppException( getErrorMessage( e ), e );
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected void finalize( ) throws Throwable
    {
        if ( !_bReleased )
        {
            free( );
            AppLogService.error(
                    "A call to DAOUtil.free() seems to be missing or an unexpected exception has occured during the use of a DAOUtil object - plugin : {} - SQL statement : {}",
                    _strPluginName, _strSQL );
        }

        super.finalize( );
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void close( )
    {
        free( );
    }
}