#890

Committed 17 Aug 2025 03:45PM UTC coverage: 88.613% (+0.1%) from 88.472%

Build # #890

Build Type

Committed by

Commit Message

fix javadoc comment

Pull Request Pull Request #364: Add ConnectionSupplier Fix schema name option.

Run Details

128 of 140 new or added lines in 5 files covered. (91.43%)

6 existing lines in 3 files now uncovered.

8202 of 9256 relevant lines covered (88.61%)

0.89 hits per line

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

96.61

/src/main/java/jp/co/future/uroborosql/connection/DataSourceConnectionSupplierImpl.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.connection;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

import jp.co.future.uroborosql.exception.UroborosqlRuntimeException;
import jp.co.future.uroborosql.exception.UroborosqlSQLException;

/**
 * データソースを使用したコネクション供給クラス<br>
 * 指定されたデータソースからコネクションを取得する
 *
 * @author H.Sugimoto
 */
public class DataSourceConnectionSupplierImpl implements ConnectionSupplier {

        /** データソース名とデータソースのマップ */
        private final Map<String, DataSource> datasources = new ConcurrentHashMap<>();

        /** デフォルトデータソース用のDB接続情報 */
        private final DataSourceConnectionContext defaultConnectionContext;

        /**
         * コンストラクタ。
         */
        public DataSourceConnectionSupplierImpl() {
                this(ConnectionContextBuilder.dataSource());
        }

        /**
         * コンストラクタ。
         *
         * @param defaultDataSourceName 取得するコネクションのデータソース名
         */
        @Deprecated
        public DataSourceConnectionSupplierImpl(final String defaultDataSourceName) {
                this(ConnectionContextBuilder.dataSource(defaultDataSourceName));
        }

        /**
         * コンストラクタ。
         *
         * @param connectionContext DB接続情報
         */
        public DataSourceConnectionSupplierImpl(final DataSourceConnectionContext connectionContext) {
                this.defaultConnectionContext = connectionContext;
        }

        /**
         * コンストラクタ。
         *
         * @param defaultDataSource 取得するコネクションのデータソース
         */
        public DataSourceConnectionSupplierImpl(final DataSource defaultDataSource) {
                this();
                this.datasources.put(this.defaultConnectionContext.dataSourceName(), defaultDataSource);

        }

        /**
         * {@inheritDoc}
         *
         * @see jp.co.future.uroborosql.connection.ConnectionSupplier#getConnection()
         */
        @Override
        public Connection getConnection() {
                return getConnection(defaultConnectionContext);
        }

        /**
         * {@inheritDoc}
         *
         * @see jp.co.future.uroborosql.connection.ConnectionSupplier#getConnection(jp.co.future.uroborosql.connection.ConnectionContext)
         */
        @Override
        public Connection getConnection(final ConnectionContext ctx) {
                if (!(ctx instanceof DataSourceConnectionContext)) {
                        throw new IllegalArgumentException("ctx must be of type DataSourceConnectionContext.");
                }
                String datasourceName = ((DataSourceConnectionContext) ctx).dataSourceName();
                try {
                        DataSource ds = datasources.computeIfAbsent(datasourceName,
                                        DataSourceConnectionSupplierImpl::getNewDataSource);
                        final Connection connection;
                        synchronized (ds) {
                                Connection original = ds.getConnection();
                                if (ctx.fixSchema()) {
                                        String schemaName = ctx.fixedSchemaName();
                                        if (schemaName == null) {
                                                schemaName = original.getSchema();
                                                ctx.fixedSchemaName(schemaName);
                                        }
                                        connection = new SchemaFixedConnectionWrapper(original, schemaName);
                                } else {
                                        connection = new MetadataCachedConnectionWrapper(original, ctx.cacheSchema());
                                }
                        }
                        if (ctx.autoCommit() != connection.getAutoCommit()) {
                                connection.setAutoCommit(ctx.autoCommit());
                        }
                        if (ctx.readOnly() != connection.isReadOnly()) {
                                connection.setReadOnly(ctx.readOnly());
                        }
                        int transactionIsolation = ctx.transactionIsolation();
                        if (transactionIsolation > 0 && transactionIsolation != connection.getTransactionIsolation()) {
                                connection.setTransactionIsolation(transactionIsolation);
                        }
                        return connection;
                } catch (SQLException ex) {
                        throw new UroborosqlSQLException("Connection[" + datasourceName + "] can not be acquired.", ex);
                }
        }

