JiraHostConnectionAccessor does not reuse the same connection in nested calls

        return databaseAccessor.runInTransaction(connection -> {
            Message<P> createdMessage = messageDao.create(message, tags);
            requireNonNull(createdMessage.getId());

            for (MessageQueueItem item : messageItems) {
                messageQueueItemDao.create(item, createdMessage);
            }
            return createdMessage;
        });

    public Message create(final Message message, final String[] tags) {
        Integer id = databaseAccessor.runInTransaction(connection -> {
             // SQL query DSL insert code goes here
             return id;
        });
        message.setTags(tags);
        message.setId(id);
        return message;
    }

    public <A> A execute(final boolean readOnly, final boolean newTransaction, @Nonnull final ConnectionCallback<A> callback) {
        if (newTransaction) {
            // Need to borrow a connection from the pool and start a new transaction
            return borrowConnectionAndExecute(readOnly, callback);
        } else {
            final Connection existingConnection = CoreTransactionUtil.getConnection();
            if (existingConnection == null) {
                // no current transaction in OfBiz
                return borrowConnectionAndExecute(readOnly, callback);
            } else {
                // Developer has requested to participate in existing transaction, and OfBiz actually has one running ...
                // I don't think it is a good idea to set read-only on an existing transaction ... ignoring
                return executeInExistingTransaction(callback, existingConnection);
            }
        }
    }

    private <A> A borrowConnectionAndExecute(final boolean readOnly, final ConnectionCallback<A> callback) {
        return databaseAccessor.executeQuery(connection -> {
                    // By contract must run in a Transaction
                    connection.setAutoCommit(false);
                    try {
                        connection.getJdbcConnection().setReadOnly(readOnly);
                    } catch (SQLException e) {
                        throw new DataAccessException(e);
                    }
                    // If this returns successfully then SAL's DefaultTransactionalExecutor will commit the transaction
                    // If it throws RuntimeException then DatabaseAcccessor and DefaultTransactionalExecutor will both
                    // cause a rollback() ... seems harmless.
                    try {
                        return callback.execute(connection.getJdbcConnection());
                    } finally {
                        if (readOnly) {
                            // Need to return the connection to the default state of NOT read-only.
                            try {
                                connection.getJdbcConnection().setReadOnly(false);
                            } catch (SQLException ex) {
                                log.error("Unable to unset the read-only flag on a borrowed DB Connection ... chaos will ensue.", ex);
                            }
                        }
                        // Connection Pool will set default auto-commit mode
                    }
                }
        );
    }