ParallelDB_RR.java の 44 行で定義されています。
Public メソッド | |
ParallelDB_RR (VirtualDatabase vdb) throws SQLException | |
DatabaseBackend | chooseBackendForReadRequest (AbstractRequest request) throws SQLException |
DatabaseBackend | chooseBackendForWriteRequest (AbstractWriteRequest request) throws SQLException |
String | getInformation () |
String | getParallelDBXml () |
ResultSet | execReadRequest (SelectRequest request) throws SQLException |
ResultSet | execReadOnlyReadStoredProcedure (StoredProcedure proc) throws SQLException |
ResultSet | execReadStoredProcedure (StoredProcedure proc) throws SQLException |
int | execWriteRequest (AbstractWriteRequest request) throws AllBackendsFailedException, SQLException |
ResultSet | execWriteRequestWithKeys (AbstractWriteRequest request) throws AllBackendsFailedException, SQLException |
int | execWriteStoredProcedure (StoredProcedure proc) throws SQLException |
void | begin (TransactionMarkerMetaData tm) throws SQLException |
void | commit (TransactionMarkerMetaData tm) throws SQLException |
void | rollback (TransactionMarkerMetaData tm) throws SQLException |
void | enableBackend (DatabaseBackend db, boolean writeEnabled) throws SQLException |
void | disableBackend (DatabaseBackend db) throws SQLException |
String | getXmlImpl () |
int | getRAIDbLevel () |
void | setRAIDbLevel (int raidbLevel) |
int | getParsingGranularity () |
void | setParsingGranularity (int parsingGranularity) |
void | setWeight (String name, int w) throws SQLException |
String | getXml () |
Protected メソッド | |
ResultSet | executeStatementOnBackend (SelectRequest request, DatabaseBackend backend, Connection c) throws SQLException, BadConnectionException |
Protected 変数 | |
VirtualDatabase | vdb |
int | raidbLevel |
int | parsingGranularity |
Static Protected 変数 | |
Trace | logger |
Private 変数 | |
int | index = 0 |
|
Creates a new
ParallelDB_RR.java の 55 行で定義されています。
00056 { 00057 super(vdb); 00058 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 1042 行で定義されています。 参照先 org.objectweb.cjdbc.controller.backend.DatabaseBackend.startTransaction().
01043 { 01044 Long lTid = new Long(tm.getTransactionId()); 01045 if (backendPerTransactionId.containsKey(lTid)) 01046 throw new SQLException(Translate.get( 01047 "loadbalancer.transaction.already.started", lTid.toString())); 01048 01049 DatabaseBackend backend = chooseBackendForReadRequest(new UnknownRequest( 01050 "begin", false, 0)); 01051 backendPerTransactionId.put(lTid, backend); 01052 backend.startTransaction(lTid); 01053 } |
|
Choose a backend using a round-robin algorithm for read request execution.
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDBに実装されています. ParallelDB_RR.java の 67 行で定義されています。 参照先 org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase.acquireReadLockBackendLists(), org.objectweb.cjdbc.common.log.Trace.error(), org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase.getBackends(), org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase.getSQLShortFormLength(), org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RR.index, と org.objectweb.cjdbc.controller.backend.DatabaseBackend.isReadEnabled.
00069 { 00070 // Choose a backend 00071 try 00072 { 00073 vdb.acquireReadLockBackendLists(); 00074 } 00075 catch (InterruptedException e) 00076 { 00077 String msg = Translate.get( 00078 "loadbalancer.backendlist.acquire.readlock.failed", e); 00079 logger.error(msg); 00080 throw new SQLException(msg); 00081 } 00082 00083 DatabaseBackend backend = null; // The backend that will execute the query 00084 00085 // Note that vdb lock is released in the finally clause of this try/catch 00086 // block 00087 try 00088 { 00089 ArrayList backends = vdb.getBackends(); 00090 int size = backends.size(); 00091 00092 if (size == 0) 00093 throw new SQLException(Translate.get( 00094 "loadbalancer.execute.no.backend.available", request.getId())); 00095 00096 // Take the next backend 00097 int maxTries = size; 00098 synchronized (this) 00099 { 00100 do 00101 { 00102 index = (index + 1) % size; 00103 backend = (DatabaseBackend) backends.get(index); 00104 maxTries--; 00105 } 00106 while ((!backend.isReadEnabled() && maxTries >= 0)); 00107 } 00108 00109 if (maxTries < 0) 00110 throw new SQLException(Translate.get( 00111 "loadbalancer.execute.no.backend.enabled", request.getId())); 00112 } 00113 catch (RuntimeException e) 00114 { 00115 String msg = Translate.get("loadbalancer.execute.find.backend.failed", 00116 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()), 00117 e.getMessage()}); 00118 logger.error(msg, e); 00119 throw new SQLException(msg); 00120 } 00121 finally 00122 { 00123 vdb.releaseReadLockBackendLists(); 00124 } 00125 return backend; 00126 } |
|
Choose a backend using a round-robin algorithm for write request execution.
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDBに実装されています. ParallelDB_RR.java の 135 行で定義されています。 参照先 org.objectweb.cjdbc.controller.backend.DatabaseBackend.isWriteEnabled.
00137 { 00138 // Choose a backend 00139 try 00140 { 00141 vdb.acquireReadLockBackendLists(); 00142 } 00143 catch (InterruptedException e) 00144 { 00145 String msg = Translate.get( 00146 "loadbalancer.backendlist.acquire.readlock.failed", e); 00147 logger.error(msg); 00148 throw new SQLException(msg); 00149 } 00150 00151 DatabaseBackend backend = null; // The backend that will execute the query 00152 00153 // Note that vdb lock is released in the finally clause of this try/catch 00154 // block 00155 try 00156 { 00157 ArrayList backends = vdb.getBackends(); 00158 int size = backends.size(); 00159 00160 if (size == 0) 00161 throw new SQLException(Translate.get( 00162 "loadbalancer.execute.no.backend.available", request.getId())); 00163 00164 // Take the next backend 00165 int maxTries = size; 00166 synchronized (this) 00167 { 00168 do 00169 { 00170 index = (index + 1) % size; 00171 backend = (DatabaseBackend) backends.get(index); 00172 maxTries--; 00173 } 00174 while ((!backend.isWriteEnabled() && maxTries >= 0)); 00175 } 00176 00177 if (maxTries < 0) 00178 throw new SQLException(Translate.get( 00179 "loadbalancer.execute.no.backend.enabled", request.getId())); 00180 } 00181 catch (RuntimeException e) 00182 { 00183 String msg = Translate.get("loadbalancer.execute.find.backend.failed", 00184 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()), 00185 e.getMessage()}); 00186 logger.error(msg, e); 00187 throw new SQLException(msg); 00188 } 00189 finally 00190 { 00191 vdb.releaseReadLockBackendLists(); 00192 } 00193 return backend; 00194 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 1058 行で定義されています。 参照先 org.objectweb.cjdbc.controller.backend.DatabaseBackend.getConnectionManager(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.getName(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.retrieveConnection(), と org.objectweb.cjdbc.controller.backend.DatabaseBackend.stopTransaction().
01059 { 01060 long tid = tm.getTransactionId(); 01061 Long lTid = new Long(tid); 01062 DatabaseBackend db = (DatabaseBackend) backendPerTransactionId.remove(lTid); 01063 01064 AbstractConnectionManager cm = db.getConnectionManager(tm.getLogin()); 01065 Connection c = cm.retrieveConnection(tid); 01066 01067 // Sanity check 01068 if (c == null) 01069 { // Bad connection 01070 db.stopTransaction(lTid); 01071 01072 throw new SQLException(Translate.get( 01073 "loadbalancer.unable.retrieve.connection", new String[]{ 01074 String.valueOf(tid), db.getName()})); 01075 } 01076 01077 // Execute Query 01078 try 01079 { 01080 c.commit(); 01081 c.setAutoCommit(true); 01082 } 01083 catch (Exception e) 01084 { 01085 String msg = Translate.get("loadbalancer.commit.failed", new String[]{ 01086 String.valueOf(tid), db.getName(), e.getMessage()}); 01087 logger.error(msg); 01088 throw new SQLException(msg); 01089 } 01090 finally 01091 { 01092 cm.releaseConnection(tid); 01093 db.stopTransaction(lTid); 01094 } 01095 } |
|
Disables a backend that was previously enabled. Asks the corresponding connection manager to finalize the connections if needed. No sanity checks are performed by this function.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 1169 行で定義されています。
01170 { 01171 logger.info(Translate.get("loadbalancer.backend.disabling", db.getName())); 01172 db.disable(); 01173 if (db.isInitialized()) 01174 db.finalizeConnections(); 01175 } |
|
Enables a backend that was previously disabled. Asks the corresponding connection manager to initialize the connections if needed. No sanity checks are performed by this function.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 1149 行で定義されています。
01151 { 01152 logger.info(Translate.get("loadbalancer.backend.enabling", db.getName())); 01153 if (!db.isInitialized()) 01154 db.initializeConnections(); 01155 db.enableRead(); 01156 if (writeEnabled) 01157 db.enableWrite(); 01158 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 136 行で定義されています。
00138 { 00139 return execReadStoredProcedure(proc); 00140 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 88 行で定義されています。 参照先 org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB.backendPerTransactionId, org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB.chooseBackendForReadRequest(), org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB.executeReadRequestOnBackend(), org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase.getSQLShortFormLength(), org.objectweb.cjdbc.common.log.Trace.info(), と org.objectweb.cjdbc.common.log.Trace.isInfoEnabled().
00089 { 00090 DatabaseBackend backend; 00091 if (request.isAutoCommit()) 00092 backend = chooseBackendForReadRequest(request); 00093 else 00094 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(request 00095 .getTransactionId())); 00096 00097 if (backend == null) 00098 throw new SQLException(Translate.get( 00099 "loadbalancer.execute.no.backend.found", request.getSQLShortForm(vdb 00100 .getSQLShortFormLength()))); 00101 00102 ResultSet rs = null; 00103 // Execute the request on the chosen backend 00104 try 00105 { 00106 rs = executeReadRequestOnBackend((SelectRequest) request, backend); 00107 } 00108 catch (UnreachableBackendException urbe) 00109 { 00110 // Try to execute query on different backend 00111 return execReadRequest(request); 00112 } 00113 catch (SQLException se) 00114 { 00115 String msg = Translate.get("loadbalancer.request.failed", new String[]{ 00116 String.valueOf(request.getId()), se.getMessage()}); 00117 if (logger.isInfoEnabled()) 00118 logger.info(msg); 00119 throw new SQLException(msg); 00120 } 00121 catch (RuntimeException e) 00122 { 00123 String msg = Translate.get("loadbalancer.request.failed.on.backend", 00124 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()), 00125 backend.getName(), e.getMessage()}); 00126 logger.error(msg, e); 00127 throw new SQLException(msg); 00128 } 00129 00130 return rs; 00131 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 145 行で定義されています。
00147 { 00148 DatabaseBackend backend; 00149 if (proc.isAutoCommit()) 00150 backend = chooseBackendForReadRequest(proc); 00151 else 00152 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(proc 00153 .getTransactionId())); 00154 00155 if (backend == null) 00156 throw new SQLException(Translate.get( 00157 "loadbalancer.storedprocedure.no.backend.found", proc 00158 .getSQLShortForm(vdb.getSQLShortFormLength()))); 00159 00160 ResultSet rs = null; 00161 // Execute the request on the chosen backend 00162 try 00163 { 00164 rs = executeReadStoredProcedureOnBackend((StoredProcedure) proc, backend); 00165 } 00166 catch (UnreachableBackendException urbe) 00167 { 00168 // Try to execute query on different backend 00169 return execReadStoredProcedure(proc); 00170 } 00171 catch (SQLException se) 00172 { 00173 String msg = Translate.get("loadbalancer.storedprocedure.failed", 00174 new String[]{String.valueOf(proc.getId()), se.getMessage()}); 00175 if (logger.isInfoEnabled()) 00176 logger.info(msg); 00177 throw new SQLException(msg); 00178 } 00179 catch (RuntimeException e) 00180 { 00181 String msg = Translate.get( 00182 "loadbalancer.storedprocedure.failed.on.backend", new String[]{ 00183 proc.getSQLShortForm(vdb.getSQLShortFormLength()), 00184 backend.getName(), e.getMessage()}); 00185 logger.error(msg, e); 00186 throw new SQLException(msg); 00187 } 00188 00189 return rs; 00190 } |
|
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.
AbstractLoadBalancer.java の 251 行で定義されています。 参照先 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, と org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetQueryTimeout. 参照元 org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.execReadRequest().
00254 { 00255 ResultSet rs = null; 00256 try 00257 { 00258 backend.addPendingReadRequest(request); 00259 String sql = request.getSQL(); 00260 // Rewrite the query if needed 00261 sql = backend.rewriteQuery(sql); 00262 // Execute the query 00263 Statement s = c.createStatement(); 00264 DriverCompliance driverCompliance = backend.getDriverCompliance(); 00265 if (driverCompliance.supportSetQueryTimeout()) 00266 s.setQueryTimeout(request.getTimeout()); 00267 if ((request.getCursorName() != null) 00268 && (driverCompliance.supportSetCursorName())) 00269 s.setCursorName(request.getCursorName()); 00270 if ((request.getFetchSize() != 0) 00271 && driverCompliance.supportSetFetchSize()) 00272 s.setFetchSize(request.getFetchSize()); 00273 if ((request.getMaxRows() > 0) && driverCompliance.supportSetMaxRows()) 00274 s.setMaxRows(request.getMaxRows()); 00275 rs = s.executeQuery(sql); 00276 } 00277 catch (SQLException e) 00278 { // Something bad happened 00279 if (backend.isValidConnection(c)) 00280 throw e; // Connection is valid, throw the exception 00281 else 00282 throw new BadConnectionException(); 00283 } 00284 finally 00285 { 00286 backend.removePendingRequest(request); 00287 } 00288 return rs; 00289 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 195 行で定義されています。
00197 { 00198 DatabaseBackend backend; 00199 if (request.isAutoCommit()) 00200 backend = chooseBackendForWriteRequest(request); 00201 else 00202 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(request 00203 .getTransactionId())); 00204 00205 if (backend == null) 00206 throw new SQLException(Translate.get( 00207 "loadbalancer.execute.no.backend.found", request.getSQLShortForm(vdb 00208 .getSQLShortFormLength()))); 00209 00210 int result; 00211 // Execute the request on the chosen backend 00212 try 00213 { 00214 result = executeWriteRequestOnBackend(request, backend); 00215 } 00216 catch (UnreachableBackendException urbe) 00217 { 00218 // Try to execute query on different backend 00219 return execWriteRequest(request); 00220 } 00221 catch (SQLException se) 00222 { 00223 String msg = Translate.get("loadbalancer.request.failed", new String[]{ 00224 String.valueOf(request.getId()), se.getMessage()}); 00225 if (logger.isInfoEnabled()) 00226 logger.info(msg); 00227 throw new SQLException(msg); 00228 } 00229 catch (RuntimeException e) 00230 { 00231 String msg = Translate.get("loadbalancer.request.failed.on.backend", 00232 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()), 00233 backend.getName(), e.getMessage()}); 00234 logger.error(msg, e); 00235 throw new SQLException(msg); 00236 } 00237 00238 return result; 00239 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 244 行で定義されています。
00246 { 00247 DatabaseBackend backend; 00248 if (request.isAutoCommit()) 00249 backend = chooseBackendForWriteRequest(request); 00250 else 00251 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(request 00252 .getTransactionId())); 00253 00254 if (backend == null) 00255 throw new SQLException(Translate.get( 00256 "loadbalancer.execute.no.backend.found", request.getSQLShortForm(vdb 00257 .getSQLShortFormLength()))); 00258 00259 ResultSet rs; 00260 // Execute the request on the chosen backend 00261 try 00262 { 00263 rs = executeWriteRequestWithKeysOnBackend(request, backend); 00264 } 00265 catch (UnreachableBackendException urbe) 00266 { 00267 // Try to execute query on different backend 00268 return execWriteRequestWithKeys(request); 00269 } 00270 catch (SQLException se) 00271 { 00272 String msg = Translate.get("loadbalancer.request.failed", new String[]{ 00273 String.valueOf(request.getId()), se.getMessage()}); 00274 if (logger.isInfoEnabled()) 00275 logger.info(msg); 00276 throw new SQLException(msg); 00277 } 00278 catch (RuntimeException e) 00279 { 00280 String msg = Translate.get("loadbalancer.request.failed.on.backend", 00281 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()), 00282 backend.getName(), e.getMessage()}); 00283 logger.error(msg, e); 00284 throw new SQLException(msg); 00285 } 00286 00287 return rs; 00288 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 293 行で定義されています。
00294 { 00295 DatabaseBackend backend; 00296 if (proc.isAutoCommit()) 00297 backend = chooseBackendForReadRequest(proc); 00298 else 00299 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(proc 00300 .getTransactionId())); 00301 00302 if (backend == null) 00303 throw new SQLException(Translate.get( 00304 "loadbalancer.storedprocedure.no.backend.found", proc 00305 .getSQLShortForm(vdb.getSQLShortFormLength()))); 00306 00307 int result; 00308 // Execute the request on the chosen backend 00309 try 00310 { 00311 result = executeWriteStoredProcedureOnBackend(proc, backend); 00312 } 00313 catch (UnreachableBackendException urbe) 00314 { 00315 // Try to execute query on different backend 00316 return execWriteStoredProcedure(proc); 00317 } 00318 catch (SQLException se) 00319 { 00320 String msg = Translate.get("loadbalancer.storedprocedure.failed", 00321 new String[]{String.valueOf(proc.getId()), se.getMessage()}); 00322 if (logger.isInfoEnabled()) 00323 logger.info(msg); 00324 throw new SQLException(msg); 00325 } 00326 catch (RuntimeException e) 00327 { 00328 String msg = Translate.get( 00329 "loadbalancer.storedprocedure.failed.on.backend", new String[]{ 00330 proc.getSQLShortForm(vdb.getSQLShortFormLength()), 00331 backend.getName(), e.getMessage()}); 00332 logger.error(msg, e); 00333 throw new SQLException(msg); 00334 } 00335 00336 return result; 00337 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB_RR.java の 199 行で定義されています。
00200 { 00201 // We don't lock since we don't need a top accurate value 00202 int size = vdb.getBackends().size(); 00203 00204 if (size == 0) 00205 return "ParallelDB Round-Robin Request load balancer: !!!Warning!!! No backend nodes found\n"; 00206 else 00207 return "ParallelDB Round-Robin Request load balancer (" + size 00208 + " backends)\n"; 00209 } |
|
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDBに実装されています. ParallelDB_RR.java の 214 行で定義されています。
00215 { 00216 return "<" + DatabasesXmlTags.ELT_ParallelDB_RoundRobin + "/>"; 00217 } |
|
Get the needed query parsing granularity.
AbstractLoadBalancer.java の 151 行で定義されています。 参照元 org.objectweb.cjdbc.controller.requestmanager.RequestManager.setLoadBalancer().
00152 { 00153 return parsingGranularity; 00154 } |
|
Returns the RAIDbLevel.
AbstractLoadBalancer.java の 131 行で定義されています。 参照先 org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.raidbLevel.
00132 { 00133 return raidbLevel; 00134 } |
|
AbstractLoadBalancer.java の 385 行で定義されています。 参照先 org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getXmlImpl().
00386 { 00387 StringBuffer info = new StringBuffer(); 00388 info.append("<" + DatabasesXmlTags.ELT_LoadBalancer + ">"); 00389 info.append(getXmlImpl()); 00390 info.append("</" + DatabasesXmlTags.ELT_LoadBalancer + ">"); 00391 return info.toString(); 00392 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 1180 行で定義されています。
01181 { 01182 StringBuffer info = new StringBuffer(); 01183 info.append("<" + DatabasesXmlTags.ELT_ParallelDB + ">"); 01184 info.append(getParallelDBXml()); 01185 info.append("</" + DatabasesXmlTags.ELT_ParallelDB + ">"); 01186 return info.toString(); 01187 } |
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. ParallelDB.java の 1100 行で定義されています。 参照先 org.objectweb.cjdbc.controller.backend.DatabaseBackend.getConnectionManager(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.getName(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.retrieveConnection(), と org.objectweb.cjdbc.controller.backend.DatabaseBackend.stopTransaction().
01101 { 01102 long tid = tm.getTransactionId(); 01103 Long lTid = new Long(tid); 01104 DatabaseBackend db = (DatabaseBackend) backendPerTransactionId.remove(lTid); 01105 01106 AbstractConnectionManager cm = db.getConnectionManager(tm.getLogin()); 01107 Connection c = cm.retrieveConnection(tid); 01108 01109 // Sanity check 01110 if (c == null) 01111 { // Bad connection 01112 db.stopTransaction(lTid); 01113 01114 throw new SQLException(Translate.get( 01115 "loadbalancer.unable.retrieve.connection", new String[]{ 01116 String.valueOf(tid), db.getName()})); 01117 } 01118 01119 // Execute Query 01120 try 01121 { 01122 c.rollback(); 01123 c.setAutoCommit(true); 01124 } 01125 catch (Exception e) 01126 { 01127 String msg = Translate.get("loadbalancer.rollback.failed", new String[]{ 01128 String.valueOf(tid), db.getName(), e.getMessage()}); 01129 logger.error(msg); 01130 throw new SQLException(msg); 01131 } 01132 finally 01133 { 01134 cm.releaseConnection(tid); 01135 db.stopTransaction(lTid); 01136 } 01137 } |
|
Set the needed query parsing granularity.
AbstractLoadBalancer.java の 161 行で定義されています。
00162 {
00163 this.parsingGranularity = parsingGranularity;
00164 }
|
|
Sets the RAIDbLevel.
AbstractLoadBalancer.java の 141 行で定義されています。
00142 {
00143 this.raidbLevel = raidbLevel;
00144 }
|
|
Associate a weight to a backend identified by its logical name.
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, と org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDBで再定義されています。 AbstractLoadBalancer.java の 359 行で定義されています。
00360 { 00361 throw new SQLException("Weight is not supported by this load balancer"); 00362 } |
|
ParallelDB_RR.java の 47 行で定義されています。 参照元 org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RR.chooseBackendForReadRequest(). |
|
初期値: Trace
.getLogger("org.objectweb.cjdbc.controller.loadbalancer")
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, と org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDBで再定義されています。 AbstractLoadBalancer.java の 76 行で定義されています。 |
|
AbstractLoadBalancer.java の 74 行で定義されています。 |
|
|
AbstractLoadBalancer.java の 72 行で定義されています。 参照元 org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.AbstractLoadBalancer(). |