        /**
         * ネーミングコンテキストから指定された名前のオブジェクトをLookupする
         * @param dataSourceName データソース名
         * @return Lookupで取得したデータソース
         * @exception UroborosqlRuntimeException データソースが見つからなかった場合
         */
        private static DataSource getNewDataSource(final String dataSourceName) {
                try {
                        Context context = new InitialContext();
                        return (DataSource) context.lookup(dataSourceName);
                } catch (NamingException ex) {
                        throw new UroborosqlRuntimeException("DataSource[" + dataSourceName + "] can not be acquired.", ex);
                }
        }

        /**
         * デフォルトデータソース名の取得
         *
         * @return デフォルトデータソース名
         */
        public String getDefaultDataSourceName() {
                return defaultConnectionContext.dataSourceName();
        }

        /**
         * デフォルトデータソース名の設定
         *
         * @param defaultDataSourceName デフォルトデータソース名
         */
        public void setDefaultDataSourceName(final String defaultDataSourceName) {
                defaultConnectionContext.dataSourceName(defaultDataSourceName);
        }

        /**
         * {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
         * で指定したデータソースに対するAutoCommitオプションの取得
         *
         * @return AutoCommitを行う場合は<code>true</code>. 初期値は<code>false</code>
         */
        public boolean isDefaultAutoCommit() {
                return defaultConnectionContext.autoCommit();
        }

        /**
         * {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
         * で指定したデータソースに対するAutoCommitオプションの指定
         *
         * @param autoCommit AutoCommitを行う場合は<code>true</code>
         */
        public void setDefaultAutoCommit(final boolean autoCommit) {
                defaultConnectionContext.autoCommit(autoCommit);
        }

        /**
         * {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
         * で指定したデータソースに対するReadOnlyオプションを取得
         *
         * @return readOnlyの場合は<code>true</code>. 初期値は<code>false</code>
         */
        public boolean isDefaultReadOnly() {
                return defaultConnectionContext.readOnly();
        }

        /**
         * {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
         * で指定したデータソースに対するReadOnlyオプションを指定
         *
         * @param readOnly readOnlyを指定する場合は<code>true</code>
         */
        public void setDefaultReadOnly(final boolean readOnly) {
                defaultConnectionContext.readOnly(readOnly);
        }

        /**
         * {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
         * で指定したデータソースに対するtransactionIsolationオプションの取得
         *
         * @return transactionIsolationの指定がない場合は<code>-1</code>. 指定がある場合はその値
         */
        public int getDefaultTransactionIsolation() {
                return defaultConnectionContext.transactionIsolation();
        }

        /**
         * {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
         * で指定したデータソースに対するtransactionIsolationオプションを指定
         *
         * @see Connection#TRANSACTION_READ_UNCOMMITTED
         * @see Connection#TRANSACTION_READ_COMMITTED
         * @see Connection#TRANSACTION_REPEATABLE_READ
         * @see Connection#TRANSACTION_SERIALIZABLE
         *
         * @param transactionIsolation transactionIsolationオプション
         *
         */
        public void setDefaultTransactionIsolation(final int transactionIsolation) {
                defaultConnectionContext.transactionIsolation(transactionIsolation);
        }

        /**
         * {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
         * で指定したデータソースに対するスキーマ名のキャッシュオプションの取得
         *
         * @return スキーマ名をキャッシュする場合は<code>true</code>
         */
        public boolean isDefaultCacheSchema() {
                return defaultConnectionContext.cacheSchema();
        }

        /**
         * デフォルトのDB接続情報にスキーマ名のキャッシュオプションを指定
         *
         * @param cache スキーマ名をキャッシュする場合は<code>true</code>
         */
        public void setDefaultCacheSchema(final boolean cache) {
                defaultConnectionContext.cacheSchema(cache);
        }

        /**
         * {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
         * で指定したデータソースに対するスキーマ名の固定オプションの取得
         *
         * @return スキーマ名を固定する場合は<code>true</code>
         */
        public boolean isDefaultFixSchema() {
                return defaultConnectionContext.fixSchema();
        }

