#866

Committed 03 Aug 2025 05:27PM UTC coverage: 88.491% (-1.7%) from 90.172%

Build # #866

Build Type

Committed by

Commit Message

add setCacheSchema API for ConnectionSupplier.

Pull Request Pull Request #360: cache DatabaseMetaData fixed value and Connection getSchema value.

Run Details

143 of 326 new or added lines in 8 files covered. (43.87%)

2 existing lines in 1 file now uncovered.

8073 of 9123 relevant lines covered (88.49%)

0.88 hits per line

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

96.81

/src/main/java/jp/co/future/uroborosql/connection/MetadataCachedConnectionWrapper.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.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

/**
 * DatabaseMetadataの一部をキャッシュするConnectionを提供するためのWrapper
 *
 * @author H.Sugimoto
 * @since v0.26.10
 */
public class MetadataCachedConnectionWrapper implements Connection {

        /** Original connection. */
        private final Connection original;

        /** Whether to cache the schema name. */
        private boolean cacheSchema;

        /** Cached DatabaseMetaData. */
        private DatabaseMetaData cachedMetadata = null;

        /** Cached Schema Name. */
        private String cachedSchemaName = null;

        /**
         * コンストラクタ
         *
         * @param original 元となるコネクション
         * @param cacheSchema スキーマ名をキャッシュするかどうか. キャッシュする場合は <code>true</code>
         */
        MetadataCachedConnectionWrapper(final Connection original, final boolean cacheSchema) {
                this.original = original;
                this.cacheSchema = cacheSchema;
        }

        /**
         * スキーマ名をキャッシュするかどうかを取得する.
         *
         * @return スキーマ名をキャッシュする場合<code>true</code>.
         */
        public boolean isCacheSchema() {
                return cacheSchema;
        }

        /**
         * スキーマ名をキャッシュするかどうかを設定する.
         *
         * @param cacheSchema スキーマ名をキャッシュするかどうか. キャッシュする場合<code>true</code>
         */
        public void setCacheSchema(final boolean cacheSchema) {
                this.cacheSchema = cacheSchema;
        }

        @SuppressWarnings("unchecked")
        @Override
        public <T> T unwrap(final Class<T> iface) throws SQLException {
                if (!isWrapperFor(iface)) {
                        throw new SQLException("Cannot unwrap to " + iface.getName());
                }
                if (iface.isInstance(this)) {
                        return (T) this;
                }
                return original.unwrap(iface);
        }

        @Override
        public boolean isWrapperFor(final Class<?> iface) throws SQLException {
                if (iface.isInstance(this)) {
                        return true;
                }
                return original.isWrapperFor(iface);
        }

        @Override
        public Statement createStatement() throws SQLException {
                return original.createStatement();
        }

        @Override
        public PreparedStatement prepareStatement(final String sql) throws SQLException {
                return original.prepareStatement(sql);
        }

        @Override
        public CallableStatement prepareCall(final String sql) throws SQLException {
                return original.prepareCall(sql);
        }

        @Override
        public String nativeSQL(final String sql) throws SQLException {
                return original.nativeSQL(sql);
        }

        @Override
        public void setAutoCommit(final boolean autoCommit) throws SQLException {
                original.setAutoCommit(autoCommit);
        }

        @Override
        public boolean getAutoCommit() throws SQLException {
                return original.getAutoCommit();
        }

        @Override
        public void commit() throws SQLException {
                original.commit();
        }

        @Override
        public void rollback() throws SQLException {
                original.rollback();
        }

        @Override
        public void close() throws SQLException {
                // コネクションのクローズタイミングでスキーマのキャッシュをクリアすることで、コネクションプールから再取得された場合に前回キャッシュした内容が残ることを防ぐ
                cachedSchemaName = null;
                original.close();
        }

        @Override
        public boolean isClosed() throws SQLException {
                return original.isClosed();
        }

        @Override
        public DatabaseMetaData getMetaData() throws SQLException {
                if (cachedMetadata == null) {
                        cachedMetadata = new CachedDatabaseMetaData(original.getMetaData(), this);
                }
                return cachedMetadata;
        }

