package org.apache.ojb.broker.accesslayer;

 /* Copyright 2002-2005 The Apache Software Foundation

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 import java.sql.Connection;

 import java.sql.PreparedStatement;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.sql.Statement;

 import org.apache.ojb.broker.PersistenceBrokerSQLException;

 import org.apache.ojb.broker.accesslayer.sql.SqlGenerator;

 import org.apache.ojb.broker.accesslayer.sql.SqlGeneratorFactory;

 import org.apache.ojb.broker.core.proxy.ProxyHelper;

 import org.apache.ojb.broker.metadata.ClassDescriptor;

 import org.apache.ojb.broker.metadata.JdbcConnectionDescriptor;

 import org.apache.ojb.broker.metadata.ConnectionPoolDescriptor;

 import org.apache.ojb.broker.platforms.Platform;

 import org.apache.ojb.broker.platforms.PlatformException;

 import org.apache.ojb.broker.platforms.PlatformFactory;

 import org.apache.ojb.broker.query.Query;

 import org.apache.ojb.broker.util.logging.Logger;

 import org.apache.ojb.broker.util.logging.LoggerFactory;

 import org.apache.ojb.broker.util.ExceptionHelper;

 /**

  * This class serves as a cache for Statements that are

  * used for persistence operations on a given class.

  * @author Thomas Mahler

  * @version $Id: StatementsForClassImpl.java,v 1.1 2007-08-24 22:17:30 ewestfal Exp $

  */

 public class StatementsForClassImpl implements StatementsForClassIF

 {

     private Logger log = LoggerFactory.getLogger(StatementsForClassImpl.class);

     /**

      * sets the escape processing mode

      */

     // protected static boolean ESCAPEPROCESSING = false;

     protected final ClassDescriptor classDescriptor;

     protected final SqlGenerator sqlGenerator;

     protected final Platform platform;

     protected final Class clazz;

     protected final int fetchSize;

     private String deleteSql;

     private String insertSql;

     private String updateSql;

     private String selectByPKSql;

     /**

      * force use of JDBC 1.0 statement creation

      */

     protected boolean FORCEJDBC1_0 = false;

     public StatementsForClassImpl(

         final JdbcConnectionDescriptor jcd,

         final ClassDescriptor classDescriptor)

     {

         this.classDescriptor = classDescriptor;

         clazz = classDescriptor.getClassOfObject();

         platform = PlatformFactory.getPlatformFor(jcd);

         sqlGenerator = SqlGeneratorFactory.getInstance().createSqlGenerator(platform);

         final ConnectionPoolDescriptor cpd = jcd.getConnectionPoolDescriptor();

         fetchSize = cpd.getFetchSize();

         // detect JDBC level

         double level = jcd.getJdbcLevel();

         FORCEJDBC1_0 = level == 1.0;

     }

     /**

      * Answer true if a PreparedStatement has to be used

      * <br>false for a CallableStatement

      */

     protected boolean usePreparedDeleteStatement()

     {

         return !(classDescriptor.getDeleteProcedure() != null &&

                 classDescriptor.getDeleteProcedure().hasReturnValues());

     }

     public PreparedStatement getDeleteStmt(Connection con) throws SQLException

     {

         if (deleteSql == null)

         {

             deleteSql = sqlGenerator.getPreparedDeleteStatement(classDescriptor).getStatement();

         }

         try

         {

             return prepareStatement(con,

                     deleteSql,

                     Query.NOT_SCROLLABLE,

                     usePreparedDeleteStatement(),

                     StatementManagerIF.FETCH_SIZE_NOT_APPLICABLE);

         }

         catch (SQLException ex)

         {

             log.error("Can't prepare delete statement: " + deleteSql, ex);

             throw ex;

         }

     }

     public Statement getGenericStmt(Connection con, boolean scrollable)

         throws PersistenceBrokerSQLException

     {

         Statement stmt;

         try

         {

             stmt = createStatement(con, scrollable,

                     StatementManagerIF.FETCH_SIZE_NOT_EXPLICITLY_SET);

         }

         catch (SQLException ex)

         {

             throw ExceptionHelper.generateException("Can't prepare statement:", ex, null, log);

         }

         return stmt;

     }

     /**

      * Answer true if a PreparedStatement has to be used

      * <br>false for a CallableStatement

      */

     protected boolean usePreparedInsertStatement()

     {

         return !(classDescriptor.getInsertProcedure() != null &&

                 classDescriptor.getInsertProcedure().hasReturnValues());

     }

     public PreparedStatement getInsertStmt(Connection con) throws SQLException

     {

         if (insertSql == null)

         {

             insertSql = sqlGenerator.getPreparedInsertStatement(classDescriptor).getStatement();

         }

         try

         {

             return prepareStatement(con,

                     insertSql,

                     Query.NOT_SCROLLABLE,

                     usePreparedInsertStatement(),

                     StatementManagerIF.FETCH_SIZE_NOT_APPLICABLE);

         }

         catch (SQLException ex)

         {

             log.error("Can't prepare insert statement: " + insertSql, ex);

             throw ex;

         }

     }

     public PreparedStatement getPreparedStmt(Connection con, String sql,

                                              boolean scrollable, int explicitFetchSizeHint, boolean callableStmt)

         throws PersistenceBrokerSQLException

     {

         PreparedStatement stmt;

         try

         {

             stmt = prepareStatement(con, sql, scrollable,

                     !callableStmt, explicitFetchSizeHint);

         }

         catch (SQLException ex)

         {

             throw ExceptionHelper.generateException("Can't prepare statement:", ex, sql, log);

         }

         return stmt;

     }

     public PreparedStatement getSelectByPKStmt(Connection con) throws SQLException

     {

         if (selectByPKSql == null)

         {

             selectByPKSql = sqlGenerator.getPreparedSelectByPkStatement(classDescriptor).getStatement();

         }

         try

         {

             return prepareStatement(con, selectByPKSql, Query.NOT_SCROLLABLE, true, 1);

         }

         catch (SQLException ex)

         {

             log.error(ex);

             throw ex;

         }

     }

     /**

      * Answer true if a PreparedStatement has to be used

      * <br>false for a CallableStatement

      */

     protected boolean usePreparedUpdateStatement()

     {

         return !(classDescriptor.getUpdateProcedure() != null &&

                 classDescriptor.getUpdateProcedure().hasReturnValues());

     }

     public PreparedStatement getUpdateStmt(Connection con) throws SQLException

     {

         if (updateSql == null)

         {

             updateSql = sqlGenerator.getPreparedUpdateStatement(classDescriptor).getStatement();

         }

         try

         {

             return prepareStatement(con,

                     updateSql,

                     Query.NOT_SCROLLABLE,

                     usePreparedUpdateStatement(),

                     StatementManagerIF.FETCH_SIZE_NOT_APPLICABLE);

         }

         catch (SQLException ex)

         {

             log.error("Can't prepare update statement: " + updateSql, ex);

             throw ex;

         }

     }

     /**

      * Prepares a statement with parameters that should work with most RDBMS.

      *

      * @param con the connection to utilize

      * @param sql the sql syntax to use when creating the statement.

      * @param scrollable determines if the statement will be scrollable.

      * @param createPreparedStatement if <code>true</code>, then a

      * {@link PreparedStatement} will be created. If <code>false</code>, then

      * a {@link java.sql.CallableStatement} will be created.

      * @param explicitFetchSizeHint will be used as fetchSize hint

      * (if applicable) if > 0

      *

      * @return a statement that can be used to execute the syntax contained in

      * the <code>sql</code> argument.

      */

     protected PreparedStatement prepareStatement(Connection con,

                                                  String sql,

                                                  boolean scrollable,

                                                  boolean createPreparedStatement,

                                                  int explicitFetchSizeHint)

         throws SQLException

     {

         PreparedStatement result;

         // if a JDBC1.0 driver is used the signature

         // prepareStatement(String, int, int) is  not defined.

         // we then call the JDBC1.0 variant prepareStatement(String)

         try

         {

             // if necessary use JDB1.0 methods

             if (!FORCEJDBC1_0)

             {

                 if (createPreparedStatement)

                 {

                     result =

                         con.prepareStatement(

                             sql,

                             scrollable

                                 ? ResultSet.TYPE_SCROLL_INSENSITIVE

                                 : ResultSet.TYPE_FORWARD_ONLY,

                             ResultSet.CONCUR_READ_ONLY);

                     afterJdbc2CapableStatementCreate(result, explicitFetchSizeHint);

                 }

                 else

                 {

                     result =

                         con.prepareCall(

                             sql,

                             scrollable

                                 ? ResultSet.TYPE_SCROLL_INSENSITIVE

                                 : ResultSet.TYPE_FORWARD_ONLY,

                             ResultSet.CONCUR_READ_ONLY);

                 }

             }

             else

             {

                 if (createPreparedStatement)

                 {

                     result = con.prepareStatement(sql);

                 }

                 else

                 {

                     result = con.prepareCall(sql);

                 }

             }

         }

         catch (AbstractMethodError err)

         {

             // this exception is raised if Driver is not JDBC 2.0 compliant

             log.warn("Used driver seems not JDBC 2.0 compatible, use the JDBC 1.0 mode", err);

             if (createPreparedStatement)

             {

                 result = con.prepareStatement(sql);

             }

             else

             {

                 result = con.prepareCall(sql);

             }

             FORCEJDBC1_0 = true;

         }

         catch (SQLException eSql)

         {

             // there are JDBC Driver that nominally implement JDBC 2.0, but

             // throw DriverNotCapableExceptions. If we catch one of these

             // we force usage of JDBC 1.0

             if (eSql

                 .getClass()

                 .getName()

                 .equals("interbase.interclient.DriverNotCapableException"))

             {

                 log.warn("JDBC 2.0 problems with this interbase driver, we use the JDBC 1.0 mode");

                 if (createPreparedStatement)

                 {

                     result = con.prepareStatement(sql);

                 }

                 else

                 {

                     result = con.prepareCall(sql);

                 }

                 FORCEJDBC1_0 = true;

             }

             else

             {

                 throw eSql;

             }

         }

         try

         {

             if (!ProxyHelper.isNormalOjbProxy(result))  // tomdz: What about VirtualProxy

             {

                 platform.afterStatementCreate(result);

             }

         }

         catch (PlatformException e)

         {

             log.error("Platform dependend failure", e);

         }

         return result;

     }

     /**

      * Creates a statement with parameters that should work with most RDBMS.

      */

     private Statement createStatement(Connection con, boolean scrollable, int explicitFetchSizeHint)

         throws java.sql.SQLException

     {

         Statement result;

         try

         {

             // if necessary use JDBC1.0 methods

             if (!FORCEJDBC1_0)

             {

                 result =

                     con.createStatement(

                         scrollable

                             ? ResultSet.TYPE_SCROLL_INSENSITIVE

                             : ResultSet.TYPE_FORWARD_ONLY,

                         ResultSet.CONCUR_READ_ONLY);

                 afterJdbc2CapableStatementCreate(result, explicitFetchSizeHint);

             }

             else

             {

                 result = con.createStatement();

             }

         }

         catch (AbstractMethodError err)

         {

             // if a JDBC1.0 driver is used, the signature

             // createStatement(int, int) is  not defined.

             // we then call the JDBC1.0 variant createStatement()

             log.warn("Used driver seems not JDBC 2.0 compatible, use the JDBC 1.0 mode", err);

             result = con.createStatement();

             FORCEJDBC1_0 = true;

         }

         catch (SQLException eSql)

         {

             // there are JDBC Driver that nominally implement JDBC 2.0, but

             // throw DriverNotCapableExceptions. If we catch one of these

             // we force usage of JDBC 1.0

             if (eSql.getClass().getName()

                 .equals("interbase.interclient.DriverNotCapableException"))

             {

                 log.warn("JDBC 2.0 problems with this interbase driver, we use the JDBC 1.0 mode");

                 FORCEJDBC1_0 = true;

                 result = con.createStatement();

             }

             else

             {

                 throw eSql;

             }

         }

         try

         {

             platform.afterStatementCreate(result);

         }

         catch (PlatformException e)

         {

             log.error("Platform dependend failure", e);

         }

         return result;

     }

     private void afterJdbc2CapableStatementCreate(Statement stmt, int explicitFetchSizeHint)

             throws SQLException

     {

         if (stmt != null)

         {

             final int fetchSizeHint;

             if (explicitFetchSizeHint == StatementManagerIF.FETCH_SIZE_NOT_APPLICABLE)

             {

                 fetchSizeHint = StatementManagerIF.FETCH_SIZE_NOT_APPLICABLE;

             }

             else if (explicitFetchSizeHint != StatementManagerIF.FETCH_SIZE_NOT_EXPLICITLY_SET)

             {

                 fetchSizeHint = explicitFetchSizeHint; // specific for this Statement

             }

             else

             {

                 fetchSizeHint = fetchSize; // connection pool default

             }

             if (fetchSizeHint > 0)

             {

                 stmt.setFetchSize(fetchSize);

             }

         }

     }

 }