---

TAbstractConnectionManager.java

/*
*  Name:      TAbstractConnectionManager.java
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Class for handling connections in JAVA.
*  Date:      $Date: 2003/10/06 13:21:36 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 2002-2003  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

package org.uesqlc;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;


public abstract class TAbstractConnectionManager
{

  protected Hashtable   tConnectionDataHashtable;

  protected TConnectionData   tCurrentConnectionData;

  protected Vector   tInputEmbeddedVariableVector;

  protected Vector   tOutputEmbeddedVariableVector;

  protected String   yCurrentConnection;

  public Logger   tLogger;


  //
  //  C O N S T R U C T O R S
  //

  public TAbstractConnectionManager()
  {

    tConnectionDataHashtable      = new Hashtable();
    tCurrentConnectionData        = null;
    tInputEmbeddedVariableVector  = new Vector();
    tOutputEmbeddedVariableVector = new Vector();
    yCurrentConnection            = null;
    tLogger                       = Logger.getLogger ("org.uesqlc");
    if ( tLogger.getLevel() == null )
    {
      //
      //  Deactivates logging if it has not been set externally.
      //
      tLogger.setLevel (Level.OFF);
    }
    initialize();

  }  // TAbstractConnectionManager()

  public void terminate() throws SQLException
  {
    finish();
  }

  public void bindConnection (final String kyCONNECTION_NAME, TConnectionData tCONNECTION_DATA)
    throws SQLException
  {
    tConnectionDataHashtable.put (kyCONNECTION_NAME, tCONNECTION_DATA);
    tCONNECTION_DATA.getConnection().setAutoCommit (false);
  }

  public void bindCursor (final String kyCURSOR_NAME, ResultSet tRESULT_SET)
  {
    tCurrentConnectionData.bind (kyCURSOR_NAME, tRESULT_SET);
  }

  public void commitCurrent()
  {

    try
    {
      tCurrentConnectionData.getConnection().commit();
    }
    catch (final SQLException ktEXCEPTION)
    {
      //
      //  Condition:           invalid transaction termination
      //  Class subcondition:  no subclass
      //
      TState.SQLCODE    = -1;
      TState.SQLMESSAGE = ktEXCEPTION.getMessage();
      TState.SQLSTATE   = TState.invalid_transaction_termination._kyNO_SUBCLASS;
    }

  }  // commitCurrent()

  public void connect (final String kyCONNECTION_NAME)
  {
    if ( tCurrentConnectionData != null )
    {
      connect ( kyCONNECTION_NAME                    ,
                tCurrentConnectionData.yHostName     ,
                tCurrentConnectionData.ySchemaName   ,
                tCurrentConnectionData.yUserName     ,
                tCurrentConnectionData.yUserPassword );
    }
    else
    {
      //
      //  Condition:           connection exception
      //  Class subcondition:  SQL-client unable to establish SQL-connection
      //
      TState.SQLCODE    = -1;
      TState.SQLSTATE   = TState.connection_exception._kySQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION;
      TState.SQLMESSAGE = TState._getDescription();
    }

  }  // connect()

  public void connect (final String kyCONNECTION_NAME, final String kySCHEMA_NAME)
  {

    if ( tCurrentConnectionData != null )
    {
      connect ( kyCONNECTION_NAME                    ,
                tCurrentConnectionData.yHostName     ,
                kySCHEMA_NAME                        ,
                tCurrentConnectionData.yUserName     ,
                tCurrentConnectionData.yUserPassword );
    }
    else
    {
      //
      //  Condition:           connection exception
      //  Class subcondition:  SQL-client unable to establish SQL-connection
      //
      TState.SQLCODE    = -1;
      TState.SQLSTATE   = TState.connection_exception._kySQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION;
      TState.SQLMESSAGE = TState._getDescription();
    }

  }  // connect()

  public void connect ( final String kyCONNECTION_NAME ,
                        final String kyHOST_NAME       ,
                        final String kySCHEMA_NAME     ,
                        final String kyUSER_LOGIN      )
  {

    int      iBarIndex;
    String   yUserName;
    String   yUserPassword = "";

    iBarIndex = kyUSER_LOGIN.indexOf ('/');
    if ( iBarIndex == -1 )
    {
      yUserName = kyUSER_LOGIN.replaceAll ("'", "");
    }
    else
    {
      yUserName     = kyUSER_LOGIN.substring (0, iBarIndex).replaceAll ("'", "");
      yUserPassword = kyUSER_LOGIN.substring (iBarIndex + 1).replaceAll ("'", "");
    }
    connect ( kyCONNECTION_NAME ,
              kyHOST_NAME       ,
              kySCHEMA_NAME     ,
              yUserName         ,
              yUserPassword     );

  }  // connect()

  public abstract void connect ( final String kyCONNECTION_NAME ,
                                 final String kyHOST_NAME       ,
                                 final String kySCHEMA_NAME     ,
                                 final String kyUSER_NAME       ,
                                 final String kyUSER_PASSWORD   );

  public void rollbackCurrent()
  {

    try
    {
      tCurrentConnectionData.getConnection().rollback();
    }
    catch (final SQLException ktEXCEPTION)
    {
      //
      //  Condition:           invalid transaction termination
      //  Class subcondition:  no subclass
      //
      TState.SQLCODE    = -1;
      TState.SQLMESSAGE = ktEXCEPTION.getMessage();
      TState.SQLSTATE   = TState.invalid_transaction_termination._kyNO_SUBCLASS;
    }

  }  // rollbackCurrent()

  public void unbindAllConnections()
  {
    Enumeration   tElementEnumeration = tConnectionDataHashtable.keys();

    while ( tElementEnumeration.hasMoreElements() )
    {
      unbindConnection ((String) tElementEnumeration.nextElement());
    }
  }

  public void unbindConnection (final String kyCONNECTION_NAME)
  {

    TConnectionData   tConnectionData = (TConnectionData) tConnectionDataHashtable.get (kyCONNECTION_NAME);
    Connection        tConnection     = tConnectionData.getConnection();

    tConnectionDataHashtable.remove (kyCONNECTION_NAME);
    try
    {
      tConnection.commit();
      tConnection.close();
    }
    catch (final SQLException ktEXCEPTION)
    {
      //
      //  Condition:           connection exception
      //  Class subcondition:  connection failure
      //
      TState.SQLCODE    = -1;
      TState.SQLMESSAGE = ktEXCEPTION.getMessage();
      TState.SQLSTATE   = TState.connection_exception._kyCONNECTION_FAILURE;
    }
    if ( kyCONNECTION_NAME == yCurrentConnection )
    {
      yCurrentConnection = null;
    }

  }  // unbindConnection()

  public void unbindCurrentConnection()
  {
    if ( isConnected() )
    {
      unbindConnection (yCurrentConnection);
    }
  }

  public void unbindCursor (final String kyCURSOR_NAME)
  {
    tCurrentConnectionData.unbind (kyCURSOR_NAME);
  }

  public void clearQueues()
  {
    tInputEmbeddedVariableVector.clear();
    tOutputEmbeddedVariableVector.clear();
  }

  public ResultSet execute (final String kySTATEMENT)
  {

    String      yInstantiatedStatement;
    Statement   tStatement = null;
    ResultSet   tResultSet = null;

    resetStatus();
    try
    {
      yInstantiatedStatement = instantiate (kySTATEMENT);
      tStatement             = createStatement();
// <DEBUG>
      tLogger.info (yInstantiatedStatement);
// </DEBUG>
      if ( tStatement.execute (yInstantiatedStatement) )
      {
        tResultSet = tStatement.getResultSet();
      }
    }
    catch (final SQLException ktEXCEPTION)
    {
      //
      //  Condition:           transaction rollback
      //  Class subcondition:  statement completion unknown
      //
      TState.SQLCODE    = -1;
      TState.SQLMESSAGE = ktEXCEPTION.getMessage();
      TState.SQLSTATE   = TState.transaction_rollback._kySTATEMENT_COMPLETION_UNKNOWN;
      tResultSet        = null;
      try
      {
        rollbackCurrent();
        tStatement.close();
      }
      catch (final SQLException ktINNER_EXCEPTION) {}
    }
    if ( TState.SQLCODE == 0 )
    {
      if ( tResultSet == null )
      {
        // 
        //  Condition:  no data
        // 
        TState.SQLCODE    = 101;
        TState.SQLSTATE   = TState.no_data._kyNO_SUBCLASS;
        TState.SQLMESSAGE = TState._getDescription();
        try
        {
          tStatement.close();
        }
        catch (final SQLException ktEXCEPTION) {}
      }
    }
    return tResultSet;

  }  // execute()

  public void executeClean (final String kySTATEMENT)
  {

    String      yInstantiatedStatement;
    Statement   tStatement = null;

    resetStatus();
    try
    {
      yInstantiatedStatement = instantiate (kySTATEMENT);
      tStatement             = createStatement();
// <DEBUG>
      tLogger.info (yInstantiatedStatement);
// </DEBUG>
      tStatement.execute (yInstantiatedStatement);
      tStatement.close();
    }
    catch (final SQLException ktEXCEPTION)
    {
      try
      {
        tStatement.close();
      }
      catch (final SQLException ktINNER_EXCEPTION) {}
    }

  }  // executeClean()

  public ResultSet executeSingleRow (final String kySTATEMENT)
  {

    String      yInstantiatedStatement;
    Statement   tStatement = null;
    ResultSet   tResultSet = null;

    resetStatus();
    try
    {
      yInstantiatedStatement = instantiate (kySTATEMENT);
      tStatement             = createStatement();
// <DEBUG>
      tLogger.info (yInstantiatedStatement);
// </DEBUG>
      tResultSet = tStatement.executeQuery (yInstantiatedStatement);
    }
    catch (final SQLException ktEXCEPTION)
    {
      //
      //  Condition:           transaction rollback
      //  Class subcondition:  statement completion unknown
      //
      TState.SQLCODE    = -1;
      TState.SQLMESSAGE = ktEXCEPTION.getMessage();
      TState.SQLSTATE   = TState.transaction_rollback._kySTATEMENT_COMPLETION_UNKNOWN;
      tResultSet        = null;
      try
      {
        rollbackCurrent();
        tStatement.close();
      }
      catch (final SQLException ktINNER_EXCEPTION) {}
    }
    if ( TState.SQLCODE == 0 )
    {
      try
      {
        if ( !tResultSet.next() )
        {
          // 
          //  Condition:  no data
          // 
          TState.SQLCODE    = 101;
          TState.SQLSTATE   = TState.no_data._kyNO_SUBCLASS;
          TState.SQLMESSAGE = TState._getDescription();
          tResultSet        = null;
        }
        else
        {
          if ( !tResultSet.next() )
          {
            //
            //  There is only one row, so everything is all right.
            //
            tResultSet.beforeFirst();
          }
          else
          {
            // 
            //  Condition:  cardinality violation
            // 
            TState.SQLCODE    = -1;
            TState.SQLSTATE   = TState.cardinality_violation._kyNO_SUBCLASS;
            TState.SQLMESSAGE = TState._getDescription();
            tResultSet        = null;
            try
            {
              rollbackCurrent();
              tStatement.close();
            }
            catch (final SQLException ktINNER_EXCEPTION) {}
          }
        }
      }
      catch (final SQLException ktEXCEPTION)
      {
        //
        //  Condition:           invalid cursor state
        //  Class subcondition:  no subclass
        //
        TState.SQLCODE    = -1;
        TState.SQLMESSAGE = ktEXCEPTION.getMessage();
        TState.SQLSTATE   = TState.invalid_cursor_state._kyNO_SUBCLASS;
        tResultSet        = null;
        try
        {
          rollbackCurrent();
          tStatement.close();
        }
        catch (final SQLException ktINNER_EXCEPTION) {}
      }
    }
    return tResultSet;

  }  // executeSingleRow()

  public void finish() throws SQLException
  {
    unbindAllConnections();
    clearQueues();
    tConnectionDataHashtable.clear();
    yCurrentConnection = null;
  }

  public IType getFromOutputQueue (final int kiINDEX)
  {
    return (IType) tOutputEmbeddedVariableVector.get (kiINDEX);
  }

  public void initialize()
  {
    connect ("DEFAULT");
    if ( !isSqlerrorCondition() )
    {
      setCurrentConnection ("DEFAULT");
    }
  }

  public String instantiate (final String kySTATEMENT)
  {

    int            iPatternIndex;
    IType          tType;
    StringBuffer   yStatementInstance = new StringBuffer (kySTATEMENT);

    while ( !tInputEmbeddedVariableVector.isEmpty() )
    {
      iPatternIndex = yStatementInstance.indexOf ("$z");
      if ( -1 == iPatternIndex )
      {
        break;
      }
      else
      {
        tType = (IType) tInputEmbeddedVariableVector.firstElement();
        yStatementInstance.replace (iPatternIndex, iPatternIndex + 2, tType.get());
        tInputEmbeddedVariableVector.remove (0);
      }
    }
    return yStatementInstance.toString();

  }  // instantiate()

  public IType popFromOutputQueue()
  {
    return (IType) tOutputEmbeddedVariableVector.remove (tOutputEmbeddedVariableVector.size() - 1);
  }

  public void pushOnInputQueue (final IType ktVALUE)
  {
    tInputEmbeddedVariableVector.add (ktVALUE);
  }

  public void pushOnOutputQueue (IType tVARIABLE)
  {
    tOutputEmbeddedVariableVector.add (tVARIABLE);
  }

  public void resetStatus()
  {
    //
    //  Condition:  successful completion
    //
    TState.SQLCODE    = 0;
    TState.SQLSTATE   = TState.successful_completion._kyNO_SUBCLASS;
    TState.SQLMESSAGE = TState._getDescription();
  }

  public void setCurrentConnection (final String kyCONNECTION_NAME)
  {

    if ( tConnectionDataHashtable.containsKey (kyCONNECTION_NAME) )
    {
      yCurrentConnection     = kyCONNECTION_NAME;
      tCurrentConnectionData = (TConnectionData) tConnectionDataHashtable.get (kyCONNECTION_NAME);
// <DEBUG>
      tLogger.info ("SET CONNECTION '" + kyCONNECTION_NAME + "'");
// </DEBUG>
      resetStatus();
    }
    else
    {
      //
      //  Condition:           connection exception
      //  Class subcondition:  connection does not exist
      //
      TState.SQLCODE    = -1;
      TState.SQLSTATE   = TState.connection_exception._kyCONNECTION_DOES_NOT_EXIST;
      TState.SQLMESSAGE = TState._getDescription();
    }
      
  }  // setCurrentConnection()


  //
  //  S E L E C T O R S
  //

  protected Statement createStatement() throws SQLException
  {
    return tCurrentConnectionData.getConnection().createStatement();
  }

  public final String currentConnectionName()
  {
    return yCurrentConnection;
  }

  public ResultSet getCursor (final String kyCURSOR_NAME)
  {
    return tCurrentConnectionData.getCursor (kyCURSOR_NAME);
  }

  public boolean isConnected()
  {
    return ( yCurrentConnection != null );
  }

  public boolean isConnected (final String kyCONNECTION_NAME)
  {
    return tConnectionDataHashtable.containsKey (kyCONNECTION_NAME);
  }

  public boolean isNotFoundCondition()
  {
    return ( TState.SQLSTATE == TState.no_data._kyNO_SUBCLASS );
  }

  public boolean isSqlerrorCondition()
  {
    return ( TState.SQLCODE < 0 );
  }

}  // class TAbstractConnectionManager

---