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

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

Public メソッド
	WriteStoredProcedureTask (int nbToComplete, int totalNb, StoredProcedure proc)
void	execute (BackendWorkerThread backendThread) throws SQLException
int	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
int	result
クラス org.objectweb.cjdbc.controller.loadbalancer.tasks.WriteStoredProcedureTask

説明

Public メソッド

Private 変数

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

メソッド

変数
