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