        @Override
        public void setReadOnly(final boolean readOnly) throws SQLException {
                original.setReadOnly(readOnly);
        }

        @Override
        public boolean isReadOnly() throws SQLException {
                return original.isReadOnly();
        }

        @Override
        public void setCatalog(final String catalog) throws SQLException {
                original.setCatalog(catalog);
        }

        @Override
        public String getCatalog() throws SQLException {
                return original.getCatalog();
        }

        @Override
        public void setTransactionIsolation(final int level) throws SQLException {
                original.setTransactionIsolation(level);
        }

        @Override
        public int getTransactionIsolation() throws SQLException {
                return original.getTransactionIsolation();
        }

        @Override
        public SQLWarning getWarnings() throws SQLException {
                return original.getWarnings();
        }

        @Override
        public void clearWarnings() throws SQLException {
                original.clearWarnings();
        }

        @Override
        public Statement createStatement(final int resultSetType, final int resultSetConcurrency) throws SQLException {
                return original.createStatement(resultSetType, resultSetConcurrency);
        }

        @Override
        public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
                        throws SQLException {
                return original.prepareStatement(sql, resultSetType, resultSetConcurrency);
        }

        @Override
        public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
                        throws SQLException {
                return original.prepareCall(sql, resultSetType, resultSetConcurrency);
        }

        @Override
        public Map<String, Class<?>> getTypeMap() throws SQLException {
                return original.getTypeMap();
        }

        @Override
        public void setTypeMap(final Map<String, Class<?>> map) throws SQLException {
                original.setTypeMap(map);
        }

        @Override
        public void setHoldability(final int holdability) throws SQLException {
                original.setHoldability(holdability);
        }

        @Override
        public int getHoldability() throws SQLException {
                return original.getHoldability();
        }

        @Override
        public Savepoint setSavepoint() throws SQLException {
                return original.setSavepoint();
        }

        @Override
        public Savepoint setSavepoint(final String name) throws SQLException {
                return original.setSavepoint(name);
        }

        @Override
        public void rollback(final Savepoint savepoint) throws SQLException {
                original.rollback(savepoint);
        }

        @Override
        public void releaseSavepoint(final Savepoint savepoint) throws SQLException {
                original.releaseSavepoint(savepoint);
        }

        @Override
        public Statement createStatement(final int resultSetType, final int resultSetConcurrency,
                        final int resultSetHoldability)
                        throws SQLException {
                return original.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
        }

