Read and write queries are load balanced on the backends without any replication (assuming that the underlying parallel database takes care of data replication). The load balancers provide failover for reads and writes.
ParallelDB.java の 68 行で定義されています。
Public メソッド | |
| ParallelDB (VirtualDatabase vdb) throws SQLException | |
| 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 () |
| abstract String | getParallelDBXml () |
| abstract DatabaseBackend | chooseBackendForReadRequest (AbstractRequest request) throws SQLException |
| abstract DatabaseBackend | chooseBackendForWriteRequest (AbstractWriteRequest request) throws SQLException |
| int | getRAIDbLevel () |
| void | setRAIDbLevel (int raidbLevel) |
| int | getParsingGranularity () |
| void | setParsingGranularity (int parsingGranularity) |
| void | setWeight (String name, int w) throws SQLException |
| abstract String | getInformation () |
| 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 メソッド | |
| java.sql.ResultSet | executeReadRequestOnBackend (SelectRequest request, DatabaseBackend backend) throws SQLException, UnreachableBackendException |
| java.sql.ResultSet | executeReadStoredProcedureOnBackend (StoredProcedure proc, DatabaseBackend backend) throws SQLException, UnreachableBackendException |
| int | executeWriteRequestOnBackend (AbstractWriteRequest request, DatabaseBackend backend) throws SQLException, UnreachableBackendException |
| java.sql.ResultSet | executeWriteRequestWithKeysOnBackend (AbstractWriteRequest request, DatabaseBackend backend) throws SQLException, UnreachableBackendException |
| int | executeWriteStoredProcedureOnBackend (StoredProcedure proc, DatabaseBackend backend) throws SQLException, UnreachableBackendException |
Private 変数 | |
| Hashtable | backendPerTransactionId |
|
|
Creates a new
ParallelDB.java の 80 行で定義されています。
00081 {
00082 super(vdb, RAIDbLevels.SingleDB, ParsingGranularities.NO_PARSING);
00083 }
|
|
|
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 the implementation specific load balancing algorithm for read request execution.
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_LPRF, と org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RRを実装しています. 参照元 org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB.execReadRequest(). |
|
|
Choose a backend using the implementation specific load balancing algorithm for write request execution.
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_LPRF, と org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RRを実装しています. |
|
|
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 read request on the selected backend.
ParallelDB.java の 347 行で定義されています。 参照元 org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB.execReadRequest().
00349 {
00350 // Ok, we have a backend, let's execute the request
00351 AbstractConnectionManager cm = backend.getConnectionManager(request
00352 .getLogin());
00353
00354 // Sanity check
00355 if (cm == null)
00356 {
00357 String msg = Translate.get("loadbalancer.connectionmanager.not.found",
00358 new String[]{request.getLogin(), backend.getName()});
00359 logger.error(msg);
00360 throw new SQLException(msg);
00361 }
00362
00363 // Execute the query
00364 if (request.isAutoCommit())
00365 {
00366 ResultSet rs = null;
00367 boolean badConnection;
00368 do
00369 {
00370 badConnection = false;
00371 // Use a connection just for this request
00372 Connection c = null;
00373 try
00374 {
00375 c = cm.getConnection();
00376 }
00377 catch (UnreachableBackendException e1)
00378 {
00379 logger.error(Translate.get(
00380 "loadbalancer.backend.disabling.unreachable", backend.getName()));
00381 backend.disable();
00382 throw new UnreachableBackendException(Translate.get(
00383 "loadbalancer.backend.unreacheable", backend.getName()));
00384 }
00385
00386 // Sanity check
00387 if (c == null)
00388 throw new SQLException(Translate.get(
00389 "loadbalancer.backend.no.connection", backend.getName()));
00390
00391 // Execute Query
00392 try
00393 {
00394 rs = executeStatementOnBackend(request, backend, c);
00395 cm.releaseConnection(c);
00396 }
00397 catch (SQLException e)
00398 {
00399 cm.releaseConnection(c);
00400 String msg = Translate.get("loadbalancer.request.failed.on.backend",
00401 new String[]{
00402 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00403 backend.getName(), e.getMessage()});
00404 }
00405 catch (BadConnectionException e)
00406 { // Get rid of the bad connection
00407 cm.deleteConnection(c);
00408 badConnection = true;
00409 }
00410 }
00411 while (badConnection);
00412 if (logger.isDebugEnabled())
00413 logger.debug(Translate.get("loadbalancer.execute.on", new String[]{
00414 String.valueOf(request.getId()), backend.getName()}));
00415 return rs;
00416 }
00417 else
00418 { // Inside a transaction
00419 Connection c;
00420 long tid = request.getTransactionId();
00421 Long lTid = new Long(tid);
00422
00423 if (!backend.isStartedTransaction(lTid))
00424 { // transaction has not been started yet on this backend
00425 try
00426 {
00427 c = cm.getConnection(tid);
00428 }
00429 catch (UnreachableBackendException e1)
00430 {
00431 logger.error(Translate.get(
00432 "loadbalancer.backend.disabling.unreachable", backend.getName()));
00433 backend.disable();
00434 throw new UnreachableBackendException(Translate.get(
00435 "loadbalancer.backend.unreacheable", backend.getName()));
00436 }
00437
00438 // Sanity check
00439 if (c == null)
00440 throw new SQLException(Translate.get(
00441 "loadbalancer.unable.get.connection", new String[]{
00442 String.valueOf(tid), backend.getName()}));
00443
00444 // begin transaction
00445 backend.startTransaction(lTid);
00446 c.setAutoCommit(false);
00447 }
00448 else
00449 { // Re-use the connection used by this transaction
00450 c = cm.retrieveConnection(tid);
00451
00452 // Sanity check
00453 if (c == null)
00454 throw new SQLException(Translate.get(
00455 "loadbalancer.unable.retrieve.connection", new String[]{
00456 String.valueOf(tid), backend.getName()}));
00457 }
00458
00459 // Execute Query
00460 ResultSet rs = null;
00461 try
00462 {
00463 rs = executeStatementOnBackend(request, backend, c);
00464 }
00465 catch (SQLException e)
00466 {
00467 String msg = Translate.get("loadbalancer.request.failed.on.backend",
00468 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()),
00469 backend.getName(), e.getMessage()});
00470 }
00471 catch (BadConnectionException e)
00472 { // Connection failed, so did the transaction
00473 // Disable the backend.
00474 cm.deleteConnection(tid);
00475 String msg = Translate.get(
00476 "loadbalancer.backend.disabling.connection.failure", backend
00477 .getName());
00478 logger.error(msg);
00479 backend.disable();
00480 throw new SQLException(msg);
00481 }
00482 if (logger.isDebugEnabled())
00483 logger.debug(Translate.get("loadbalancer.execute.transaction.on",
00484 new String[]{String.valueOf(tid), String.valueOf(request.getId()),
00485 backend.getName()}));
00486 return rs;
00487 }
00488 }
|
|
||||||||||||
|
Execute a stored procedure on the selected backend.
ParallelDB.java の 498 行で定義されています。
00501 {
00502 // Ok, we have a backend, let's execute the request
00503 AbstractConnectionManager cm = backend
00504 .getConnectionManager(proc.getLogin());
00505
00506 // Sanity check
00507 if (cm == null)
00508 {
00509 String msg = Translate.get("loadbalancer.connectionmanager.not.found",
00510 new String[]{proc.getLogin(), backend.getName()});
00511 logger.error(msg);
00512 throw new SQLException(msg);
00513 }
00514
00515 // Execute the query
00516 if (proc.isAutoCommit())
00517 {
00518 // Use a connection just for this request
00519 Connection c = null;
00520 try
00521 {
00522 c = cm.getConnection();
00523 }
00524 catch (UnreachableBackendException e1)
00525 {
00526 logger.error(Translate.get(
00527 "loadbalancer.backend.disabling.unreachable", backend.getName()));
00528 backend.disable();
00529 throw new UnreachableBackendException(Translate.get(
00530 "loadbalancer.backend.unreacheable", backend.getName()));
00531 }
00532
00533 // Sanity check
00534 if (c == null)
00535 throw new UnreachableBackendException(Translate.get(
00536 "loadbalancer.backend.no.connection", backend.getName()));
00537
00538 // Execute Query
00539 ResultSet rs = null;
00540 try
00541 {
00542 // We suppose here that the request does not modify the schema since
00543 // it is a read-only query.
00544 CallableStatement cs = c.prepareCall(proc.getSQL());
00545 if (backend.getDriverCompliance().supportSetQueryTimeout())
00546 cs.setQueryTimeout(proc.getTimeout());
00547 if ((proc.getMaxRows() > 0)
00548 && backend.getDriverCompliance().supportSetMaxRows())
00549 cs.setMaxRows(proc.getMaxRows());
00550 rs = cs.executeQuery();
00551 }
00552 catch (SQLException e)
00553 {
00554 throw new SQLException(Translate.get(
00555 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00556 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00557 backend.getName(), e.getMessage()}));
00558 }
00559 finally
00560 {
00561 cm.releaseConnection(c);
00562 }
00563 if (logger.isDebugEnabled())
00564 logger.debug(Translate.get("loadbalancer.storedprocedure.on",
00565 new String[]{String.valueOf(proc.getId()), backend.getName()}));
00566 return rs;
00567 }
00568 else
00569 { // Inside a transaction
00570 Connection c;
00571 long tid = proc.getTransactionId();
00572 Long lTid = new Long(tid);
00573
00574 if (!backend.isStartedTransaction(lTid))
00575 { // transaction has not been started yet on this backend
00576 try
00577 {
00578 c = cm.getConnection(tid);
00579 }
00580 catch (UnreachableBackendException e1)
00581 {
00582 logger.error(Translate.get(
00583 "loadbalancer.backend.disabling.unreachable", backend.getName()));
00584 backend.disable();
00585 throw new UnreachableBackendException(Translate.get(
00586 "loadbalancer.backend.unreacheable", backend.getName()));
00587 }
00588
00589 // Sanity check
00590 if (c == null)
00591 throw new SQLException(Translate.get(
00592 "loadbalancer.unable.get.connection", new String[]{
00593 String.valueOf(tid), backend.getName()}));
00594
00595 // begin transaction
00596 backend.startTransaction(lTid);
00597 c.setAutoCommit(false);
00598 }
00599 else
00600 { // Re-use the connection used by this transaction
00601 c = cm.retrieveConnection(tid);
00602
00603 // Sanity check
00604 if (c == null)
00605 throw new SQLException(Translate.get(
00606 "loadbalancer.unable.retrieve.connection", new String[]{
00607 String.valueOf(tid), backend.getName()}));
00608 }
00609
00610 // Execute Query
00611 ResultSet rs;
00612 try
00613 {
00614 // We suppose here that the request does not modify the schema since
00615 // it is a read-only query.
00616 CallableStatement cs = c.prepareCall(proc.getSQL());
00617 if (backend.getDriverCompliance().supportSetQueryTimeout())
00618 cs.setQueryTimeout(proc.getTimeout());
00619 if ((proc.getMaxRows() > 0)
00620 && backend.getDriverCompliance().supportSetMaxRows())
00621 cs.setMaxRows(proc.getMaxRows());
00622 rs = cs.executeQuery();
00623 }
00624 catch (SQLException e)
00625 {
00626 throw new SQLException(Translate.get(
00627 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00628 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00629 backend.getName(), e.getMessage()}));
00630 }
00631 if (logger.isDebugEnabled())
00632 logger.debug(Translate.get("loadbalancer.execute.transaction.on",
00633 new String[]{String.valueOf(tid), String.valueOf(proc.getId()),
00634 backend.getName()}));
00635 return rs;
00636 }
00637 }
|
|
||||||||||||||||
|
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 }
|
|
||||||||||||
|
Execute a write request on the selected backend.
ParallelDB.java の 647 行で定義されています。 参照先 java.sql.Statement.executeUpdate(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.getConnection(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.releaseConnection(), と java.sql.Statement.setQueryTimeout().
00649 {
00650 if (backend == null)
00651 throw new SQLException(Translate.get(
00652 "loadbalancer.execute.no.backend.available", request.getId()));
00653
00654 try
00655 {
00656 AbstractConnectionManager cm = backend.getConnectionManager(request
00657 .getLogin());
00658 if (request.isAutoCommit())
00659 { // Use a connection just for this request
00660 Connection c = null;
00661 try
00662 {
00663 c = cm.getConnection();
00664 }
00665 catch (UnreachableBackendException e1)
00666 {
00667 String backendName = backend.getName();
00668 logger.error(Translate.get(
00669 "loadbalancer.backend.disabling.unreachable", backendName));
00670 backend.disable();
00671 throw new UnreachableBackendException(Translate.get(
00672 "loadbalancer.backend.unreacheable", backendName));
00673 }
00674
00675 // Sanity check
00676 if (c == null)
00677 throw new UnreachableBackendException(Translate.get(
00678 "loadbalancer.backend.no.connection", backend.getName()));
00679
00680 // Execute Query
00681 int result;
00682 try
00683 {
00684 backend.addPendingWriteRequest(request);
00685 Statement s = c.createStatement();
00686 if (backend.getDriverCompliance().supportSetQueryTimeout())
00687 s.setQueryTimeout(request.getTimeout());
00688 String sql = request.getSQL();
00689 // Rewrite the query if needed
00690 sql = backend.rewriteQuery(sql);
00691 result = s.executeUpdate(sql);
00692 }
00693 catch (SQLException e)
00694 {
00695 throw new SQLException(Translate.get(
00696 "loadbalancer.request.failed.on.backend", new String[]{
00697 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00698 backend.getName(), e.getMessage()}));
00699 }
00700 finally
00701 {
00702 backend.removePendingRequest(request);
00703 cm.releaseConnection(c);
00704 }
00705 return result;
00706 }
00707 else
00708 { // Re-use the connection used by this transaction
00709 Connection c = cm.retrieveConnection(request.getTransactionId());
00710
00711 // Sanity check
00712 if (c == null)
00713 throw new SQLException(Translate.get(
00714 "loadbalancer.unable.retrieve.connection",
00715 new String[]{String.valueOf(request.getTransactionId()),
00716 backend.getName()}));
00717
00718 // Execute Query
00719 try
00720 {
00721 backend.addPendingWriteRequest(request);
00722 Statement s = c.createStatement();
00723 if (backend.getDriverCompliance().supportSetQueryTimeout())
00724 s.setQueryTimeout(request.getTimeout());
00725 String sql = request.getSQL();
00726 // Rewrite the query if needed
00727 sql = backend.rewriteQuery(sql);
00728 return s.executeUpdate(sql);
00729 }
00730 catch (SQLException e)
00731 {
00732 throw new SQLException(Translate.get(
00733 "loadbalancer.request.failed.on.backend", new String[]{
00734 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00735 backend.getName(), e.getMessage()}));
00736 }
00737 finally
00738 {
00739 backend.removePendingRequest(request);
00740 }
00741 }
00742 }
00743 catch (RuntimeException e)
00744 {
00745 String msg = Translate.get("loadbalancer.request.failed.on.backend",
00746 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()),
00747 backend.getName(), e.getMessage()});
00748 logger.fatal(msg, e);
00749 throw new SQLException(msg);
00750 }
00751 }
|
|
||||||||||||
|
Execute a write request on the selected backend and return the autogenerated keys.
ParallelDB.java の 762 行で定義されています。 参照先 java.sql.Statement.executeUpdate(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.getConnection(), と java.sql.Statement.setQueryTimeout().
00765 {
00766 if (backend == null)
00767 throw new SQLException(Translate.get(
00768 "loadbalancer.execute.no.backend.available", request.getId()));
00769
00770 if (!backend.getDriverCompliance().supportGetGeneratedKeys())
00771 throw new SQLException(Translate.get(
00772 "loadbalancer.backend.autogeneratedkeys.unsupported", backend
00773 .getName()));
00774
00775 try
00776 {
00777 AbstractConnectionManager cm = backend.getConnectionManager(request
00778 .getLogin());
00779 if (request.isAutoCommit())
00780 { // Use a connection just for this request
00781 Connection c = null;
00782 try
00783 {
00784 c = cm.getConnection();
00785 }
00786 catch (UnreachableBackendException e1)
00787 {
00788 String backendName = backend.getName();
00789 logger.error(Translate.get(
00790 "loadbalancer.backend.disabling.unreachable", backendName));
00791 backend.disable();
00792 throw new UnreachableBackendException(Translate.get(
00793 "loadbalancer.backend.unreacheable", backendName));
00794 }
00795
00796 // Sanity check
00797 if (c == null)
00798 throw new UnreachableBackendException(Translate.get(
00799 "loadbalancer.backend.no.connection", backend.getName()));
00800
00801 // Execute Query
00802 ResultSet result;
00803 try
00804 {
00805 backend.addPendingWriteRequest(request);
00806 Statement s = c.createStatement();
00807 if (backend.getDriverCompliance().supportSetQueryTimeout())
00808 s.setQueryTimeout(request.getTimeout());
00809 String sql = request.getSQL();
00810 // Rewrite the query if needed
00811 sql = backend.rewriteQuery(sql);
00812 int rows = s.executeUpdate(sql,
00813 java.sql.Statement.RETURN_GENERATED_KEYS);
00814 if (logger.isDebugEnabled())
00815 logger.debug(Translate.get("loadbalancer.request.affected",
00816 new String[]{String.valueOf(request.getId()),
00817 String.valueOf(rows)}));
00818 result = s.getGeneratedKeys();
00819 }
00820 catch (SQLException e)
00821 {
00822 throw new SQLException(Translate.get(
00823 "loadbalancer.request.failed.on.backend", new String[]{
00824 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00825 backend.getName(), e.getMessage()}));
00826 }
00827 finally
00828 {
00829 backend.removePendingRequest(request);
00830 cm.releaseConnection(c);
00831 }
00832 return result;
00833 }
00834 else
00835 { // Re-use the connection used by this transaction
00836 Connection c = cm.retrieveConnection(request.getTransactionId());
00837
00838 // Sanity check
00839 if (c == null)
00840 throw new SQLException(Translate.get(
00841 "loadbalancer.unable.retrieve.connection",
00842 new String[]{String.valueOf(request.getTransactionId()),
00843 backend.getName()}));
00844
00845 // Execute Query
00846 ResultSet result;
00847 try
00848 {
00849 backend.addPendingWriteRequest(request);
00850 Statement s = c.createStatement();
00851 if (backend.getDriverCompliance().supportSetQueryTimeout())
00852 s.setQueryTimeout(request.getTimeout());
00853 String sql = request.getSQL();
00854 // Rewrite the query if needed
00855 sql = backend.rewriteQuery(sql);
00856 int rows = s.executeUpdate(sql,
00857 java.sql.Statement.RETURN_GENERATED_KEYS);
00858 if (logger.isDebugEnabled())
00859 logger.debug(Translate.get("loadbalancer.request.affected",
00860 new String[]{String.valueOf(request.getId()),
00861 String.valueOf(rows)}));
00862 return s.getGeneratedKeys();
00863 }
00864 catch (SQLException e)
00865 {
00866 throw new SQLException(Translate.get(
00867 "loadbalancer.request.failed.on.backend", new String[]{
00868 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00869 backend.getName(), e.getMessage()}));
00870 }
00871 finally
00872 {
00873 backend.removePendingRequest(request);
00874 }
00875 }
00876 }
00877 catch (RuntimeException e)
00878 {
00879 String msg = Translate
00880 .get("loadbalancer.request.failed", new String[]{
00881 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00882 e.getMessage()});
00883 logger.fatal(msg, e);
00884 throw new SQLException(msg);
00885 }
00886 }
|
|
||||||||||||
|
Execute a stored procedure on the selected backend.
ParallelDB.java の 896 行で定義されています。
00898 {
00899 // Ok, we have a backend, let's execute the request
00900 AbstractConnectionManager cm = backend
00901 .getConnectionManager(proc.getLogin());
00902
00903 // Sanity check
00904 if (cm == null)
00905 {
00906 String msg = Translate.get("loadbalancer.connectionmanager.not.found",
00907 new String[]{proc.getLogin(), backend.getName()});
00908 logger.error(msg);
00909 throw new SQLException(msg);
00910 }
00911
00912 // Execute the query
00913 if (proc.isAutoCommit())
00914 {
00915 // Use a connection just for this request
00916 Connection c = null;
00917 try
00918 {
00919 c = cm.getConnection();
00920 }
00921 catch (UnreachableBackendException e1)
00922 {
00923 logger.error(Translate.get(
00924 "loadbalancer.backend.disabling.unreachable", backend.getName()));
00925 backend.disable();
00926 throw new UnreachableBackendException(Translate.get(
00927 "loadbalancer.backend.unreacheable", backend.getName()));
00928 }
00929
00930 // Sanity check
00931 if (c == null)
00932 throw new UnreachableBackendException(Translate.get(
00933 "loadbalancer.backend.no.connection", backend.getName()));
00934
00935 // Execute Query
00936 int result;
00937 try
00938 {
00939 CallableStatement cs = c.prepareCall(proc.getSQL());
00940 if (backend.getDriverCompliance().supportSetQueryTimeout())
00941 cs.setQueryTimeout(proc.getTimeout());
00942 result = cs.executeUpdate();
00943
00944 // Warning! No way to detect if schema has been modified unless
00945 // we ask the backend again using DatabaseMetaData.getTables().
00946 }
00947 catch (SQLException e)
00948 {
00949 throw new SQLException(Translate.get(
00950 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00951 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00952 backend.getName(), e.getMessage()}));
00953 }
00954 finally
00955 {
00956 cm.releaseConnection(c);
00957 }
00958 if (logger.isDebugEnabled())
00959 logger.debug(Translate.get("loadbalancer.storedprocedure.on",
00960 new String[]{String.valueOf(proc.getId()), backend.getName()}));
00961 return result;
00962 }
00963 else
00964 { // Inside a transaction
00965 Connection c;
00966 long tid = proc.getTransactionId();
00967 Long lTid = new Long(tid);
00968
00969 if (!backend.isStartedTransaction(lTid))
00970 { // transaction has not been started yet on this backend
00971 try
00972 {
00973 c = cm.getConnection(tid);
00974 }
00975 catch (UnreachableBackendException e1)
00976 {
00977 logger.error(Translate.get(
00978 "loadbalancer.backend.disabling.unreachable", backend.getName()));
00979 backend.disable();
00980 throw new SQLException(Translate.get(
00981 "loadbalancer.backend.unreacheable", backend.getName()));
00982 }
00983
00984 // Sanity check
00985 if (c == null)
00986 throw new SQLException(Translate.get(
00987 "loadbalancer.unable.get.connection", new String[]{
00988 String.valueOf(tid), backend.getName()}));
00989
00990 // begin transaction
00991 backend.startTransaction(lTid);
00992 c.setAutoCommit(false);
00993 }
00994 else
00995 { // Re-use the connection used by this transaction
00996 c = cm.retrieveConnection(tid);
00997
00998 // Sanity check
00999 if (c == null)
01000 throw new SQLException(Translate.get(
01001 "loadbalancer.unable.retrieve.connection", new String[]{
01002 String.valueOf(tid), backend.getName()}));
01003 }
01004
01005 // Execute Query
01006 int result;
01007 try
01008 {
01009 CallableStatement cs = c.prepareCall(proc.getSQL());
01010 if (backend.getDriverCompliance().supportSetQueryTimeout())
01011 cs.setQueryTimeout(proc.getTimeout());
01012 result = cs.executeUpdate();
01013
01014 // Warning! No way to detect if schema has been modified unless
01015 // we ask the backend again using DatabaseMetaData.getTables().
01016 }
01017 catch (SQLException e)
01018 {
01019 throw new SQLException(Translate.get(
01020 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
01021 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
01022 backend.getName(), e.getMessage()}));
01023 }
01024 if (logger.isDebugEnabled())
01025 logger.debug(Translate.get("loadbalancer.execute.transaction.on",
01026 new String[]{String.valueOf(tid), String.valueOf(proc.getId()),
01027 backend.getName()}));
01028 return result;
01029 }
01030 }
|
|
|
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 }
|
|
|
|
Return the XML tags of the ParallelDB load balancer implementation.
org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_LPRF, と org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RRを実装しています. |
|
|
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.java の 71 行で定義されています。 参照元 org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB.execReadRequest(). |
|
|
初期値: 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