public class BootstrapQueryDslAccessor extends Object implements QueryDslAccessor
All methods throw an IllegalStateException if anything tries to use this before the database is configured.
They can still get it injected, though. In other words, you can look, but you can't touch. 'Cause the best things
in life ain't cheap, no!
| Modifier and Type | Field and Description |
|---|---|
protected DatabaseConfigurationManager |
databaseConfigurationManager |
protected OfBizConnectionFactory |
ofBizConnectionFactory |
| Constructor and Description |
|---|
BootstrapQueryDslAccessor(DatabaseConfigurationManager databaseConfigurationManager,
OfBizConnectionFactory ofBizConnectionFactory) |
| Modifier and Type | Method and Description |
|---|---|
void |
execute(SqlCallback callback)
Executes SQL statements as defined in the callback function.
|
<T> T |
executeQuery(QueryCallback<T> callback)
Executes SQL statements as defined in the callback function and returns the results.
|
DbConnection |
withDbConnection(Connection connection)
Wrap an existing connection in a DbConnection to allow the use of QueryDsl against it.
|
ConnectionProvider |
withLegacyOfBizTransaction()
Get a connection provider that will ensure that there is a Connection in OfBiz's Transaction ThreadLocal and then
use that.
|
ConnectionProvider |
withNewConnection()
Get a connection provider that will always borrow a new DB connection from the connection pool.
|
protected final DatabaseConfigurationManager databaseConfigurationManager
protected final OfBizConnectionFactory ofBizConnectionFactory
public BootstrapQueryDslAccessor(DatabaseConfigurationManager databaseConfigurationManager, OfBizConnectionFactory ofBizConnectionFactory)
public <T> T executeQuery(@Nonnull QueryCallback<T> callback)
QueryDslAccessorThis method is mostly useful for running SELECT statements and returning the given results in some form.
This method will attempt to run the callback within an existing OfBiz transaction if one is running within this thread. If not, it will borrow a new connection, start a transaction and manage that transaction for you. That is, the connection will always be in autocommit=false, and the commit or rollback will be completely managed for you.
Important: This method will NOT put the new connection into the OfBiz ThreadLocal transaction
if there wasn't one there already. See QueryDslAccessor.withLegacyOfBizTransaction() instead.
If you want to rollback the transaction then throw a RuntimeException. The transaction will be marked as "rollback required" such that the code that started the transaction will eventually call rollback on the Connection and the exception will be propagated. If the callback returns normally, then this indicates that the underlying transaction is allowed to be committed at the appropriate time.
Because the connection (borrowing and returning from the pool) and its transaction are managed for you,
then specific Connection methods are illegal to call and will cause a RuntimeException including:
Connection.setAutoCommit(boolean) autocommit is always falseConnection.commit()Connection.rollback()Connection.close()Example Usage:
WorklogDTO worklogDTO = queryDslAccessor.executeQuery(
dbConnection -> dbConnection.newSqlQuery()
.from(WORKLOG)
.where(WORKLOG.id.eq(worklog.getId()))
.singleResult(WORKLOG));
executeQuery in interface QueryDslAccessorT - type of resultscallback - the callback function that runs the queryQueryDslAccessor.execute(SqlCallback),
QueryDslAccessor.withNewConnection()public void execute(@Nonnull SqlCallback callback)
QueryDslAccessorThis method does not return results and is mostly useful for running INSERT, UPDATE, and DELETE operations.
This method will attempt to run the callback within an existing OfBiz transaction if one is running within this thread. If not, it will borrow a new connection, start a transaction and manage that transaction for you. That is, the connection will always be in autocommit=false, and the commit or rollback will be completely managed for you. If you want to rollback the transaction then throw a RuntimeException. The transaction will be marked as "rollback required" such that the code that started the transaction will eventually call rollback on the Connection and the exception will be propagated. If the callback returns normally, then this indicates that the underlying transaction is allowed to be committed at the appropriate time.
Because the connection (borrowing and returning from the pool) and its transaction are managed for you,
then specific Connection methods are illegal to call and will cause a RuntimeException including:
Connection.setAutoCommit(boolean) autocommit is always falseConnection.commit()Connection.rollback()Connection.close()Example Usage:
queryDslAccessor.execute(dbConnection -> {
dbConnection.update(QIssueLink.ISSUE_LINK)
.set(QIssueLink.ISSUE_LINK.sequence, newSeq)
.where(QIssueLink.ISSUE_LINK.id.eq(issueLinkId))
.execute();
});
execute in interface QueryDslAccessorcallback - the callback function that runs the queryQueryDslAccessor.executeQuery(QueryCallback),
QueryDslAccessor.withNewConnection()public ConnectionProvider withNewConnection()
QueryDslAccessor
Important:
This method will borrow a new connection from the pool, pass it to the callback function and then return it to
the pool after the callback has completed.
Even if OfBiz is currently running in a ThreadLocal transaction, this will retrieve a fresh connection from
the pool.
If you want to run in an existing OfBiz transaction then see instead QueryDslAccessor.executeQuery(QueryCallback) or
QueryDslAccessor.execute(SqlCallback)
The connection will have the default auto-commit value as defined by the JIRA connection pool.
As at JIRA 7.0 this means autocommit == true.
(See org.apache.commons.dbcp2.PoolableConnectionFactory for details.)
autocommit(false) and then commit() to use a transaction.rollback() explicitly, or throw a RuntimeException.Example Usage:
queryDslAccessor.withNewConnection().execute(dbConnection -> {
dbConnection.update(QIssueLink.ISSUE_LINK)
.set(QIssueLink.ISSUE_LINK.sequence, newSeq)
.where(QIssueLink.ISSUE_LINK.id.eq(issueLinkId))
.execute();
});
withNewConnection in interface QueryDslAccessorQueryDslAccessor.executeQuery(QueryCallback),
QueryDslAccessor.execute(SqlCallback),
QueryDslAccessor.withLegacyOfBizTransaction()public ConnectionProvider withLegacyOfBizTransaction()
QueryDslAccessorThis method is mostly useful if you want to call a mixture of OfBiz and Querydsl methods within your callback and ensure that the OfBiz code participates in the same transaction as the Querydsl code. In other words, its a handy workaround for dealing with legacy code, but the preferred long-term solution would usually be to convert the OfBiz code to Querydsl.
If there is already an OfBiz ThreadLocal transaction in play, then this will be passed to the callback function. If not, then a new OfBiz ThreadLocal transaction is started and it's connection is passed to the callback function. This method will attempt to run the callback within an existing OfBiz transaction if one is running within this thread. If not, it will start a new OfBiz ThreadLocal transaction which will be committed or rolled back once the callback terminates.
The connection will always be in autocommit=false, and the commit or rollback will be completely managed for you. If you want to rollback the transaction then throw a RuntimeException. The transaction will be marked as "rollback required" such that the code that started the transaction will eventually call rollback on the Connection and the exception will be propagated. If the callback returns normally, then this indicates that the underlying transaction is allowed to be committed at the appropriate time.
Because the connection (borrowing and returning from the pool) and its transaction are managed for you,
some specific Connection methods are illegal to call and will cause a RuntimeException including:
Connection.setAutoCommit(boolean) autocommit is always falseConnection.commit()Connection.rollback()Connection.close()Example Usage:
queryDslAccessor.withLegacyOfBizTransaction().execute(dbConnection -> {
doQueryDslStuffWith(dbConnection);
callLegacyCodeThatUsesOfBiz();
});
withLegacyOfBizTransaction in interface QueryDslAccessorQueryDslAccessor.withNewConnection(),
QueryDslAccessor.executeQuery(QueryCallback),
QueryDslAccessor.execute(SqlCallback)public DbConnection withDbConnection(Connection connection)
QueryDslAccessorwithDbConnection in interface QueryDslAccessorconnection - an already established connection.Copyright © 2002-2024 Atlassian. All Rights Reserved.