CJDBCversion1.0rc6: org.objectweb.cjdbc.controller.loadbalancer.tasks.ReadStoredProcedureTask class Reference

00071   {
00072     DatabaseBackend backend = backendThread.getBackend();
00073 
00074     AbstractConnectionManager cm = backend
00075         .getConnectionManager(proc.getLogin());
00076 
00077     if (proc.isAutoCommit())
00078     { // Use a connection just for this request
00079       Connection c = null;
00080       try
00081       {
00082         c = cm.getConnection();
00083       }
00084       catch (UnreachableBackendException e1)
00085       {
00086         backendThread.getLogger().error(
00087             "Disabling backend " + backend.getName()
00088                 + " because it is no more reachable.");
00089         backend.disable();
00090         throw new SQLException("Backend " + backend.getName()
00091             + " is no more reachable.");
00092       }
00093 
00094       // Sanity check
00095       if (c == null)
00096       {
00097         SQLException se = new SQLException("No more connections");
00098         try
00099         { // All backends failed, just ignore
00100           if (!notifyFailure(backendThread, (long) proc.getTimeout() * 1000, se))
00101             return;
00102         }
00103         catch (SQLException ignore)
00104         {
00105         }
00106         // Disable this backend (it is no more in sync) by killing the backend
00107         // thread
00108         backendThread.kill();
00109         String msg = "Stored procedure '"
00110             + proc.getSQLShortForm(backend.getSQLShortFormLength())
00111             + "' failed on backend " + backend.getName() + " but "
00112             + getSuccess() + " succeeded (" + se + ")";
00113         backendThread.getLogger().error(msg);
00114         throw new SQLException(msg);
00115       }
00116 
00117       // Execute Query
00118       try
00119       {
00120         CallableStatement cs = c.prepareCall(proc.getSQL());
00121         if (backend.getDriverCompliance().supportSetQueryTimeout())
00122           cs.setQueryTimeout(proc.getTimeout());
00123         if ((proc.getMaxRows() > 0)
00124             && backend.getDriverCompliance().supportSetMaxRows())
00125           cs.setMaxRows(proc.getMaxRows());
00126         result = cs.executeQuery();
00127 
00128         // Warning! No way to detect if schema has been modified unless
00129         // we ask the backend again using DatabaseMetaData.getTables().
00130         // FIXME!
00131       }
00132       catch (SQLException e)
00133       {
00134         try
00135         { // All backends failed, just ignore
00136           if (!notifyFailure(backendThread, (long) proc.getTimeout() * 1000, e))
00137             return;
00138         }
00139         catch (SQLException ignore)
00140         {
00141         }
00142         // Disable this backend (it is no more in sync) by killing the backend
00143         // thread
00144         backendThread.kill();
00145         String msg = "Stored procedure '"
00146             + proc.getSQLShortForm(backend.getSQLShortFormLength())
00147             + "' failed on backend " + backend.getName() + " but "
00148             + getSuccess() + " succeeded (" + e + ")";
00149         backendThread.getLogger().error(msg);
00150         throw new SQLException(msg);
00151       }
00152       finally
00153       {
00154         cm.releaseConnection(c);
00155       }
00156     }
00157     else
00158     { // Re-use the connection used by this transaction
00159       Connection c;
00160       long tid = proc.getTransactionId();
00161       Long lTid = new Long(tid);
00162 
00163       if (!backend.isStartedTransaction(lTid))
00164       { // Transaction has not been started yet, this is a lazy begin
00165         try
00166         {
00167           c = cm.getConnection(tid);
00168         }
00169         catch (UnreachableBackendException e1)
00170         {
00171           backendThread.getLogger().error(
00172               "Disabling backend " + backend.getName()
00173                   + " because it is no more reachable.");
00174           backend.disable();
00175           throw new SQLException("Backend " + backend.getName()
00176               + " is no more reachable.");
00177         }
00178 
00179         // Sanity check
00180         if (c == null)
00181         { // Bad connection
00182           SQLException se = new SQLException(
00183               "Unable to get connection for transaction " + tid);
00184           try
00185           { // All backends failed, just ignore
00186             if (!notifyFailure(backendThread, (long) proc.getTimeout() * 1000,
00187                 se))
00188               return;
00189           }
00190           catch (SQLException ignore)
00191           {
00192           }
00193           // Disable this backend (it is no more in sync) by killing the
00194           // backend thread
00195           backendThread.kill();
00196           String msg = "Stored procedure '"
00197               + proc.getSQLShortForm(backend.getSQLShortFormLength())
00198               + "' failed on backend " + backend.getName() + " but "
00199               + getSuccess() + " succeeded (" + se + ")";
00200           backendThread.getLogger().error(msg);
00201           throw new SQLException(msg);
00202         }
00203 
00204         // begin transaction
00205         backend.startTransaction(lTid);
00206         c.setAutoCommit(false);
00207       }
00208       else
00209       { // Transaction has already been started, retrieve connection
00210         c = cm.retrieveConnection(tid);
00211 
00212         // Sanity check
00213         if (c == null)
00214         { // Bad connection
00215           SQLException se = new SQLException(
00216               "Unable to retrieve connection for transaction " + tid);
00217           try
00218           { // All backends failed, just ignore
00219             if (!notifyFailure(backendThread, (long) proc.getTimeout() * 1000,
00220                 se))
00221               return;
00222           }
00223           catch (SQLException ignore)
00224           {
00225           }
00226           // Disable this backend (it is no more in sync) by killing the
00227           // backend thread
00228           backendThread.kill();
00229           String msg = "Stored procedure '"
00230               + proc.getSQLShortForm(backend.getSQLShortFormLength())
00231               + "' failed on backend " + backend.getName() + " but "
00232               + getSuccess() + " succeeded (" + se + ")";
00233           backendThread.getLogger().error(msg);
00234           throw new SQLException(msg);
00235         }
00236       }
00237 
00238       // Execute Query
00239       try
00240       {
00241         CallableStatement cs = c.prepareCall(proc.getSQL());
00242         if (backend.getDriverCompliance().supportSetQueryTimeout())
00243           cs.setQueryTimeout(proc.getTimeout());
00244         if ((proc.getMaxRows() > 0)
00245             && backend.getDriverCompliance().supportSetMaxRows())
00246           cs.setMaxRows(proc.getMaxRows());
00247         result = cs.executeQuery();
00248 
00249         // Warning! No way to detect if schema has been modified unless
00250         // we ask the backend again using DatabaseMetaData.getTables().
00251 
00252       }
00253       catch (SQLException e)
00254       {
00255         try
00256         { // All backends failed, just ignore
00257           if (!notifyFailure(backendThread, (long) proc.getTimeout() * 1000, e))
00258             return;
00259         }
00260         catch (SQLException ignore)
00261         {
00262         }
00263         // Disable this backend (it is no more in sync) by killing the backend
00264         // thread
00265         backendThread.kill();
00266         String msg = "Stored procedure '"
00267             + proc.getSQLShortForm(backend.getSQLShortFormLength())
00268             + "' failed on backend " + backend.getName() + " but "
00269             + getSuccess() + " succeeded (" + e + ")";
00270         backendThread.getLogger().error(msg);
00271         throw new SQLException(msg);
00272       }
00273     }
00274     notifySuccess();
00275   }

Public メソッド
	ReadStoredProcedureTask (int nbToComplete, int totalNb, StoredProcedure proc)
void	execute (BackendWorkerThread backendThread) throws SQLException
ResultSet	getResult ()
String	toString ()
boolean	hasTid ()
synchronized void	notifySuccess ()
synchronized boolean	notifyFailure (BackendWorkerThread backendThread, long timeout, SQLException e) throws SQLException
ArrayList	getExceptions ()
int	getFailed ()
int	getNbToComplete ()
int	getSuccess ()
int	getTotalNb ()
void	setTotalNb (int totalNb)
void	setHasTid (boolean hasTid)
Private 変数
StoredProcedure	proc
ResultSet	result
クラス org.objectweb.cjdbc.controller.loadbalancer.tasks.ReadStoredProcedureTask

説明

Public メソッド

Private 変数

コンストラクタとデストラクタ

メソッド

変数
