ParallelDB_LPRF.java の 45 行で定義されています。
Public メソッド | |
ParallelDB_LPRF (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 |
|
Creates a new
ParallelDB_LPRF.java の 54 行で定義されています。
00055 { 00056 super(vdb); 00057 } |
|
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 } |
|
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDBに実装されています. ParallelDB_LPRF.java の 62 行で定義されています。 参照先 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.backend.DatabaseBackend.getPendingRequests(), org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase.getSQLShortFormLength(), と org.objectweb.cjdbc.controller.backend.DatabaseBackend.isReadEnabled.
00064 { 00065 // Choose a backend 00066 try 00067 { 00068 vdb.acquireReadLockBackendLists(); 00069 } 00070 catch (InterruptedException e) 00071 { 00072 String msg = Translate.get( 00073 "loadbalancer.backendlist.acquire.readlock.failed", e); 00074 logger.error(msg); 00075 throw new SQLException(msg); 00076 } 00077 00078 DatabaseBackend backend = null; // The backend that will execute the query 00079 00080 // Note that vdb lock is released in the finally clause of this try/catch 00081 // block 00082 try 00083 { 00084 ArrayList backends = vdb.getBackends(); 00085 int size = backends.size(); 00086 00087 if (size == 0) 00088 throw new SQLException(Translate.get( 00089 "loadbalancer.execute.no.backend.available", request.getId())); 00090 00091 // Choose the backend that has the least pending requests 00092 int leastRequests = 0; 00093 for (int i = 0; i < size; i++) 00094 { 00095 DatabaseBackend b = (DatabaseBackend) backends.get(i); 00096 if (b.isReadEnabled()) 00097 { 00098 int pending = b.getPendingRequests().size(); 00099 if ((backend == null) || (pending < leastRequests)) 00100 { 00101 backend = b; 00102 if (pending == 0) 00103 break; // Stop here we will never find a less loaded node 00104 else 00105 leastRequests = pending; 00106 } 00107 } 00108 } 00109 00110 if (backend == null) 00111 throw new SQLException(Translate.get( 00112 "loadbalancer.execute.no.backend.enabled", request.getId())); 00113 } 00114 catch (RuntimeException e) 00115 { 00116 String msg = Translate.get("loadbalancer.execute.find.backend.failed", 00117 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()), 00118 e.getMessage()}); 00119 logger.error(msg, e); 00120 throw new SQLException(msg); 00121 } 00122 finally 00123 { 00124 vdb.releaseReadLockBackendLists(); 00125 } 00126 00127 return backend; 00128 } |
|
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDBに実装されています. ParallelDB_LPRF.java の 133 行で定義されています。 参照先 org.objectweb.cjdbc.controller.backend.DatabaseBackend.getPendingRequests(), と org.objectweb.cjdbc.controller.backend.DatabaseBackend.isWriteEnabled.
00135 { 00136 // Choose a backend 00137 try 00138 { 00139 vdb.acquireReadLockBackendLists(); 00140 } 00141 catch (InterruptedException e) 00142 { 00143 String msg = Translate.get( 00144 "loadbalancer.backendlist.acquire.readlock.failed", e); 00145 logger.error(msg); 00146 throw new SQLException(msg); 00147 } 00148 00149 DatabaseBackend backend = null; // The backend that will execute the query 00150 00151 // Note that vdb lock is released in the finally clause of this try/catch 00152 // block 00153 try 00154 { 00155 ArrayList backends = vdb.getBackends(); 00156 int size = backends.size(); 00157 00158 if (size == 0) 00159 throw new SQLException(Translate.get( 00160 "loadbalancer.execute.no.backend.available", request.getId())); 00161 00162 // Choose the backend that has the least pending requests 00163 int leastRequests = 0; 00164 for (int i = 0; i < size; i++) 00165 { 00166 DatabaseBackend b = (DatabaseBackend) backends.get(i); 00167 if (b.isWriteEnabled()) 00168 { 00169 int pending = b.getPendingRequests().size(); 00170 if ((backend == null) || (pending < leastRequests)) 00171 { 00172 backend = b; 00173 if (pending == 0) 00174 break; // Stop here we will never find a less loaded node 00175 else 00176 leastRequests = pending; 00177 } 00178 } 00179 } 00180 00181 if (backend == null) 00182 { 00183 throw new SQLException(Translate.get( 00184 "loadbalancer.execute.no.backend.enabled", request.getId())); 00185 } 00186 } 00187 catch (RuntimeException e) 00188 { 00189 String msg = Translate.get("loadbalancer.execute.find.backend.failed", 00190 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()), 00191 e.getMessage()}); 00192 logger.error(msg, e); 00193 throw new SQLException(msg); 00194 } 00195 finally 00196 { 00197 vdb.releaseReadLockBackendLists(); 00198 } 00199 00200 return backend; 00201 } |
|
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_LPRF.java の 206 行で定義されています。
00207 { 00208 // We don't lock since we don't need a top accurate value 00209 int size = vdb.getBackends().size(); 00210 00211 if (size == 0) 00212 return "ParallelDB Least Pending Request First Request load balancer: !!!Warning!!! No backend nodes found\n"; 00213 else 00214 return "ParallelDB Least Pending Request First Request load balancer (" 00215 + size + " backends)\n"; 00216 } |
|
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDBに実装されています. ParallelDB_LPRF.java の 221 行で定義されています。
00222 { 00223 return "<" + DatabasesXmlTags.ELT_ParallelDB_LeastPendingRequestsFirst 00224 + "/>"; 00225 } |
|
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 } |
|
初期値: 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(). |