Main Page | Packages | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | Related Pages

org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer Class Reference

Inheritance diagram for org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer:

Inheritance graph
[legend]
List of all members.

Public Member Functions

int getRAIDbLevel ()
void setRAIDbLevel (int raidbLevel)
int getParsingGranularity ()
void setParsingGranularity (int parsingGranularity)
abstract ControllerResultSet execReadRequest (SelectRequest request, MetadataCache metadataCache) throws SQLException
abstract int execWriteRequest (AbstractWriteRequest request) throws AllBackendsFailedException, SQLException
abstract ControllerResultSet execWriteRequestWithKeys (AbstractWriteRequest request, MetadataCache metadataCache) throws AllBackendsFailedException, SQLException
abstract ControllerResultSet execReadOnlyReadStoredProcedure (StoredProcedure proc, MetadataCache metadataCache) throws SQLException
abstract ControllerResultSet execReadStoredProcedure (StoredProcedure proc, MetadataCache metadataCache) throws SQLException
abstract int execWriteStoredProcedure (StoredProcedure proc) throws SQLException
abstract void begin (TransactionMarkerMetaData tm) throws SQLException
abstract void commit (TransactionMarkerMetaData tm) throws AllBackendsFailedException, SQLException
abstract void rollback (TransactionMarkerMetaData tm) throws AllBackendsFailedException, SQLException
abstract void enableBackend (DatabaseBackend db, boolean writeEnabled) throws SQLException
abstract void disableBackend (DatabaseBackend db) throws SQLException
void setWeight (String name, int w) throws SQLException
abstract String getInformation ()
abstract String getXmlImpl ()
void setMacroHandler (MacrosHandler handler)
void handleMacros (AbstractRequest request)
String getXml ()
String getAssociatedString ()

Static Public Member Functions

final ControllerResultSet executeSelectRequestOnBackend (SelectRequest request, DatabaseBackend backend, Connection c, MetadataCache metadataCache) throws SQLException, BadConnectionException
final int executeUpdateRequestOnBackend (AbstractWriteRequest request, DatabaseBackend backend, Connection c) throws SQLException, BadConnectionException
final ControllerResultSet executeUpdateRequestOnBackendWithKeys (AbstractWriteRequest request, DatabaseBackend backend, Connection c, MetadataCache metadataCache) throws SQLException, BadConnectionException
final ControllerResultSet executeReadStoredProcedureOnBackend (StoredProcedure proc, DatabaseBackend backend, Connection c, MetadataCache metadataCache) throws SQLException, BadConnectionException
final int executeWriteStoredProcedureOnBackend (StoredProcedure proc, DatabaseBackend backend, Connection c) throws SQLException, BadConnectionException
final Connection getConnectionAndBeginTransaction (DatabaseBackend backend, AbstractConnectionManager cm, long tid) throws SQLException, UnreachableBackendException

Protected Member Functions

 AbstractLoadBalancer (VirtualDatabase vdb, int raidbLevel, int parsingGranularity) throws SQLException, NotCompliantMBeanException

Protected Attributes

VirtualDatabase vdb
int raidbLevel
int parsingGranularity
MacrosHandler macroHandler

Static Protected Attributes

Trace logger

Detailed Description

The Request Load Balancer should implement the load balancing of the requests among the backend nodes.

The requests comes from the Request Controller and are sent to the Connection Managers.

Author:
Emmanuel Cecchet

Vadim Kassin

Jaco Swart

Version:
1.0

Definition at line 69 of file AbstractLoadBalancer.java.

Constructor & Destructor Documentation

org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.AbstractLoadBalancer (  VirtualDatabase  vdb,
int  raidbLevel,
int  parsingGranularity
)  throws SQLException, NotCompliantMBeanException [protected]
 

Generic constructor that sets some member variables and checks that backends are in the disabled state

Parameters:
vdb The virtual database this load balancer belongs to
raidbLevel The RAIDb level of this load balancer
parsingGranularity The parsing granularity needed by this load balancer

Definition at line 105 of file AbstractLoadBalancer.java.

References org.objectweb.cjdbc.controller.backend.DatabaseBackend.disable(), org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.disableBackend(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.getName(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.isReadEnabled(), and org.objectweb.cjdbc.controller.backend.DatabaseBackend.isWriteEnabled().

00107   {
00108     super(AbstractLoadBalancerMBean.class);
00109     this.raidbLevel = raidbLevel;
00110     this.parsingGranularity = parsingGranularity;
00111     this.vdb = vdb;
00112     try
00113     {
00114       vdb.acquireReadLockBackendLists();
00115     }
00116     catch (InterruptedException e)
00117     {
00118       String msg = Translate.get(
00119           "loadbalancer.backendlist.acquire.readlock.failed", e);
00120       logger.error(msg);
00121       throw new SQLException(msg);
00122     }
00123     int size = vdb.getBackends().size();
00124     ArrayList backends = vdb.getBackends();
00125     for (int i = 0; i < size; i++)
00126     {
00127       DatabaseBackend backend = (DatabaseBackend) backends.get(i);
00128       if (backend.isReadEnabled() || backend.isWriteEnabled())
00129       {
00130         if (logger.isWarnEnabled())
00131           logger.warn(Translate.get(
00132               "loadbalancer.constructor.backends.not.disabled", backend
00133                   .getName()));
00134         try
00135         {
00136           disableBackend(backend);
00137         }
00138         catch (Exception e)
00139         { // Set the disabled state anyway
00140           backend.disable();
00141         }
00142       }
00143     }
00144     vdb.releaseReadLockBackendLists();
00145   }

Member Function Documentation

abstract void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.begin (  TransactionMarkerMetaData  tm  )  throws SQLException [pure virtual]
 

Begin a new transaction.

Parameters:
tm The transaction marker metadata
Exceptions:
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

Referenced by org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager.begin(), and org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager.lazyTransactionStart().

abstract void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.commit (  TransactionMarkerMetaData  tm  )  throws AllBackendsFailedException, SQLException [pure virtual]
 

Commit a transaction.

Parameters:
tm The transaction marker metadata
Exceptions:
AllBackendsFailedException if all backends failed to execute the request
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

abstract void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.disableBackend (  DatabaseBackend  db  )  throws SQLException [pure virtual]
 

Disable a backend without further check. Ask the corresponding connection manager to finalize the connections if needed. This method should not be called directly but instead should access the RequestManager.disableBackeknd(...) method.

Parameters:
db The database backend to disable
Exceptions:
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

Referenced by org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.AbstractLoadBalancer(), org.objectweb.cjdbc.controller.loadbalancer.BackendWorkerThread.kill(), and org.objectweb.cjdbc.controller.loadbalancer.BackendWorkerThread.run().

abstract void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.enableBackend (  DatabaseBackend  db,
boolean  writeEnabled
)  throws SQLException [pure virtual]
 

Enable a backend without further check. The backend is at least read enabled but could also be enabled for writes. Ask the corresponding connection manager to initialize the connections if needed.

Parameters:
db The database backend to enable
writeEnabled True if the backend must be enabled for writes
Exceptions:
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

Referenced by org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager.enableBackend().

abstract ControllerResultSet org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.execReadOnlyReadStoredProcedure (  StoredProcedure  proc,
MetadataCache  metadataCache
)  throws SQLException [pure virtual]
 

Call a read-only stored procedure that returns a ResultSet. The stored procedure will be executed by one node only.

Parameters:
proc the stored procedure call
metadataCache MetadataCache (null if none)
Returns:
a ControllerResultSet value
Exceptions:
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_LPRF, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_LPRF, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_WRR, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

abstract ControllerResultSet org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.execReadRequest (  SelectRequest  request,
MetadataCache  metadataCache
)  throws SQLException [pure virtual]
 

Perform a read request. It is up to the implementation to choose to which backend node(s) this request should be sent.

Parameters:
request an SelectRequest
metadataCache MetadataCache (null if none)
Returns:
the corresponding ControllerResultSet
Exceptions:
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_LPRF, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_LPRF, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_WRR, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

abstract ControllerResultSet org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.execReadStoredProcedure (  StoredProcedure  proc,
MetadataCache  metadataCache
)  throws SQLException [pure virtual]
 

Call a stored procedure that returns a ResultSet. This stored procedure can possibly perform writes and will therefore be executed by all nodes.

Parameters:
proc the stored procedure call
metadataCache MetadataCache (null if none)
Returns:
a ControllerResultSet value
Exceptions:
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

final ControllerResultSet org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.executeReadStoredProcedureOnBackend (  StoredProcedure  proc,
DatabaseBackend  backend,
Connection  c,
MetadataCache  metadataCache
)  throws SQLException, BadConnectionException [static]
 

Execute a read stored procedure on the given backend. The callable statement is setXXX if the driver has not processed the statement.

Parameters:
proc the stored procedure to execute
backend the backend on which to execute the stored procedure
c the connection on which to execute the stored procedure
metadataCache the matedatacache to build the ControllerResultSet
Returns:
the controllerResultSet
Exceptions:
SQLException if an error occurs
BadConnectionException if the connection was bad

Definition at line 458 of file AbstractLoadBalancer.java.

00461   {
00462     try
00463     {
00464       backend.addPendingReadRequest(proc);
00465 
00466       // We suppose here that the request does not modify the schema since
00467       // it is a read-only query.
00468       CallableStatement cs;
00469       if (proc.isDriverProcessed())
00470         cs = c.prepareCall(proc.getSQL());
00471       else
00472       {
00473         cs = c.prepareCall(proc.getSqlSkeleton());
00474         org.objectweb.cjdbc.driver.PreparedStatement.setPreparedStatement(proc
00475             .getSQL(), cs);
00476       }
00477       if (backend.getDriverCompliance().supportSetQueryTimeout())
00478         cs.setQueryTimeout(proc.getTimeout());
00479       if ((proc.getMaxRows() > 0)
00480           && backend.getDriverCompliance().supportSetMaxRows())
00481         cs.setMaxRows(proc.getMaxRows());
00482       ControllerResultSet rs = new ControllerResultSet(proc, cs.executeQuery(),
00483           metadataCache, cs);
00484       return rs;
00485     }
00486     catch (SQLException e)
00487     { // Something bad happened
00488       if (backend.isValidConnection(c))
00489         throw e; // Connection is valid, throw the exception
00490       else
00491         throw new BadConnectionException(e);
00492     }
00493     finally
00494     {
00495       backend.removePendingRequest(proc);
00496     }
00497   }

final ControllerResultSet org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.executeSelectRequestOnBackend (  SelectRequest  request,
DatabaseBackend  backend,
Connection  c,
MetadataCache  metadataCache
)  throws SQLException, BadConnectionException [static]
 

Execute a statement on a backend. If the execution fails, the connection is checked for validity. If the connection was not valid, the query is automatically retried on a new connection.

Parameters:
request the request to execute
backend the backend on which the request is executed
c connection used to create the statement
metadataCache MetadataCache (null if none)
Returns:
the ControllerResultSet
Exceptions:
SQLException if an error occurs
BadConnectionException if the connection was bad

Definition at line 282 of file AbstractLoadBalancer.java.

References java.sql.Statement.executeQuery(), java.sql.Statement.setCursorName(), java.sql.Statement.setFetchSize(), java.sql.Statement.setMaxRows(), java.sql.Statement.setQueryTimeout(), org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetCursorName, org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetFetchSize, org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetMaxRows, and org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetQueryTimeout.

Referenced by org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.execReadRequest().

00285   {
00286     ControllerResultSet rs = null;
00287     try
00288     {
00289       backend.addPendingReadRequest(request);
00290       String sql = request.getSQL();
00291       // Rewrite the query if needed
00292       sql = backend.rewriteQuery(sql);
00293 
00294       Statement s; // Can also be used as a PreparedStatement
00295       if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
00296         s = c.createStatement();
00297       else
00298       {
00299         s = c.prepareStatement(request.getSqlSkeleton());
00300         org.objectweb.cjdbc.driver.PreparedStatement.setPreparedStatement(sql,
00301             (PreparedStatement) s);
00302       }
00303 
00304       // Execute the query
00305       DriverCompliance driverCompliance = backend.getDriverCompliance();
00306       if (driverCompliance.supportSetQueryTimeout())
00307         s.setQueryTimeout(request.getTimeout());
00308       if ((request.getCursorName() != null)
00309           && (driverCompliance.supportSetCursorName()))
00310         s.setCursorName(request.getCursorName());
00311       if ((request.getFetchSize() != 0)
00312           && driverCompliance.supportSetFetchSize())
00313         s.setFetchSize(request.getFetchSize());
00314       if ((request.getMaxRows() > 0) && driverCompliance.supportSetMaxRows())
00315         s.setMaxRows(request.getMaxRows());
00316       if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
00317         rs = new ControllerResultSet(request, s.executeQuery(sql),
00318             metadataCache, s);
00319       else
00320         rs = new ControllerResultSet(request, ((PreparedStatement) s)
00321             .executeQuery(), metadataCache, s);
00322     }
00323     catch (SQLException e)
00324     { // Something bad happened
00325       if (backend.isValidConnection(c))
00326         throw e; // Connection is valid, throw the exception
00327       else
00328         throw new BadConnectionException(e);
00329     }
00330     finally
00331     {
00332       backend.removePendingRequest(request);
00333     }
00334     return rs;
00335   }

final int org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.executeUpdateRequestOnBackend (  AbstractWriteRequest  request,
DatabaseBackend  backend,
Connection  c
)  throws SQLException, BadConnectionException [static]
 

Execute an update prepared statement on a backend. If the execution fails, the connection is checked for validity. If the connection was not valid, the query is automatically retried on a new connection.

Parameters:
request the request to execute
backend the backend on which the request is executed
c connection used to create the statement
Returns:
int Number of rows effected
Exceptions:
SQLException if an error occurs
BadConnectionException if the connection was bad

Definition at line 349 of file AbstractLoadBalancer.java.

References java.sql.Statement.close(), java.sql.Statement.executeUpdate(), java.sql.Statement.setQueryTimeout(), and org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetQueryTimeout.

00352   {
00353     try
00354     {
00355       backend.addPendingWriteRequest(request);
00356       String sql = request.getSQL();
00357       // Rewrite the query if needed
00358       sql = backend.rewriteQuery(sql);
00359 
00360       Statement s; // Can also be used as a PreparedStatement
00361       if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
00362         s = c.createStatement();
00363       else
00364       {
00365         s = c.prepareStatement(request.getSqlSkeleton());
00366         org.objectweb.cjdbc.driver.PreparedStatement.setPreparedStatement(sql,
00367             (PreparedStatement) s);
00368       }
00369 
00370       // Execute the query
00371       DriverCompliance driverCompliance = backend.getDriverCompliance();
00372       if (driverCompliance.supportSetQueryTimeout())
00373         s.setQueryTimeout(request.getTimeout());
00374 
00375       int rows = 0;
00376       if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
00377         rows = s.executeUpdate(sql);
00378       else
00379         rows = ((PreparedStatement) s).executeUpdate();
00380 
00381       s.close();
00382       return rows;
00383     }
00384     catch (SQLException e)
00385     { // Something bad happened
00386       if (backend.isValidConnection(c))
00387         throw e; // Connection is valid, throw the exception
00388       else
00389         throw new BadConnectionException(e);
00390     }
00391     finally
00392     {
00393       backend.removePendingRequest(request);
00394     }
00395   }

final ControllerResultSet org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.executeUpdateRequestOnBackendWithKeys (  AbstractWriteRequest  request,
DatabaseBackend  backend,
Connection  c,
MetadataCache  metadataCache
)  throws SQLException, BadConnectionException [static]
 

Execute an update prepared statement on a backend. If the execution fails, the connection is checked for validity. If the connection was not valid, the query is automatically retried on a new connection.

Parameters:
request the request to execute
backend the backend on which the request is executed
c connection used to create the statement
metadataCache MetadataCache (null if none)
Returns:
ControllerResultSet containing the auto-generated keys
Exceptions:
SQLException if an error occurs
BadConnectionException if the connection was bad

Definition at line 410 of file AbstractLoadBalancer.java.

References java.sql.Statement.executeUpdate(), java.sql.Statement.setQueryTimeout(), and org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetQueryTimeout.

00413   {
00414     try
00415     {
00416       backend.addPendingWriteRequest(request);
00417       String sql = request.getSQL();
00418       // Rewrite the query if needed
00419       sql = backend.rewriteQuery(sql);
00420 
00421       Statement s = c.createStatement();
00422 
00423       // Execute the query
00424       DriverCompliance driverCompliance = backend.getDriverCompliance();
00425       if (driverCompliance.supportSetQueryTimeout())
00426         s.setQueryTimeout(request.getTimeout());
00427 
00428       s.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);
00429       ControllerResultSet rs = new ControllerResultSet(request, s
00430           .getGeneratedKeys(), metadataCache, s);
00431       return rs;
00432     }
00433     catch (SQLException e)
00434     { // Something bad happened
00435       if (backend.isValidConnection(c))
00436         throw e; // Connection is valid, throw the exception
00437       else
00438         throw new BadConnectionException(e);
00439     }
00440     finally
00441     {
00442       backend.removePendingRequest(request);
00443     }
00444   }

final int org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.executeWriteStoredProcedureOnBackend (  StoredProcedure  proc,
DatabaseBackend  backend,
Connection  c
)  throws SQLException, BadConnectionException [static]
 

Execute a write stored procedure on the given backend. The callable statement is setXXX if the driver has not processed the statement.

Parameters:
proc the stored procedure to execute
backend the backend on which to execute the stored procedure
c the connection on which to execute the stored procedure
Returns:
the number of updated rows
Exceptions:
SQLException if an error occurs
BadConnectionException if the connection was bad

Definition at line 510 of file AbstractLoadBalancer.java.

00513   {
00514     try
00515     {
00516       backend.addPendingWriteRequest(proc);
00517 
00518       // We suppose here that the request does not modify the schema since
00519       // it is a read-only query.
00520       CallableStatement cs;
00521       if (proc.isDriverProcessed())
00522         cs = c.prepareCall(proc.getSQL());
00523       else
00524       {
00525         cs = c.prepareCall(proc.getSqlSkeleton());
00526         org.objectweb.cjdbc.driver.PreparedStatement.setPreparedStatement(proc
00527             .getSQL(), cs);
00528       }
00529       if (backend.getDriverCompliance().supportSetQueryTimeout())
00530         cs.setQueryTimeout(proc.getTimeout());
00531       if ((proc.getMaxRows() > 0)
00532           && backend.getDriverCompliance().supportSetMaxRows())
00533         cs.setMaxRows(proc.getMaxRows());
00534       int rows = cs.executeUpdate();
00535       cs.close();
00536       return rows;
00537     }
00538     catch (SQLException e)
00539     { // Something bad happened
00540       if (backend.isValidConnection(c))
00541         throw e; // Connection is valid, throw the exception
00542       else
00543         throw new BadConnectionException(e);
00544     }
00545     finally
00546     {
00547       backend.removePendingRequest(proc);
00548     }
00549   }

abstract int org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.execWriteRequest (  AbstractWriteRequest  request  )  throws AllBackendsFailedException, SQLException [pure virtual]
 

Perform a write request. This request should usually be broadcasted to all nodes.

Parameters:
request an AbstractWriteRequest
Returns:
number of rows affected by the request
Exceptions:
AllBackendsFailedException if all backends failed to execute the request
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

abstract ControllerResultSet org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.execWriteRequestWithKeys (  AbstractWriteRequest  request,
MetadataCache  metadataCache
)  throws AllBackendsFailedException, SQLException [pure virtual]
 

Perform a write request and return a ResultSet containing the auto generated keys.

Parameters:
request an AbstractWriteRequest
metadataCache MetadataCache (null if none)
Returns:
auto generated keys
Exceptions:
AllBackendsFailedException if all backends failed to execute the request
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

abstract int org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.execWriteStoredProcedure (  StoredProcedure  proc  )  throws SQLException [pure virtual]
 

Call a stored procedure that performs an update.

Parameters:
proc the stored procedure call
Returns:
number of rows affected
Exceptions:
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

String org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getAssociatedString (   ) 
 

See also:
org.objectweb.cjdbc.controller.jmx.AbstractStandardMBean.getAssociatedString()

Definition at line 744 of file AbstractLoadBalancer.java.

00745   {
00746     return "loadbalancer";
00747   }

final Connection org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getConnectionAndBeginTransaction (  DatabaseBackend  backend,
AbstractConnectionManager  cm,
long  tid
)  throws SQLException, UnreachableBackendException [static]
 

Factorized code to start a transaction on a backend and to retrieve a connection on this backend

Parameters:
backend the backend needed to check valid connection against this backend test statement
cm the connection manager to use to retrieve connections
tid the id of the transaction to start
Returns:
a valid connection with a started transaction
Exceptions:
SQLException if the backend is valid but set autocommit cannot be set to false
UnreachableBackendException if the backend is not reachable, ie not valid connection can be retrieved

Definition at line 707 of file AbstractLoadBalancer.java.

00710   {
00711     Connection c = null;
00712     boolean isConnectionValid = false;
00713     do
00714     {
00715       c = cm.getConnection(tid);
00716 
00717       // Sanity check
00718       if (c == null)
00719         throw new UnreachableBackendException(Translate.get(
00720             "loadbalancer.unable.get.connection", new String[]{
00721                 String.valueOf(tid), backend.getName()}));
00722       try
00723       {
00724         c.setAutoCommit(false);
00725         isConnectionValid = true;
00726       }
00727       catch (SQLException e)
00728       {
00729         if (backend.isValidConnection(c))
00730           throw e; // Connection is valid, throw the exception
00731         else
00732         {
00733           cm.deleteConnection(tid);
00734         }
00735       }
00736     }
00737     while (!isConnectionValid);
00738     return c;
00739   }

abstract String org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getInformation (   )  [pure virtual]
 

Get information about the Request Load Balancer

Returns:
String containing information

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_LPRF, org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_LPRF, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_LPRF, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_RR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_WRR, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

int org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getParsingGranularity (   ) 
 

Get the needed query parsing granularity.

Returns:
needed query parsing granularity

Definition at line 176 of file AbstractLoadBalancer.java.

00177   {
00178     return parsingGranularity;
00179   }

int org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getRAIDbLevel (   ) 
 

Returns the RAIDbLevel.

Returns:
int the RAIDb level

Definition at line 156 of file AbstractLoadBalancer.java.

Referenced by org.objectweb.cjdbc.controller.loadbalancer.BackendWorkerThread.BackendWorkerThread().

00157   {
00158     return raidbLevel;
00159   }

String org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getXml (   ) 
 

See also:
org.objectweb.cjdbc.common.xml.XmlComponent.getXml()

Definition at line 684 of file AbstractLoadBalancer.java.

References org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getXmlImpl().

00685   {
00686     StringBuffer info = new StringBuffer();
00687     info.append("<" + DatabasesXmlTags.ELT_LoadBalancer + ">");
00688     info.append(getXmlImpl());
00689     info.append("</" + DatabasesXmlTags.ELT_LoadBalancer + ">");
00690     return info.toString();
00691   }

abstract String org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getXmlImpl (   )  [pure virtual]
 

Get information about the Request Load Balancer in xml

Returns:
String containing information, xml formatted

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

Referenced by org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getXml().

void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.handleMacros (  AbstractRequest  request  ) 
 

Interprets the macros in the request (depending on the MacroHandler set for this class) and modify either the skeleton or the query itself. Note that the given object is directly modified.

Parameters:
request the request to process

Definition at line 662 of file AbstractLoadBalancer.java.

References org.objectweb.cjdbc.common.sql.AbstractRequest.getSQL(), org.objectweb.cjdbc.common.sql.AbstractRequest.getSqlSkeleton(), org.objectweb.cjdbc.common.sql.AbstractWriteRequest.isAlter(), org.objectweb.cjdbc.common.sql.AbstractWriteRequest.isCreate(), org.objectweb.cjdbc.common.sql.AbstractRequest.isDriverProcessed(), org.objectweb.cjdbc.common.sql.AbstractWriteRequest.isDrop(), org.objectweb.cjdbc.common.sql.AbstractRequest.isWriteRequest(), org.objectweb.cjdbc.common.sql.AbstractRequest.setSQL(), and org.objectweb.cjdbc.common.sql.AbstractRequest.setSqlSkeleton().

Referenced by org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1.executeRequestOnBackend().

00663   {
00664     if (macroHandler == null)
00665       return;
00666 
00667     if (request.isWriteRequest())
00668     {
00669       AbstractWriteRequest writeReq = (AbstractWriteRequest) request;
00670       if (writeReq.isCreate() || writeReq.isAlter() || writeReq.isDrop())
00671         return;
00672     }
00673 
00674     if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
00675       request.setSQL(macroHandler.processMacros(request.getSQL()));
00676     else
00677       request.setSqlSkeleton(macroHandler.processMacros(request
00678           .getSqlSkeleton()));
00679   }

abstract void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.rollback (  TransactionMarkerMetaData  tm  )  throws AllBackendsFailedException, SQLException [pure virtual]
 

Rollback a transaction.

Parameters:
tm The transaction marker metadata
Exceptions:
AllBackendsFailedException if all backends failed to execute the request
SQLException if an error occurs

Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB, org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.setMacroHandler (  MacrosHandler  handler  ) 
 

This sets the macro handler for this load balancer. Handling macros prevents different backends to generate different values when interpreting the macros which could result in data inconsitencies.

Parameters:
handler MacrosHandler instance

Definition at line 649 of file AbstractLoadBalancer.java.

00650   {
00651     this.macroHandler = handler;
00652   }

void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.setParsingGranularity (  int  parsingGranularity  ) 
 

Set the needed query parsing granularity.

Parameters:
parsingGranularity the granularity to set

Definition at line 186 of file AbstractLoadBalancer.java.

00187   {
00188     this.parsingGranularity = parsingGranularity;
00189   }

void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.setRAIDbLevel (  int  raidbLevel  ) 
 

Sets the RAIDbLevel.

Parameters:
raidbLevel The RAIDb level to set

Definition at line 166 of file AbstractLoadBalancer.java.

00167   {
00168     this.raidbLevel = raidbLevel;
00169   }

void org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.setWeight (  String  name,
int  w
)  throws SQLException
 

Associate a weight to a backend identified by its logical name.

Parameters:
name the backend name
w the weight
Exceptions:
SQLException if an error occurs

Reimplemented in org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_WRR, org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_WRR, and org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.

Definition at line 619 of file AbstractLoadBalancer.java.

00620   {
00621     throw new SQLException("Weight is not supported by this load balancer");
00622   }

Member Data Documentation

Trace org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.logger [static, protected]
 

Initial value:

 Trace
                                       .getLogger("org.objectweb.cjdbc.controller.loadbalancer")

Definition at line 91 of file AbstractLoadBalancer.java.

The documentation for this class was generated from the following file:
Generated on Mon Apr 11 22:03:53 2005 for C-JDBC by  doxygen 1.3.9.1