#743

Committed 28 Jun 2024 04:17PM UTC coverage: 90.988% (+0.5%) from 90.484%

Build # #743

Build Type

push

Committed by

Commit Message

add paramIfNotEmpty method (#318)

* v0.x to master merge

* fix nanoseconds diff (java8 to java11)

* eclipse cleanup and  optimize import

* eclipse format

* optimize Imports

* remove unused annotation

* library version up

* migrate v0.x to master
- update java version 8 to 11
- update junit4 to junit5
- library version update

* fix test failed

* remove unused annotation

* fixed bug

* use var

* fix java8 coding style

* Refactoring TransactionContextManager

* Refactoring SqlAgent

* 途中コミット

* fix testcase

* fix review

* fix javadoc comments

* merge v0.x PR

* cleanup code

* cleanup test code

* change build status badge

* - agent.query, update, proc, batch にそれぞれSupplierを引数にとるメソッドを追加
- SqlQuery.paramとSqlEntityUpdate.setにFunctionを受け取るメソッドを追加

* testcaseの整形

* - SqlFluent と ExtractionCondition の分離
- Arrays.asList -> List.of への変更
- テストの整形

* - v0.x系の不具合対応の追いつき
- ログ出力の整理

* - SqlKindの整理（ENTITY_XXXの追加）
- REPL_LOGの追加
- Deprecatedメソッドの削除（SqlAgent）
- SqlAgent, ExecutionContextでsetterをfluent APIに変更

* DB接続URLの修正

* add and fix testcases.

* add event testcases.

* fix typo

* add paramIfNotEmpty method and StringUtils rename ObjectUtils

* fix review comments.

* remove unused import

Run Details

1695 of 1958 new or added lines in 97 files covered. (86.57%)

26 existing lines in 10 files now uncovered.

8249 of 9066 relevant lines covered (90.99%)

0.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.39

/src/main/java/jp/co/future/uroborosql/event/subscriber/EventSubscriber.java

/**
 * Copyright (c) 2017-present, Future Corporation
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
package jp.co.future.uroborosql.event.subscriber;

import java.util.Optional;
import java.util.function.Consumer;

import jp.co.future.uroborosql.event.AfterBeginTransactionEvent;
import jp.co.future.uroborosql.event.AfterCommitEvent;
import jp.co.future.uroborosql.event.AfterCreateCallableStatementEvent;
import jp.co.future.uroborosql.event.AfterCreatePreparedStatementEvent;
import jp.co.future.uroborosql.event.AfterGetOutParameterEvent;
import jp.co.future.uroborosql.event.AfterInitializeExecutionContextEvent;
import jp.co.future.uroborosql.event.AfterRollbackEvent;
import jp.co.future.uroborosql.event.BeforeCommitEvent;
import jp.co.future.uroborosql.event.BeforeEndTransactionEvent;
import jp.co.future.uroborosql.event.BeforeParseSqlEvent;
import jp.co.future.uroborosql.event.BeforeRollbackEvent;
import jp.co.future.uroborosql.event.BeforeSetParameterEvent;
import jp.co.future.uroborosql.event.EventListenerHolder;
import jp.co.future.uroborosql.event.ExecutionConsumer;
import jp.co.future.uroborosql.event.ProcedureEvent;
import jp.co.future.uroborosql.event.SqlBatchEvent;
import jp.co.future.uroborosql.event.SqlQueryEvent;
import jp.co.future.uroborosql.event.SqlUpdateEvent;
import jp.co.future.uroborosql.event.TransformSqlEvent;

/**
 * イベントサブスクライバ抽象親クラス
 *
 * @author H.Sugimoto
 * @since v1.0.0
 */
public abstract class EventSubscriber {
        /** ExecutionContext初期化後イベントリスナ. */
        private Optional<Consumer<AfterInitializeExecutionContextEvent>> afterInitializeExecutionContextListener = Optional
                        .empty();
        /** パラメータ設定前イベントリスナ. */
        private Optional<Consumer<BeforeSetParameterEvent>> beforeSetParameterListener = Optional.empty();
        /** SQL変換イベントリスナ. */
        private Optional<Consumer<TransformSqlEvent>> transformSqlListener = Optional.empty();
        /** SQLパース前イベントリスナ. */
        private Optional<Consumer<BeforeParseSqlEvent>> beforeParseSqlListener = Optional.empty();
        /** 出力パラメータ取得後イベントリスナ. */
        private Optional<Consumer<AfterGetOutParameterEvent>> afterGetOutParameterListener = Optional.empty();
        /** PreparedStatement生成後イベントリスナ. */
        private Optional<ExecutionConsumer<AfterCreatePreparedStatementEvent>> afterCreatePreparedStatementListener = Optional
                        .empty();
        /** CallableStatement生成後イベントリスナ. */
        private Optional<ExecutionConsumer<AfterCreateCallableStatementEvent>> afterCreateCallableStatementListener = Optional
                        .empty();
        /** SQLQuery実行後イベントリスナ. */
        private Optional<ExecutionConsumer<SqlQueryEvent>> sqlQueryListener = Optional.empty();
        /** SQLUpdate実行後イベントリスナ. */
        private Optional<ExecutionConsumer<SqlUpdateEvent>> sqlUpdateListener = Optional.empty();
        /** SQLBatch実行後イベントリスナ. */
        private Optional<ExecutionConsumer<SqlBatchEvent>> sqlBatchListener = Optional.empty();
        /** Procedure実行後イベントリスナ. */
        private Optional<ExecutionConsumer<ProcedureEvent>> procedureListener = Optional.empty();
        /** トランザクション開始後イベントリスナ. */
        private Optional<Consumer<AfterBeginTransactionEvent>> afterBeginTransactionListener = Optional.empty();
        /** トランザクション終了前イベントリスナ. */
        private Optional<Consumer<BeforeEndTransactionEvent>> beforeEndTransactionListener = Optional.empty();
        /** コミット前イベントリスナ. */
        private Optional<Consumer<BeforeCommitEvent>> beforeCommitListener = Optional.empty();
        /** コミット後イベントリスナ. */
        private Optional<Consumer<AfterCommitEvent>> afterCommitListener = Optional.empty();
        /** ロールバック前イベントリスナ. */
        private Optional<Consumer<BeforeRollbackEvent>> beforeRollbackListener = Optional.empty();
        /** ロールバック後イベントリスナ. */
        private Optional<Consumer<AfterRollbackEvent>> afterRollbackListener = Optional.empty();

        /**
         * 初期化処理.
         */
        public abstract void initialize();

        /**
         * イベントの購読を行う.
         *
         * @param eventListenerHolder EventListenerHolder
         */
        public final void subscribe(final EventListenerHolder eventListenerHolder) {
                afterInitializeExecutionContextListener()
                                .ifPresent(listener -> eventListenerHolder.addAfterInitializeExecutionContextListener(listener));
                beforeSetParameterListener().ifPresent(listener -> eventListenerHolder.addBeforeSetParameterListener(listener));
                transformSqlListener().ifPresent(listener -> eventListenerHolder.addTransformSqlListener(listener));
                beforeParseSqlListener()
                                .ifPresent(listener -> eventListenerHolder.addBeforeParseSqlListener(listener));
                afterGetOutParameterListener()
                                .ifPresent(listener -> eventListenerHolder.addAfterGetOutParameterListener(listener));
                afterCreatePreparedStatementListener()
                                .ifPresent(listener -> eventListenerHolder.addAfterCreatePreparedStatementListener(listener));
                afterCreateCallableStatementListener()
                                .ifPresent(listener -> eventListenerHolder.addAfterCreateCallableStatementListener(listener));
                sqlQueryListener().ifPresent(listener -> eventListenerHolder.addSqlQueryListener(listener));
                sqlUpdateListener().ifPresent(listener -> eventListenerHolder.addSqlUpdateListener(listener));
                sqlBatchListener().ifPresent(listener -> eventListenerHolder.addSqlBatchListener(listener));
                procedureListener().ifPresent(listener -> eventListenerHolder.addProcedureListener(listener));
                afterBeginTransactionListener()
                                .ifPresent(listener -> eventListenerHolder.addAfterBeginTransactionListener(listener));
                beforeEndTransactionListener()
                                .ifPresent(listener -> eventListenerHolder.addBeforeEndTransactionListener(listener));
                beforeCommitListener().ifPresent(listener -> eventListenerHolder.addBeforeCommitListener(listener));
                afterCommitListener().ifPresent(listener -> eventListenerHolder.addAfterCommitListener(listener));
                beforeRollbackListener().ifPresent(listener -> eventListenerHolder.addBeforeRollbackListener(listener));
                afterRollbackListener().ifPresent(listener -> eventListenerHolder.addAfterRollbackListener(listener));
        }

        /**
         * イベントの購読解除を行う.
         *
         * @param eventListenerHolder EventListenerHolder
         */
        public final void unsubscribe(final EventListenerHolder eventListenerHolder) {
                afterInitializeExecutionContextListener()
                                .ifPresent(listener -> eventListenerHolder.removeAfterInitializeExecutionContextListener(listener));
                beforeSetParameterListener()
                                .ifPresent(listener -> eventListenerHolder.removeBeforeSetParameterListener(listener));
                transformSqlListener()
                                .ifPresent(listener -> eventListenerHolder.removeTransformSqlListener(listener));
                beforeParseSqlListener()
                                .ifPresent(listener -> eventListenerHolder.removeBeforeParseSqlListener(listener));
                afterGetOutParameterListener()
                                .ifPresent(listener -> eventListenerHolder.removeAfterGetOutParameterListener(listener));
                afterCreatePreparedStatementListener()
                                .ifPresent(listener -> eventListenerHolder.removeAfterCreatePreparedStatementListener(listener));
                afterCreateCallableStatementListener()
                                .ifPresent(listener -> eventListenerHolder.removeAfterCreateCallableStatementListener(listener));
                sqlQueryListener().ifPresent(listener -> eventListenerHolder.removeSqlQueryListener(listener));
                sqlUpdateListener().ifPresent(listener -> eventListenerHolder.removeSqlUpdateListener(listener));
                sqlBatchListener().ifPresent(listener -> eventListenerHolder.removeSqlBatchListener(listener));
                procedureListener().ifPresent(listener -> eventListenerHolder.removeProcedureListener(listener));
                afterBeginTransactionListener()
                                .ifPresent(listener -> eventListenerHolder.removeAfterBeginTransactionListener(listener));
                beforeEndTransactionListener()
                                .ifPresent(listener -> eventListenerHolder.removeBeforeEndTransactionListener(listener));
                beforeCommitListener().ifPresent(listener -> eventListenerHolder.removeBeforeCommitListener(listener));
                afterCommitListener().ifPresent(listener -> eventListenerHolder.removeAfterCommitListener(listener));
                beforeRollbackListener().ifPresent(listener -> eventListenerHolder.removeBeforeRollbackListener(listener));
                afterRollbackListener().ifPresent(listener -> eventListenerHolder.removeAfterRollbackListener(listener));
        }

        protected final Optional<Consumer<AfterInitializeExecutionContextEvent>> afterInitializeExecutionContextListener() {
                return afterInitializeExecutionContextListener;
        }

        protected final Optional<Consumer<BeforeSetParameterEvent>> beforeSetParameterListener() {
                return beforeSetParameterListener;
        }

        protected final Optional<Consumer<TransformSqlEvent>> transformSqlListener() {
                return transformSqlListener;
        }

        protected final Optional<Consumer<BeforeParseSqlEvent>> beforeParseSqlListener() {
                return beforeParseSqlListener;
        }

        protected final Optional<Consumer<AfterGetOutParameterEvent>> afterGetOutParameterListener() {
                return afterGetOutParameterListener;
        }

        protected final Optional<ExecutionConsumer<AfterCreatePreparedStatementEvent>> afterCreatePreparedStatementListener() {
                return afterCreatePreparedStatementListener;
        }

        protected final Optional<ExecutionConsumer<AfterCreateCallableStatementEvent>> afterCreateCallableStatementListener() {
                return afterCreateCallableStatementListener;
        }

        protected final Optional<ExecutionConsumer<SqlQueryEvent>> sqlQueryListener() {
                return sqlQueryListener;
        }

        protected final Optional<ExecutionConsumer<SqlUpdateEvent>> sqlUpdateListener() {
                return sqlUpdateListener;
        }

        protected final Optional<ExecutionConsumer<SqlBatchEvent>> sqlBatchListener() {
                return sqlBatchListener;
        }

        protected final Optional<ExecutionConsumer<ProcedureEvent>> procedureListener() {
                return procedureListener;
        }

        protected final Optional<Consumer<AfterBeginTransactionEvent>> afterBeginTransactionListener() {
                return afterBeginTransactionListener;
        }

        protected final Optional<Consumer<BeforeEndTransactionEvent>> beforeEndTransactionListener() {
                return beforeEndTransactionListener;
        }

        protected final Optional<Consumer<BeforeCommitEvent>> beforeCommitListener() {
                return beforeCommitListener;
        }

        protected final Optional<Consumer<AfterCommitEvent>> afterCommitListener() {
                return afterCommitListener;
        }

        protected final Optional<Consumer<BeforeRollbackEvent>> beforeRollbackListener() {
                return beforeRollbackListener;
        }

        protected final Optional<Consumer<AfterRollbackEvent>> afterRollbackListener() {
                return afterRollbackListener;
        }

        protected final void afterInitializeExecutionContextListener(
                        final Consumer<AfterInitializeExecutionContextEvent> listener) {
                this.afterInitializeExecutionContextListener = Optional.ofNullable(listener);
        }

        protected final void beforeSetParameterListener(final Consumer<BeforeSetParameterEvent> listener) {
                this.beforeSetParameterListener = Optional.ofNullable(listener);
        }

        protected final void transformSqlListener(final Consumer<TransformSqlEvent> listener) {
                this.transformSqlListener = Optional.ofNullable(listener);
        }

        protected final void beforeParseSqlListener(final Consumer<BeforeParseSqlEvent> listener) {
                this.beforeParseSqlListener = Optional.ofNullable(listener);
        }

        protected final void afterGetOutParameterListener(final Consumer<AfterGetOutParameterEvent> listener) {
                this.afterGetOutParameterListener = Optional.ofNullable(listener);
        }

        protected final void afterCreatePreparedStatementListener(
                        final ExecutionConsumer<AfterCreatePreparedStatementEvent> listener) {
                this.afterCreatePreparedStatementListener = Optional.ofNullable(listener);
        }

        protected final void afterCreateCallableStatementListener(
                        final ExecutionConsumer<AfterCreateCallableStatementEvent> listener) {
                this.afterCreateCallableStatementListener = Optional.ofNullable(listener);
        }

        protected final void sqlQueryListener(final ExecutionConsumer<SqlQueryEvent> listener) {
                this.sqlQueryListener = Optional.ofNullable(listener);
        }

        protected final void sqlUpdateListener(final ExecutionConsumer<SqlUpdateEvent> listener) {
                this.sqlUpdateListener = Optional.ofNullable(listener);
        }

        protected final void sqlBatchListener(final ExecutionConsumer<SqlBatchEvent> listener) {
                this.sqlBatchListener = Optional.ofNullable(listener);
        }

        protected final void procedureListener(final ExecutionConsumer<ProcedureEvent> listener) {
                this.procedureListener = Optional.ofNullable(listener);
        }

        protected final void afterBeginTransactionListener(final Consumer<AfterBeginTransactionEvent> listener) {
                this.afterBeginTransactionListener = Optional.ofNullable(listener);
        }

        protected final void beforeEndTransactionListener(final Consumer<BeforeEndTransactionEvent> listener) {
                this.beforeEndTransactionListener = Optional.ofNullable(listener);
        }

        protected final void beforeCommitListener(final Consumer<BeforeCommitEvent> listener) {
                this.beforeCommitListener = Optional.ofNullable(listener);
        }

        protected final void afterCommitListener(final Consumer<AfterCommitEvent> listener) {
                this.afterCommitListener = Optional.ofNullable(listener);
        }

        protected final void beforeRollbackListener(final Consumer<BeforeRollbackEvent> listener) {
                this.beforeRollbackListener = Optional.ofNullable(listener);
        }

        protected final void afterRollbackListener(final Consumer<AfterRollbackEvent> listener) {
                this.afterRollbackListener = Optional.ofNullable(listener);
        }

}

1	/**
2	* Copyright (c) 2017-present, Future Corporation
3	*
4	* This source code is licensed under the MIT license found in the
5	* LICENSE file in the root directory of this source tree.
6	*/
7	package jp.co.future.uroborosql.event.subscriber;
8
9	import java.util.Optional;
10	import java.util.function.Consumer;
11
12	import jp.co.future.uroborosql.event.AfterBeginTransactionEvent;
13	import jp.co.future.uroborosql.event.AfterCommitEvent;
14	import jp.co.future.uroborosql.event.AfterCreateCallableStatementEvent;
15	import jp.co.future.uroborosql.event.AfterCreatePreparedStatementEvent;
16	import jp.co.future.uroborosql.event.AfterGetOutParameterEvent;
17	import jp.co.future.uroborosql.event.AfterInitializeExecutionContextEvent;
18	import jp.co.future.uroborosql.event.AfterRollbackEvent;
19	import jp.co.future.uroborosql.event.BeforeCommitEvent;
20	import jp.co.future.uroborosql.event.BeforeEndTransactionEvent;
21	import jp.co.future.uroborosql.event.BeforeParseSqlEvent;
22	import jp.co.future.uroborosql.event.BeforeRollbackEvent;
23	import jp.co.future.uroborosql.event.BeforeSetParameterEvent;
24	import jp.co.future.uroborosql.event.EventListenerHolder;
25	import jp.co.future.uroborosql.event.ExecutionConsumer;
26	import jp.co.future.uroborosql.event.ProcedureEvent;
27	import jp.co.future.uroborosql.event.SqlBatchEvent;
28	import jp.co.future.uroborosql.event.SqlQueryEvent;
29	import jp.co.future.uroborosql.event.SqlUpdateEvent;
30	import jp.co.future.uroborosql.event.TransformSqlEvent;
31
32	/**
33	* イベントサブスクライバ抽象親クラス
34	*
35	* @author H.Sugimoto
36	* @since v1.0.0
37	*/
38	public abstract class EventSubscriber {	1✔
39	/** ExecutionContext初期化後イベントリスナ. */
40	private Optional<Consumer<AfterInitializeExecutionContextEvent>> afterInitializeExecutionContextListener = Optional	1✔
41	.empty();	1✔
42	/** パラメータ設定前イベントリスナ. */
43	private Optional<Consumer<BeforeSetParameterEvent>> beforeSetParameterListener = Optional.empty();	1✔
44	/** SQL変換イベントリスナ. */
45	private Optional<Consumer<TransformSqlEvent>> transformSqlListener = Optional.empty();	1✔
46	/** SQLパース前イベントリスナ. */
47	private Optional<Consumer<BeforeParseSqlEvent>> beforeParseSqlListener = Optional.empty();	1✔
48	/** 出力パラメータ取得後イベントリスナ. */
49	private Optional<Consumer<AfterGetOutParameterEvent>> afterGetOutParameterListener = Optional.empty();	1✔
50	/** PreparedStatement生成後イベントリスナ. */
51	private Optional<ExecutionConsumer<AfterCreatePreparedStatementEvent>> afterCreatePreparedStatementListener = Optional	1✔
52	.empty();	1✔
53	/** CallableStatement生成後イベントリスナ. */
54	private Optional<ExecutionConsumer<AfterCreateCallableStatementEvent>> afterCreateCallableStatementListener = Optional	1✔
55	.empty();	1✔
56	/** SQLQuery実行後イベントリスナ. */
57	private Optional<ExecutionConsumer<SqlQueryEvent>> sqlQueryListener = Optional.empty();	1✔
58	/** SQLUpdate実行後イベントリスナ. */
59	private Optional<ExecutionConsumer<SqlUpdateEvent>> sqlUpdateListener = Optional.empty();	1✔
60	/** SQLBatch実行後イベントリスナ. */
61	private Optional<ExecutionConsumer<SqlBatchEvent>> sqlBatchListener = Optional.empty();	1✔
62	/** Procedure実行後イベントリスナ. */
63	private Optional<ExecutionConsumer<ProcedureEvent>> procedureListener = Optional.empty();	1✔
64	/** トランザクション開始後イベントリスナ. */
65	private Optional<Consumer<AfterBeginTransactionEvent>> afterBeginTransactionListener = Optional.empty();	1✔
66	/** トランザクション終了前イベントリスナ. */
67	private Optional<Consumer<BeforeEndTransactionEvent>> beforeEndTransactionListener = Optional.empty();	1✔
68	/** コミット前イベントリスナ. */
69	private Optional<Consumer<BeforeCommitEvent>> beforeCommitListener = Optional.empty();	1✔
70	/** コミット後イベントリスナ. */
71	private Optional<Consumer<AfterCommitEvent>> afterCommitListener = Optional.empty();	1✔
72	/** ロールバック前イベントリスナ. */
73	private Optional<Consumer<BeforeRollbackEvent>> beforeRollbackListener = Optional.empty();	1✔
74	/** ロールバック後イベントリスナ. */
75	private Optional<Consumer<AfterRollbackEvent>> afterRollbackListener = Optional.empty();	1✔
76
77	/**
78	* 初期化処理.
79	*/
80	public abstract void initialize();
81
82	/**
83	* イベントの購読を行う.
84	*
85	* @param eventListenerHolder EventListenerHolder
86	*/
87	public final void subscribe(final EventListenerHolder eventListenerHolder) {
88	afterInitializeExecutionContextListener()	1✔
89	.ifPresent(listener -> eventListenerHolder.addAfterInitializeExecutionContextListener(listener));	1✔
90	beforeSetParameterListener().ifPresent(listener -> eventListenerHolder.addBeforeSetParameterListener(listener));	1✔
91	transformSqlListener().ifPresent(listener -> eventListenerHolder.addTransformSqlListener(listener));	1✔
92	beforeParseSqlListener()	1✔
93	.ifPresent(listener -> eventListenerHolder.addBeforeParseSqlListener(listener));	1✔
94	afterGetOutParameterListener()	1✔
95	.ifPresent(listener -> eventListenerHolder.addAfterGetOutParameterListener(listener));	1✔
96	afterCreatePreparedStatementListener()	1✔
97	.ifPresent(listener -> eventListenerHolder.addAfterCreatePreparedStatementListener(listener));	1✔
98	afterCreateCallableStatementListener()	1✔
99	.ifPresent(listener -> eventListenerHolder.addAfterCreateCallableStatementListener(listener));	1✔
100	sqlQueryListener().ifPresent(listener -> eventListenerHolder.addSqlQueryListener(listener));	1✔
101	sqlUpdateListener().ifPresent(listener -> eventListenerHolder.addSqlUpdateListener(listener));	1✔
102	sqlBatchListener().ifPresent(listener -> eventListenerHolder.addSqlBatchListener(listener));	1✔
103	procedureListener().ifPresent(listener -> eventListenerHolder.addProcedureListener(listener));	1✔
104	afterBeginTransactionListener()	1✔
105	.ifPresent(listener -> eventListenerHolder.addAfterBeginTransactionListener(listener));	1✔
106	beforeEndTransactionListener()	1✔
107	.ifPresent(listener -> eventListenerHolder.addBeforeEndTransactionListener(listener));	1✔
108	beforeCommitListener().ifPresent(listener -> eventListenerHolder.addBeforeCommitListener(listener));	1✔
109	afterCommitListener().ifPresent(listener -> eventListenerHolder.addAfterCommitListener(listener));	1✔
110	beforeRollbackListener().ifPresent(listener -> eventListenerHolder.addBeforeRollbackListener(listener));	1✔
111	afterRollbackListener().ifPresent(listener -> eventListenerHolder.addAfterRollbackListener(listener));	1✔
112	}	1✔
113
114	/**
115	* イベントの購読解除を行う.
116	*
117	* @param eventListenerHolder EventListenerHolder
118	*/
119	public final void unsubscribe(final EventListenerHolder eventListenerHolder) {
120	afterInitializeExecutionContextListener()	1✔
121	.ifPresent(listener -> eventListenerHolder.removeAfterInitializeExecutionContextListener(listener));	1✔
122	beforeSetParameterListener()	1✔
123	.ifPresent(listener -> eventListenerHolder.removeBeforeSetParameterListener(listener));	1✔
124	transformSqlListener()	1✔
125	.ifPresent(listener -> eventListenerHolder.removeTransformSqlListener(listener));	1✔
126	beforeParseSqlListener()	1✔
127	.ifPresent(listener -> eventListenerHolder.removeBeforeParseSqlListener(listener));	1✔
128	afterGetOutParameterListener()	1✔
129	.ifPresent(listener -> eventListenerHolder.removeAfterGetOutParameterListener(listener));	1✔
130	afterCreatePreparedStatementListener()	1✔
131	.ifPresent(listener -> eventListenerHolder.removeAfterCreatePreparedStatementListener(listener));	1✔
132	afterCreateCallableStatementListener()	1✔
133	.ifPresent(listener -> eventListenerHolder.removeAfterCreateCallableStatementListener(listener));	1✔
134	sqlQueryListener().ifPresent(listener -> eventListenerHolder.removeSqlQueryListener(listener));	1✔
135	sqlUpdateListener().ifPresent(listener -> eventListenerHolder.removeSqlUpdateListener(listener));	1✔
136	sqlBatchListener().ifPresent(listener -> eventListenerHolder.removeSqlBatchListener(listener));	1✔
137	procedureListener().ifPresent(listener -> eventListenerHolder.removeProcedureListener(listener));	1✔
138	afterBeginTransactionListener()	1✔
139	.ifPresent(listener -> eventListenerHolder.removeAfterBeginTransactionListener(listener));	1✔
140	beforeEndTransactionListener()	1✔
141	.ifPresent(listener -> eventListenerHolder.removeBeforeEndTransactionListener(listener));	1✔
142	beforeCommitListener().ifPresent(listener -> eventListenerHolder.removeBeforeCommitListener(listener));	1✔
143	afterCommitListener().ifPresent(listener -> eventListenerHolder.removeAfterCommitListener(listener));	1✔
144	beforeRollbackListener().ifPresent(listener -> eventListenerHolder.removeBeforeRollbackListener(listener));	1✔
145	afterRollbackListener().ifPresent(listener -> eventListenerHolder.removeAfterRollbackListener(listener));	1✔
146	}	1✔
147
148	protected final Optional<Consumer<AfterInitializeExecutionContextEvent>> afterInitializeExecutionContextListener() {
149	return afterInitializeExecutionContextListener;	1✔
150	}
151
152	protected final Optional<Consumer<BeforeSetParameterEvent>> beforeSetParameterListener() {
153	return beforeSetParameterListener;	1✔
154	}
155
156	protected final Optional<Consumer<TransformSqlEvent>> transformSqlListener() {
157	return transformSqlListener;	1✔
158	}
159
160	protected final Optional<Consumer<BeforeParseSqlEvent>> beforeParseSqlListener() {
161	return beforeParseSqlListener;	1✔
162	}
163
164	protected final Optional<Consumer<AfterGetOutParameterEvent>> afterGetOutParameterListener() {
165	return afterGetOutParameterListener;	1✔
166	}
167
168	protected final Optional<ExecutionConsumer<AfterCreatePreparedStatementEvent>> afterCreatePreparedStatementListener() {
169	return afterCreatePreparedStatementListener;	1✔
170	}
171
172	protected final Optional<ExecutionConsumer<AfterCreateCallableStatementEvent>> afterCreateCallableStatementListener() {
173	return afterCreateCallableStatementListener;	1✔
174	}
175
176	protected final Optional<ExecutionConsumer<SqlQueryEvent>> sqlQueryListener() {
177	return sqlQueryListener;	1✔
178	}
179
180	protected final Optional<ExecutionConsumer<SqlUpdateEvent>> sqlUpdateListener() {
181	return sqlUpdateListener;	1✔
182	}
183
184	protected final Optional<ExecutionConsumer<SqlBatchEvent>> sqlBatchListener() {
185	return sqlBatchListener;	1✔
186	}
187
188	protected final Optional<ExecutionConsumer<ProcedureEvent>> procedureListener() {
189	return procedureListener;	1✔
190	}
191
192	protected final Optional<Consumer<AfterBeginTransactionEvent>> afterBeginTransactionListener() {
193	return afterBeginTransactionListener;	1✔
194	}
195
196	protected final Optional<Consumer<BeforeEndTransactionEvent>> beforeEndTransactionListener() {
197	return beforeEndTransactionListener;	1✔
198	}
199
200	protected final Optional<Consumer<BeforeCommitEvent>> beforeCommitListener() {
201	return beforeCommitListener;	1✔
202	}
203
204	protected final Optional<Consumer<AfterCommitEvent>> afterCommitListener() {
205	return afterCommitListener;	1✔
206	}
207
208	protected final Optional<Consumer<BeforeRollbackEvent>> beforeRollbackListener() {
209	return beforeRollbackListener;	1✔
210	}
211
212	protected final Optional<Consumer<AfterRollbackEvent>> afterRollbackListener() {
213	return afterRollbackListener;	1✔
214	}
215
216	protected final void afterInitializeExecutionContextListener(
217	final Consumer<AfterInitializeExecutionContextEvent> listener) {
218	this.afterInitializeExecutionContextListener = Optional.ofNullable(listener);	1✔
219	}	1✔
220
221	protected final void beforeSetParameterListener(final Consumer<BeforeSetParameterEvent> listener) {
222	this.beforeSetParameterListener = Optional.ofNullable(listener);	1✔
223	}	1✔
224
225	protected final void transformSqlListener(final Consumer<TransformSqlEvent> listener) {
226	this.transformSqlListener = Optional.ofNullable(listener);	1✔
227	}	1✔
228
229	protected final void beforeParseSqlListener(final Consumer<BeforeParseSqlEvent> listener) {
NEW 230	this.beforeParseSqlListener = Optional.ofNullable(listener);	×
NEW 231	}	×
232
233	protected final void afterGetOutParameterListener(final Consumer<AfterGetOutParameterEvent> listener) {
234	this.afterGetOutParameterListener = Optional.ofNullable(listener);	1✔
235	}	1✔
236
237	protected final void afterCreatePreparedStatementListener(
238	final ExecutionConsumer<AfterCreatePreparedStatementEvent> listener) {
239	this.afterCreatePreparedStatementListener = Optional.ofNullable(listener);	1✔
240	}	1✔
241
242	protected final void afterCreateCallableStatementListener(
243	final ExecutionConsumer<AfterCreateCallableStatementEvent> listener) {
244	this.afterCreateCallableStatementListener = Optional.ofNullable(listener);	1✔
245	}	1✔
246
247	protected final void sqlQueryListener(final ExecutionConsumer<SqlQueryEvent> listener) {
248	this.sqlQueryListener = Optional.ofNullable(listener);	1✔
249	}	1✔
250
251	protected final void sqlUpdateListener(final ExecutionConsumer<SqlUpdateEvent> listener) {
252	this.sqlUpdateListener = Optional.ofNullable(listener);	1✔
253	}	1✔
254
255	protected final void sqlBatchListener(final ExecutionConsumer<SqlBatchEvent> listener) {
256	this.sqlBatchListener = Optional.ofNullable(listener);	1✔
257	}	1✔
258
259	protected final void procedureListener(final ExecutionConsumer<ProcedureEvent> listener) {
260	this.procedureListener = Optional.ofNullable(listener);	1✔
261	}	1✔
262
263	protected final void afterBeginTransactionListener(final Consumer<AfterBeginTransactionEvent> listener) {
264	this.afterBeginTransactionListener = Optional.ofNullable(listener);	1✔
265	}	1✔
266
267	protected final void beforeEndTransactionListener(final Consumer<BeforeEndTransactionEvent> listener) {
268	this.beforeEndTransactionListener = Optional.ofNullable(listener);	1✔
269	}	1✔
270
271	protected final void beforeCommitListener(final Consumer<BeforeCommitEvent> listener) {
272	this.beforeCommitListener = Optional.ofNullable(listener);	1✔
273	}	1✔
274
275	protected final void afterCommitListener(final Consumer<AfterCommitEvent> listener) {
276	this.afterCommitListener = Optional.ofNullable(listener);	1✔
277	}	1✔
278
279	protected final void beforeRollbackListener(final Consumer<BeforeRollbackEvent> listener) {
280	this.beforeRollbackListener = Optional.ofNullable(listener);	1✔
281	}	1✔
282
283	protected final void afterRollbackListener(final Consumer<AfterRollbackEvent> listener) {
284	this.afterRollbackListener = Optional.ofNullable(listener);	1✔
285	}	1✔
286
287	}

future-architect / uroborosql / #743

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous