#872

Committed 04 Aug 2025 02:28PM UTC coverage: 88.472% (-1.7%) from 90.172%

Build # #872

Build Type

push

Committed by

Commit Message

cache DatabaseMetaData fixed value and Connection getSchema value. (#360)

* cache DatabaseMetaData fixed value and Connection getSchema value.

* add setCacheSchema API for ConnectionSupplier.

* add Connection#toString()

* fix review comment.

Run Details

144 of 329 new or added lines in 8 files covered. (43.77%)

2 existing lines in 1 file now uncovered.

8074 of 9126 relevant lines covered (88.47%)

0.88 hits per line

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

89.58

/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 = new MetadataCachedConnectionWrapper(ds.getConnection(), 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);
        }

}

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 = new MetadataCachedConnectionWrapper(ds.getConnection(), ctx.cacheSchema());	1✔
100	}	1✔
101	if (ctx.autoCommit() != connection.getAutoCommit()) {	1✔
102	connection.setAutoCommit(ctx.autoCommit());	1✔
103	}
104	if (ctx.readOnly() != connection.isReadOnly()) {	1✔
105	connection.setReadOnly(ctx.readOnly());	1✔
106	}
107	int transactionIsolation = ctx.transactionIsolation();	1✔
108	if (transactionIsolation > 0 && transactionIsolation != connection.getTransactionIsolation()) {	1✔
109	connection.setTransactionIsolation(transactionIsolation);	1✔
110	}
111	return connection;	1✔
112	} catch (SQLException ex) {	×
113	throw new UroborosqlSQLException("Connection[" + datasourceName + "] can not be acquired.", ex);	×
114	}
115	}
116
117	/**
118	* ネーミングコンテキストから指定された名前のオブジェクトをLookupする
119	* @param dataSourceName データソース名
120	* @return Lookupで取得したデータソース
121	* @exception UroborosqlRuntimeException データソースが見つからなかった場合
122	*/
123	private static DataSource getNewDataSource(final String dataSourceName) {
124	try {
125	Context context = new InitialContext();	1✔
126	return (DataSource) context.lookup(dataSourceName);	1✔
127	} catch (NamingException ex) {	1✔
128	throw new UroborosqlRuntimeException("DataSource[" + dataSourceName + "] can not be acquired.", ex);	1✔
129	}
130	}
131
132	/**
133	* デフォルトデータソース名の取得
134	*
135	* @return デフォルトデータソース名
136	*/
137	public String getDefaultDataSourceName() {
138	return defaultConnectionContext.dataSourceName();	1✔
139	}
140
141	/**
142	* デフォルトデータソース名の設定
143	*
144	* @param defaultDataSourceName デフォルトデータソース名
145	*/
146	public void setDefaultDataSourceName(final String defaultDataSourceName) {
147	defaultConnectionContext.dataSourceName(defaultDataSourceName);	1✔
148	}	1✔
149
150	/**
151	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
152	* で指定したデータソースに対するAutoCommitオプションの取得
153	*
154	* @return AutoCommitを行う場合は<code>true</code>. 初期値は<code>false</code>
155	*/
156	public boolean isDefaultAutoCommit() {
157	return defaultConnectionContext.autoCommit();	1✔
158	}
159
160	/**
161	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
162	* で指定したデータソースに対するAutoCommitオプションの指定
163	*
164	* @param autoCommit AutoCommitを行う場合は<code>true</code>
165	*/
166	public void setDefaultAutoCommit(final boolean autoCommit) {
167	defaultConnectionContext.autoCommit(autoCommit);	1✔
168	}	1✔
169
170	/**
171	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
172	* で指定したデータソースに対するReadOnlyオプションを取得
173	*
174	* @return readOnlyの場合は<code>true</code>. 初期値は<code>false</code>
175	*/
176	public boolean isDefaultReadOnly() {
177	return defaultConnectionContext.readOnly();	1✔
178	}
179
180	/**
181	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
182	* で指定したデータソースに対するReadOnlyオプションを指定
183	*
184	* @param readOnly readOnlyを指定する場合は<code>true</code>
185	*/
186	public void setDefaultReadOnly(final boolean readOnly) {
187	defaultConnectionContext.readOnly(readOnly);	1✔
188	}	1✔
189
190	/**
191	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
192	* で指定したデータソースに対するtransactionIsolationオプションの取得
193	*
194	* @return transactionIsolationの指定がない場合は<code>-1</code>. 指定がある場合はその値
195	*/
196	public int getDefaultTransactionIsolation() {
197	return defaultConnectionContext.transactionIsolation();	1✔
198	}
199
200	/**
201	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
202	* で指定したデータソースに対するtransactionIsolationオプションを指定
203	*
204	* @see Connection#TRANSACTION_READ_UNCOMMITTED
205	* @see Connection#TRANSACTION_READ_COMMITTED
206	* @see Connection#TRANSACTION_REPEATABLE_READ
207	* @see Connection#TRANSACTION_SERIALIZABLE
208	*
209	* @param transactionIsolation transactionIsolationオプション
210	*
211	*/
212	public void setDefaultTransactionIsolation(final int transactionIsolation) {
213	defaultConnectionContext.transactionIsolation(transactionIsolation);	1✔
214	}	1✔
215
216	/**
217	* {@link DataSourceConnectionSupplierImpl#setDefaultDataSourceName(String)}
218	* で指定したデータソースに対するスキーマ名のキャッシュオプションの取得
219	*
220	* @return スキーマ名をキャッシュする場合は<code>true</code>
221	*/
222	public boolean isDefaultCacheSchema() {
NEW 223	return defaultConnectionContext.cacheSchema();	×
224	}
225
226	/**
227	* デフォルトのDB接続情報にスキーマ名のキャッシュオプションを指定
228	*
229	* @param cache スキーマ名をキャッシュする場合は<code>true</code>
230	*/
231	public void setDefaultCacheSchema(final boolean cache) {
NEW 232	defaultConnectionContext.cacheSchema(cache);	×
NEW 233	}	×
234
235	}

future-architect / uroborosql / #872

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