        /**
         * デフォルトのDB接続情報にスキーマ名の固定オプションを指定
         *
         * @param fixed スキーマ名を固定する場合は<code>true</code>
         */
        public void setDefaultFixSchema(final boolean fixed) {
                defaultConnectionContext.fixSchema(fixed);
        }

}

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.connection;
8
9	import java.sql.Connection;
10	import java.sql.SQLException;
11	import java.util.Map;
12	import java.util.concurrent.ConcurrentHashMap;
13
14	import javax.naming.Context;
15	import javax.naming.InitialContext;
16	import javax.naming.NamingException;
17	import javax.sql.DataSource;
18
19	import jp.co.future.uroborosql.exception.UroborosqlRuntimeException;
20	import jp.co.future.uroborosql.exception.UroborosqlSQLException;
21
22	/**
23	* データソースを使用したコネクション供給クラス<br>
24	* 指定されたデータソースからコネクションを取得する
25	*
26	* @author H.Sugimoto
27	*/
28	public class DataSourceConnectionSupplierImpl implements ConnectionSupplier {
29
30	/** データソース名とデータソースのマップ */
31	private final Map<String, DataSource> datasources = new ConcurrentHashMap<>();	1✔
32
33	/** デフォルトデータソース用のDB接続情報 */
34	private final DataSourceConnectionContext defaultConnectionContext;
35
36	/**
37	* コンストラクタ。
38	*/
39	public DataSourceConnectionSupplierImpl() {
40	this(ConnectionContextBuilder.dataSource());	1✔
41	}	1✔
42
43	/**
44	* コンストラクタ。
45	*
46	* @param defaultDataSourceName 取得するコネクションのデータソース名
47	*/
48	@Deprecated
49	public DataSourceConnectionSupplierImpl(final String defaultDataSourceName) {
50	this(ConnectionContextBuilder.dataSource(defaultDataSourceName));	1✔
51	}	1✔
52
53	/**
54	* コンストラクタ。
55	*
56	* @param connectionContext DB接続情報
57	*/
58	public DataSourceConnectionSupplierImpl(final DataSourceConnectionContext connectionContext) {	1✔
59	this.defaultConnectionContext = connectionContext;	1✔
60	}	1✔
61
62	/**
63	* コンストラクタ。
64	*
65	* @param defaultDataSource 取得するコネクションのデータソース
66	*/
67	public DataSourceConnectionSupplierImpl(final DataSource defaultDataSource) {
68	this();	1✔
69	this.datasources.put(this.defaultConnectionContext.dataSourceName(), defaultDataSource);	1✔
70
71	}	1✔
72
73	/**
74	* {@inheritDoc}
75	*
76	* @see jp.co.future.uroborosql.connection.ConnectionSupplier#getConnection()
77	*/
78	@Override
79	public Connection getConnection() {
80	return getConnection(defaultConnectionContext);	1✔
81	}
82
83	/**
84	* {@inheritDoc}
85	*
86	* @see jp.co.future.uroborosql.connection.ConnectionSupplier#getConnection(jp.co.future.uroborosql.connection.ConnectionContext)
87	*/
88	@Override
89	public Connection getConnection(final ConnectionContext ctx) {
90	if (!(ctx instanceof DataSourceConnectionContext)) {	1✔
91	throw new IllegalArgumentException("ctx must be of type DataSourceConnectionContext.");	1✔
92	}
93	String datasourceName = ((DataSourceConnectionContext) ctx).dataSourceName();	1✔
94	try {
95	DataSource ds = datasources.computeIfAbsent(datasourceName,	1✔
96	DataSourceConnectionSupplierImpl::getNewDataSource);
97	final Connection connection;
98	synchronized (ds) {	1✔
99	Connection original = ds.getConnection();	1✔
100	if (ctx.fixSchema()) {	1✔
101	String schemaName = ctx.fixedSchemaName();	1✔
102	if (schemaName == null) {	1✔
103	schemaName = original.getSchema();	1✔
104	ctx.fixedSchemaName(schemaName);	1✔
105	}
106	connection = new SchemaFixedConnectionWrapper(original, schemaName);	1✔
107	} else {	1✔
108	connection = new MetadataCachedConnectionWrapper(original, ctx.cacheSchema());	1✔
109	}
110	}	1✔
111	if (ctx.autoCommit() != connection.getAutoCommit()) {	1✔
112	connection.setAutoCommit(ctx.autoCommit());	1✔
113	}
114	if (ctx.readOnly() != connection.isReadOnly()) {	1✔
115	connection.setReadOnly(ctx.readOnly());	1✔
116	}
117	int transactionIsolation = ctx.transactionIsolation();	1✔
118	if (transactionIsolation > 0 && transactionIsolation != connection.getTransactionIsolation()) {	1✔
119	connection.setTransactionIsolation(transactionIsolation);	1✔
120	}
121	return connection;	1✔
UNCOV 122	} catch (SQLException ex) {	×
UNCOV 123	throw new UroborosqlSQLException("Connection[" + datasourceName + "] can not be acquired.", ex);	×
124	}
125	}
126
127	/**
128	* ネーミングコンテキストから指定された名前のオブジェクトをLookupする
129	* @param dataSourceName データソース名
130	* @return Lookupで取得したデータソース
131	* @exception UroborosqlRuntimeException データソースが見つからなかった場合
132	*/
133	private static DataSource getNewDataSource(final String dataSourceName) {
134	try {
135	Context context = new InitialContext();	1✔
136	return (DataSource) context.lookup(dataSourceName);	1✔
137	} catch (NamingException ex) {	1✔
138	throw new UroborosqlRuntimeException("DataSource[" + dataSourceName + "] can not be acquired.", ex);	1✔
139	}
140	}
141
142	/**
143	* デフォルトデータソース名の取得
144	*
145	* @return デフォルトデータソース名
146	*/
147	public String getDefaultDataSourceName() {
148	return defaultConnectionContext.dataSourceName();	1✔
149	}
150
151	/**
152	* デフォルトデータソース名の設定
153	*
154	* @param defaultDataSourceName デフォルトデータソース名
155	*/
156	public void setDefaultDataSourceName(final String defaultDataSourceName) {
157	defaultConnectionContext.dataSourceName(defaultDataSourceName);	1✔
158	}	1✔
159
160	/**
161	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
162	* で指定したデータソースに対するAutoCommitオプションの取得
163	*
164	* @return AutoCommitを行う場合は<code>true</code>. 初期値は<code>false</code>
165	*/
166	public boolean isDefaultAutoCommit() {
167	return defaultConnectionContext.autoCommit();	1✔
168	}
169
170	/**
171	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
172	* で指定したデータソースに対するAutoCommitオプションの指定
173	*
174	* @param autoCommit AutoCommitを行う場合は<code>true</code>
175	*/
176	public void setDefaultAutoCommit(final boolean autoCommit) {
177	defaultConnectionContext.autoCommit(autoCommit);	1✔
178	}	1✔
179
180	/**
181	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
182	* で指定したデータソースに対するReadOnlyオプションを取得
183	*
184	* @return readOnlyの場合は<code>true</code>. 初期値は<code>false</code>
185	*/
186	public boolean isDefaultReadOnly() {
187	return defaultConnectionContext.readOnly();	1✔
188	}
189
190	/**
191	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
192	* で指定したデータソースに対するReadOnlyオプションを指定
193	*
194	* @param readOnly readOnlyを指定する場合は<code>true</code>
195	*/
196	public void setDefaultReadOnly(final boolean readOnly) {
197	defaultConnectionContext.readOnly(readOnly);	1✔
198	}	1✔
199
200	/**
201	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
202	* で指定したデータソースに対するtransactionIsolationオプションの取得
203	*
204	* @return transactionIsolationの指定がない場合は<code>-1</code>. 指定がある場合はその値
205	*/
206	public int getDefaultTransactionIsolation() {
207	return defaultConnectionContext.transactionIsolation();	1✔
208	}
209
210	/**
211	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
212	* で指定したデータソースに対するtransactionIsolationオプションを指定
213	*
214	* @see Connection#TRANSACTION_READ_UNCOMMITTED
215	* @see Connection#TRANSACTION_READ_COMMITTED
216	* @see Connection#TRANSACTION_REPEATABLE_READ
217	* @see Connection#TRANSACTION_SERIALIZABLE
218	*
219	* @param transactionIsolation transactionIsolationオプション
220	*
221	*/
222	public void setDefaultTransactionIsolation(final int transactionIsolation) {
223	defaultConnectionContext.transactionIsolation(transactionIsolation);	1✔
224	}	1✔
225
226	/**
227	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
228	* で指定したデータソースに対するスキーマ名のキャッシュオプションの取得
229	*
230	* @return スキーマ名をキャッシュする場合は<code>true</code>
231	*/
232	public boolean isDefaultCacheSchema() {
233	return defaultConnectionContext.cacheSchema();	1✔
234	}
235
236	/**
237	* デフォルトのDB接続情報にスキーマ名のキャッシュオプションを指定
238	*
239	* @param cache スキーマ名をキャッシュする場合は<code>true</code>
240	*/
241	public void setDefaultCacheSchema(final boolean cache) {
242	defaultConnectionContext.cacheSchema(cache);	1✔
243	}	1✔
244
245	/**
246	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
247	* で指定したデータソースに対するスキーマ名の固定オプションの取得
248	*
249	* @return スキーマ名を固定する場合は<code>true</code>
250	*/
251	public boolean isDefaultFixSchema() {
252	return defaultConnectionContext.fixSchema();	1✔
253	}
254
255	/**
256	* デフォルトのDB接続情報にスキーマ名の固定オプションを指定
257	*
258	* @param fixed スキーマ名を固定する場合は<code>true</code>
259	*/
260	public void setDefaultFixSchema(final boolean fixed) {
261	defaultConnectionContext.fixSchema(fixed);	1✔
262	}	1✔
263
264	}

future-architect / uroborosql / #890

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