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(). |
1.3.6