Any suggestions for my code.

Question

Hi,
I wrote this little piece of code to reduce some of the work I need to do when doing database access. I intend to use if with mySQL and mostly web based applications. It'll probably use it quite a bit, and since it's my first try at writing something like this I figured I'd post the code to see if anyone can find any problems. I've already tested it and it works, so I'm mostly interested in any feedback about performance issues.
I'd really like to know if there's any way I can get the number of rows in a result set before I start going through it. That way I could return the data in an Object[][] array (I'd assume it'd be a little faster to add values to than the ArrayList).
Here's the code...
* SQLGruntBean.java
* Created on November 22, 2002, 12:37 PM
package com.vacode.beans.sql;
import java.sql.*;
import java.util.*;
/** This bean is a generic class that can be used to access any type of SQL
*  database.  To use it with an application that accesses an SQL database
*  do the following:
*  <p>1. Create a new instance of SQLGruntBean.</p>
*  <p>2. Set the SQL connection source by calling setConnection(Connection).</p>
*  <p>3. Set the SQL query you wish to perform by calling setSqlQuery(String).
*  <br><b>Note:</b> You may replace all values with question mark place holders
*  as long as you also perform step 4.</p>
*  <p>4. (OPTIONAL) Set the values that are represented by question mark place
*  holders by calling setSqlValues.  This method requires an Object array as
*  input.</p>
*  <p>5. (OPTIONAL) Set the maximum number of results to be retrieved by calling
*  setMaxRows.  If left unset it will default to 100.  This method should not
*  be used as a replacement for the LIMIT parameter in an SQL query.  It is
*  merely a backup in case an excessive number of results are returned
*  erroneously.</p>
*  <p>6. Once all the necessary variables are set you may call either
*  executeQuery or executeUpdate to perform the intended task.</p>
*  <p>     <b><i><u>EXAMPLE</u></i></b></p>
*  <p>
*  <code>
*  <br>SQLGruntBean sgb = new SQLGruntBean();
*  <br>Object[] values = new Object[1];
*  <br>ArrayList data = null;
*  <br><br>
*  <br>sgb.setConnection(dataSource.getConnection);
*  <br>sgb.setSqlQuery("SELECT * FROM USERS WHERE firstName = ?");
*  <br>values[0] = "John";
*  <br>sgb.setSqlValues(values);
*  <br>data = sgb.executeQuery();
*  </code>
*  </p>
*  <p>The necessary try / catch blocks and error handling have been left out of
*  this example, but will need to be implemented for production code.</p>
* @author  Vacode Web Systems
* @version 1.0
public class SQLGruntBean
    // Define global variables
    private Connection dbConnection = null;
    private String sqlQuery = null;
    private int maxRows = 100;  // Default to 100 in case it is not set
    private Object[] sqlValues = null;
    // End global variables
    /** A write only method for defining the connection to an SQL
     *  database
    public void setConnection(Connection sqlConnectionObject)
     this.dbConnection = sqlConnectionObject;
    /** A write only method for defining the SQL query that is to be
     *  executed.*/
    public void setSqlQuery(String sqlQuery)
     this.sqlQuery = sqlQuery;
    /** Defines the maximum number of rows that are to be retrieved from the
     *  result set.  This is more of a back up than anything as the sql query
     *  should contain a limit parameter if the query is going to return an
     *  excessive number of results. */
    public void setMaxRows(int maximumRows)
     this.maxRows = maximumRows;
    /** A write only method for defining the dynamic values that are
     *  to replace the question mark placeholders in the sql query.*/
    public void setSqlValues(Object[] values)
     this.sqlValues = values;
    /** Used to execute an sql query.  The executed query is defined by calling
     *  setSqlQuery prior to this method.  The database connection to be used
     *  is defined by calling setConnection prior to this method. */
    public ArrayList executeQuery() throws SQLException
     // Define the local variables that will be used within this method
     ArrayList data = null;
     // End local variables
     if(this.sqlValues!=null && this.sqlValues.length>0)
         /* A prepared statement needs to be executed because the
          * sqlQuery is going to contain ? placeholders rather than
          * actual values.  It is necessary to replace these place
          * holders with their corresponding values.*/
         data = executePreparedQuery();
     else
         // A regular sql query needs to be executed.
         data = executeRegularQuery();
     return(data);
    /** Used to execute an sql update.  The executed update is defined by calling
     *  setSqlQuery prior to this method.  The database connection to be used
     *  is defined by calling setConnection prior to this method. */
    public int executeUpdate() throws SQLException
     // Define the local variables that will be used in this method
     int rowsAffected = -1;
     // Done local variables
     if(this.sqlValues!=null && this.sqlValues.length>0)
         /* A prepared update needs to be executed because the
          * sqlQuery is going to contain ? placeholders rather than
          * actual values.  It is necessary to replace these place
          * holders with their corresponding values.*/
         rowsAffected = executePreparedUpdate();
     else
         // We just need to execute a regular sql query
         rowsAffected = executeRegularUpdate();
     return(rowsAffected);
    /** If a prepared statement is needed this method will be called by the
     *  executeQuery method.*/
    private ArrayList executePreparedQuery() throws SQLException
     // Define the local variables that will be used within this method
     ResultSet rs = null;
     PreparedStatement pstmt = null;
     ArrayList data = null;
     // End local variables
     try
         pstmt = this.dbConnection.prepareStatement(this.sqlQuery);
         setSqlValues(pstmt, this.sqlValues);
         rs = pstmt.executeQuery();
         /* Closing the PreparedStatement is going to cause the
          * ResultSet to be inaccessible.  Therefore it is necessary to
          * move the data that has just been aquired into an alternate
          * data storage object.*/
         data = processResult(rs);
         // Clean up all of the db resources we have opened
         rs.close();
         rs = null;
         pstmt.close();
         pstmt = null;
         this.dbConnection.close();
         this.dbConnection = null;
         /* No exceptions are caught.  They should be dealt with by the
          * calling class. */
     finally
          /* If an exception was thrown during the execution of the
           * sql query there will still be open db resources.  They need
           * to be closed. */
         if(rs!=null)
          try
          { rs.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          rs = null;
         if(pstmt!=null)
          try
          { pstmt.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          pstmt = null;
         if(this.dbConnection!=null)
          try
          { this.dbConnection.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          this.dbConnection = null;
         /* Regardless of what happens we need to return an array of Objects.
          * If the returning value is null it should be handled by the
          * calling class. */
     return(data);
    /** If a regular sql statement is required this method will be called
     *  by the executeQuery method. */
    private ArrayList executeRegularQuery() throws SQLException
     // Define the local variables that will be used within this method
     ResultSet rs = null;
     Statement stmt = null;
     ArrayList data = null;
     // End local variables
     try
         stmt = this.dbConnection.createStatement();
         rs = stmt.executeQuery(this.sqlQuery);
         /* Closing the Statement is going to cause the ResultSet to be
          * inaccessible.  Therefore it is necessary to move the data
          * that has just been aquired into an alternate data storage
          * object.*/
         data = processResult(rs);
         // Clean up all of the db resources we have opened
         rs.close();
         rs = null;
         stmt.close();
         stmt = null;
         this.dbConnection.close();
         this.dbConnection = null;
         /* No exceptions are caught.  They should be dealt with by the
          * calling class. */
     finally
          /* If an exception was thrown during the execution of the
           * sql query there will still be open db resources.  They need
           * to be closed. */
         if(rs!=null)
          try
          { rs.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          rs = null;
         if(stmt!=null)
          try
          { stmt.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          stmt = null;
         if(this.dbConnection!=null)
          try
          { this.dbConnection.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          this.dbConnection = null;
     return(data);
    /** If a prepared update is needed this method will be called by the
     *  executeUpdate method.*/
    private int executePreparedUpdate() throws SQLException
     // Define the local variables that will be used within this method
     PreparedStatement pstmt = null;
     int rowsAffected = -1;
     // End local variables
     try
         pstmt = this.dbConnection.prepareStatement(this.sqlQuery);
         setSqlValues(pstmt, this.sqlValues);
         rowsAffected = pstmt.executeUpdate();
         pstmt.close();
         pstmt = null;
         this.dbConnection.close();
         this.dbConnection = null;
         /* No exceptions are caught.  They should be dealt with by the
          * calling class. */
     finally
          /* If an exception was thrown during the execution of the
           * sql update there will still be open db resources.  They need
           * to be closed. */
         if(pstmt!=null)
          try
          { pstmt.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          pstmt = null;
         if(this.dbConnection!=null)
          try
          { this.dbConnection.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          this.dbConnection = null;
         /* Regardless of what happens we need to return an array of Objects.
          * If the returning value is -1 it should be handled by the
          * calling class. */
     return(rowsAffected);
    /** If a regular sql statement is required this method will be called
     *  by the executeQuery method. */
    private int executeRegularUpdate() throws SQLException
     // Define the local variables that will be used within this method
     ResultSet rs = null;
     Statement stmt = null;
     int rowsAffected = -1;
     // End local variables
     try
         stmt = this.dbConnection.createStatement();
         rowsAffected = stmt.executeUpdate(this.sqlQuery);
         // Clean up all of the db resources we have opened
         stmt.close();
         stmt = null;
         this.dbConnection.close();
         this.dbConnection = null;
         /* No exceptions are caught.  They should be dealt with by the
          * calling class. */
     finally
          /* If an exception was thrown during the execution of the
           * sql update there will still be open db resources.  They need
           * to be closed. */
         if(stmt!=null)
          try
          { stmt.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          stmt = null;
         if(this.dbConnection!=null)
          try
          { this.dbConnection.close(); } catch(SQLException sqle)
          { } // EXCEPTION IGNORED
          this.dbConnection = null;
     return(rowsAffected);
    /** used to iterate through the sql values and add them to the
     *  prepared statement object. */
    private void setSqlValues(PreparedStatement ps, Object[] values) throws SQLException
     for(int i=0;i<this.sqlValues.length;i++)
         Object o = this.sqlValues;
     /* SQL starts counting at 1 not 0, so this loop needs to be
     * incremented by 1 for the setObject method to interpret it
     * correctly. */
     ps.setObject(i+1, values[i]);
/** Used to copy a result set into a persistent object so that it can
* be used even once the connection to the database has been closed. */
private ArrayList processResult(ResultSet rs) throws SQLException
     ArrayList data = new ArrayList();
     ResultSetMetaData rsmd = rs.getMetaData();
     int colCount = rsmd.getColumnCount();
     while(rs.next())
     Object[] currentRow = new Object[colCount];
     for(int i=0;i<colCount;i++)
          currentRow[i] = rs.getObject(i+1); //SQL starts at 1 not 0
     data.add(currentRow);
     return(data);
Thanks for the input,
Ryan

Answer 1

I think I have an idea of what you mean. I just want to make sure before I write everything though. I could implement your idea by doing the following right?
I haven't tried any of this, so if there's minor (syntax) errors just ignore them. I'll fix them later.
1. Create the following Interface.
package com.vacode.beans.sql;
public interface GruntBeanProccessingModule
    public Object get(Object[] properties);
}2. Force the subclasses to implement the above interface
public class EmployeeProcessor implements GruntBeanProcessingModule
    public Object get(Object[] properties)
     //make sure the input array is the right length (+ other validation, etc.)
     //create a new EmployeeBean
     //set all the EmployeeBean properties based on the input Object[]
     //return the EmployeeBean
}3. Make the following additions to my SQLGruntBean class
private requestedClassType = null;
public void setRequestedClassType(Object o) // o must be an instance of the requested class
    this.requestedClassType = o;
//if requestedClassType isn't null then create the ArrayList like this
while(rs.next())
         Object[] currentRow = new Object[colCount];
         for(int i=0;i<colCount;i++)
          currentRow[i] = rs.getObject(i+1); //SQL starts at 1 not 0
         Class requestedClass = Class.forName(requestedClassType.getClass().getName());
         GruntBeanProcessingModule gbpm = requestedClass.newInstance();
         Object convertedData = gbpm.get(currentRow);
         data.add(convertedData);
     }Of course I'll have to handle any possible exceptions (requestedClassType isn't an instance of GruntBeanProcessingModule, etc.). I also notice the forum replaced some of my [] with <> (I've seen it before though, so you probably already know about it).
Did I get it right or am I out to lunch :-)
Thank you very much for the feedback,
Ryan