        @Override
        public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
                        final int resultSetHoldability) throws SQLException {
                return original.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
        }

        @Override
        public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
                        final int resultSetHoldability) throws SQLException {
                return original.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
        }

        @Override
        public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
                return original.prepareStatement(sql, autoGeneratedKeys);
        }

        @Override
        public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
                return original.prepareStatement(sql, columnIndexes);
        }

        @Override
        public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
                return original.prepareStatement(sql, columnNames);
        }

        @Override
        public Clob createClob() throws SQLException {
                return original.createClob();
        }

        @Override
        public Blob createBlob() throws SQLException {
                return original.createBlob();
        }

        @Override
        public NClob createNClob() throws SQLException {
                return original.createNClob();
        }

        @Override
        public SQLXML createSQLXML() throws SQLException {
                return original.createSQLXML();
        }

        @Override
        public boolean isValid(final int timeout) throws SQLException {
                return original.isValid(timeout);
        }

        @Override
        public void setClientInfo(final String name, final String value) throws SQLClientInfoException {
                original.setClientInfo(name, value);
        }

        @Override
        public void setClientInfo(final Properties properties) throws SQLClientInfoException {
                original.setClientInfo(properties);
        }

        @Override
        public String getClientInfo(final String name) throws SQLException {
                return original.getClientInfo(name);
        }

        @Override
        public Properties getClientInfo() throws SQLException {
                return original.getClientInfo();
        }

        @Override
        public Array createArrayOf(final String typeName, final Object[] elements) throws SQLException {
                return original.createArrayOf(typeName, elements);
        }

        @Override
        public Struct createStruct(final String typeName, final Object[] attributes) throws SQLException {
                return original.createStruct(typeName, attributes);
        }

        @Override
        public void setSchema(final String schema) throws SQLException {
                original.setSchema(schema);
                cachedSchemaName = schema;
        }

        @Override
        public String getSchema() throws SQLException {
                if (!cacheSchema) {
                        return original.getSchema();
                } else {
                        if (cachedSchemaName == null) {
                                cachedSchemaName = original.getSchema();
                        }
                        return cachedSchemaName;
                }
        }

        @Override
        public void abort(final Executor executor) throws SQLException {
                original.abort(executor);
        }

        @Override
        public void setNetworkTimeout(final Executor executor, final int milliseconds) throws SQLException {
                original.setNetworkTimeout(executor, milliseconds);
        }

        @Override
        public int getNetworkTimeout() throws SQLException {
                return original.getNetworkTimeout();
        }

}

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.Array;
10	import java.sql.Blob;
11	import java.sql.CallableStatement;
12	import java.sql.Clob;
13	import java.sql.Connection;
14	import java.sql.DatabaseMetaData;
15	import java.sql.NClob;
16	import java.sql.PreparedStatement;
17	import java.sql.SQLClientInfoException;
18	import java.sql.SQLException;
19	import java.sql.SQLWarning;
20	import java.sql.SQLXML;
21	import java.sql.Savepoint;
22	import java.sql.Statement;
23	import java.sql.Struct;
24	import java.util.Map;
25	import java.util.Properties;
26	import java.util.concurrent.Executor;
27
28	/**
29	* DatabaseMetadataの一部をキャッシュするConnectionを提供するためのWrapper
30	*
31	* @author H.Sugimoto
32	* @since v0.26.10
33	*/
34	public class MetadataCachedConnectionWrapper implements Connection {
35
36	/** Original connection. */
37	private final Connection original;
38
39	/** Whether to cache the schema name. */
40	private boolean cacheSchema;
41
42	/** Cached DatabaseMetaData. */
43	private DatabaseMetaData cachedMetadata = null;	1✔
44
45	/** Cached Schema Name. */
46	private String cachedSchemaName = null;	1✔
47
48	/**
49	* コンストラクタ
50	*
51	* @param original 元となるコネクション
52	* @param cacheSchema スキーマ名をキャッシュするかどうか. キャッシュする場合は <code>true</code>
53	*/
54	MetadataCachedConnectionWrapper(final Connection original, final boolean cacheSchema) {	1✔
55	this.original = original;	1✔
56	this.cacheSchema = cacheSchema;	1✔
57	}	1✔
58
59	/**
60	* スキーマ名をキャッシュするかどうかを取得する.
61	*
62	* @return スキーマ名をキャッシュする場合<code>true</code>.
63	*/
64	public boolean isCacheSchema() {
65	return cacheSchema;	1✔
66	}
67
68	/**
69	* スキーマ名をキャッシュするかどうかを設定する.
70	*
71	* @param cacheSchema スキーマ名をキャッシュするかどうか. キャッシュする場合<code>true</code>
72	*/
73	public void setCacheSchema(final boolean cacheSchema) {
74	this.cacheSchema = cacheSchema;	1✔
75	}	1✔
76
77	@SuppressWarnings("unchecked")
78	@Override
79	public <T> T unwrap(final Class<T> iface) throws SQLException {
80	if (!isWrapperFor(iface)) {	1✔
NEW 81	throw new SQLException("Cannot unwrap to " + iface.getName());	×
82	}
83	if (iface.isInstance(this)) {	1✔
84	return (T) this;	1✔
85	}
NEW 86	return original.unwrap(iface);	×
87	}
88
89	@Override
90	public boolean isWrapperFor(final Class<?> iface) throws SQLException {
91	if (iface.isInstance(this)) {	1✔
92	return true;	1✔
93	}
94	return original.isWrapperFor(iface);	1✔
95	}
96
97	@Override
98	public Statement createStatement() throws SQLException {
99	return original.createStatement();	1✔
100	}
101
102	@Override
103	public PreparedStatement prepareStatement(final String sql) throws SQLException {
104	return original.prepareStatement(sql);	1✔
105	}
106
107	@Override
108	public CallableStatement prepareCall(final String sql) throws SQLException {
109	return original.prepareCall(sql);	1✔
110	}
111
112	@Override
113	public String nativeSQL(final String sql) throws SQLException {
114	return original.nativeSQL(sql);	1✔
115	}
116
117	@Override
118	public void setAutoCommit(final boolean autoCommit) throws SQLException {
119	original.setAutoCommit(autoCommit);	1✔
120	}	1✔
121
122	@Override
123	public boolean getAutoCommit() throws SQLException {
124	return original.getAutoCommit();	1✔
125	}
126
127	@Override
128	public void commit() throws SQLException {
129	original.commit();	1✔
130	}	1✔
131
132	@Override
133	public void rollback() throws SQLException {
134	original.rollback();	1✔
135	}	1✔
136
137	@Override
138	public void close() throws SQLException {
139	// コネクションのクローズタイミングでスキーマのキャッシュをクリアすることで、コネクションプールから再取得された場合に前回キャッシュした内容が残ることを防ぐ
140	cachedSchemaName = null;	1✔
141	original.close();	1✔
142	}	1✔
143
144	@Override
145	public boolean isClosed() throws SQLException {
146	return original.isClosed();	1✔
147	}
148
149	@Override
150	public DatabaseMetaData getMetaData() throws SQLException {
151	if (cachedMetadata == null) {	1✔
152	cachedMetadata = new CachedDatabaseMetaData(original.getMetaData(), this);	1✔
153	}
154	return cachedMetadata;	1✔
155	}
156
157	@Override
158	public void setReadOnly(final boolean readOnly) throws SQLException {
159	original.setReadOnly(readOnly);	1✔
160	}	1✔
161
162	@Override
163	public boolean isReadOnly() throws SQLException {
164	return original.isReadOnly();	1✔
165	}
166
167	@Override
168	public void setCatalog(final String catalog) throws SQLException {
169	original.setCatalog(catalog);	1✔
170	}	1✔
171
172	@Override
173	public String getCatalog() throws SQLException {
174	return original.getCatalog();	1✔
175	}
176
177	@Override
178	public void setTransactionIsolation(final int level) throws SQLException {
179	original.setTransactionIsolation(level);	1✔
180	}	1✔
181
182	@Override
183	public int getTransactionIsolation() throws SQLException {
184	return original.getTransactionIsolation();	1✔
185	}
186
187	@Override
188	public SQLWarning getWarnings() throws SQLException {
189	return original.getWarnings();	1✔
190	}
191
192	@Override
193	public void clearWarnings() throws SQLException {
194	original.clearWarnings();	1✔
195	}	1✔
196
197	@Override
198	public Statement createStatement(final int resultSetType, final int resultSetConcurrency) throws SQLException {
199	return original.createStatement(resultSetType, resultSetConcurrency);	1✔
200	}
201
202	@Override
203	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
204	throws SQLException {
205	return original.prepareStatement(sql, resultSetType, resultSetConcurrency);	1✔
206	}
207
208	@Override
209	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
210	throws SQLException {
211	return original.prepareCall(sql, resultSetType, resultSetConcurrency);	1✔
212	}
213
214	@Override
215	public Map<String, Class<?>> getTypeMap() throws SQLException {
216	return original.getTypeMap();	1✔
217	}
218
219	@Override
220	public void setTypeMap(final Map<String, Class<?>> map) throws SQLException {
221	original.setTypeMap(map);	1✔
222	}	1✔
223
224	@Override
225	public void setHoldability(final int holdability) throws SQLException {
226	original.setHoldability(holdability);	1✔
227	}	1✔
228
229	@Override
230	public int getHoldability() throws SQLException {
231	return original.getHoldability();	1✔
232	}
233
234	@Override
235	public Savepoint setSavepoint() throws SQLException {
236	return original.setSavepoint();	1✔
237	}
238
239	@Override
240	public Savepoint setSavepoint(final String name) throws SQLException {
241	return original.setSavepoint(name);	1✔
242	}
243
244	@Override
245	public void rollback(final Savepoint savepoint) throws SQLException {
246	original.rollback(savepoint);	1✔
247	}	1✔
248
249	@Override
250	public void releaseSavepoint(final Savepoint savepoint) throws SQLException {
251	original.releaseSavepoint(savepoint);	1✔
252	}	1✔
253
254	@Override
255	public Statement createStatement(final int resultSetType, final int resultSetConcurrency,
256	final int resultSetHoldability)
257	throws SQLException {
258	return original.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
259	}
260
261	@Override
262	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
263	final int resultSetHoldability) throws SQLException {
264	return original.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
265	}
266
267	@Override
268	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
269	final int resultSetHoldability) throws SQLException {
270	return original.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
271	}
272
273	@Override
274	public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
275	return original.prepareStatement(sql, autoGeneratedKeys);	1✔
276	}
277
278	@Override
279	public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
280	return original.prepareStatement(sql, columnIndexes);	1✔
281	}
282
283	@Override
284	public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
285	return original.prepareStatement(sql, columnNames);	1✔
286	}
287
288	@Override
289	public Clob createClob() throws SQLException {
290	return original.createClob();	1✔
291	}
292
293	@Override
294	public Blob createBlob() throws SQLException {
295	return original.createBlob();	1✔
296	}
297
298	@Override
299	public NClob createNClob() throws SQLException {
300	return original.createNClob();	1✔
301	}
302
303	@Override
304	public SQLXML createSQLXML() throws SQLException {
305	return original.createSQLXML();	1✔
306	}
307
308	@Override
309	public boolean isValid(final int timeout) throws SQLException {
310	return original.isValid(timeout);	1✔
311	}
312
313	@Override
314	public void setClientInfo(final String name, final String value) throws SQLClientInfoException {
315	original.setClientInfo(name, value);	1✔
316	}	1✔
317
318	@Override
319	public void setClientInfo(final Properties properties) throws SQLClientInfoException {
320	original.setClientInfo(properties);	1✔
321	}	1✔
322
323	@Override
324	public String getClientInfo(final String name) throws SQLException {
325	return original.getClientInfo(name);	1✔
326	}
327
328	@Override
329	public Properties getClientInfo() throws SQLException {
330	return original.getClientInfo();	1✔
331	}
332
333	@Override
334	public Array createArrayOf(final String typeName, final Object[] elements) throws SQLException {
335	return original.createArrayOf(typeName, elements);	1✔
336	}
337
338	@Override
339	public Struct createStruct(final String typeName, final Object[] attributes) throws SQLException {
NEW 340	return original.createStruct(typeName, attributes);	×
341	}
342
343	@Override
344	public void setSchema(final String schema) throws SQLException {
345	original.setSchema(schema);	1✔
346	cachedSchemaName = schema;	1✔
347	}	1✔
348
349	@Override
350	public String getSchema() throws SQLException {
351	if (!cacheSchema) {	1✔
352	return original.getSchema();	1✔
353	} else {
354	if (cachedSchemaName == null) {	1✔
355	cachedSchemaName = original.getSchema();	1✔
356	}
357	return cachedSchemaName;	1✔
358	}
359	}
360
361	@Override
362	public void abort(final Executor executor) throws SQLException {
363	original.abort(executor);	1✔
364	}	1✔
365
366	@Override
367	public void setNetworkTimeout(final Executor executor, final int milliseconds) throws SQLException {
368	original.setNetworkTimeout(executor, milliseconds);	1✔
369	}	1✔
370
371	@Override
372	public int getNetworkTimeout() throws SQLException {
373	return original.getNetworkTimeout();	1✔
374	}
375
376	}

future-architect / uroborosql / #866

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