#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

95.83

/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;
                cachedMetadata = 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();
        }

        @Override
        public String toString() {
                return original.toString();
        }

}

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	// コネクションプールから再取得された場合に前回キャッシュした内容が残ることを防ぐ
141	cachedSchemaName = null;	1✔
142	cachedMetadata = null;	1✔
143	original.close();	1✔
144	}	1✔
145
146	@Override
147	public boolean isClosed() throws SQLException {
148	return original.isClosed();	1✔
149	}
150
151	@Override
152	public DatabaseMetaData getMetaData() throws SQLException {
153	if (cachedMetadata == null) {	1✔
154	cachedMetadata = new CachedDatabaseMetaData(original.getMetaData(), this);	1✔
155	}
156	return cachedMetadata;	1✔
157	}
158
159	@Override
160	public void setReadOnly(final boolean readOnly) throws SQLException {
161	original.setReadOnly(readOnly);	1✔
162	}	1✔
163
164	@Override
165	public boolean isReadOnly() throws SQLException {
166	return original.isReadOnly();	1✔
167	}
168
169	@Override
170	public void setCatalog(final String catalog) throws SQLException {
171	original.setCatalog(catalog);	1✔
172	}	1✔
173
174	@Override
175	public String getCatalog() throws SQLException {
176	return original.getCatalog();	1✔
177	}
178
179	@Override
180	public void setTransactionIsolation(final int level) throws SQLException {
181	original.setTransactionIsolation(level);	1✔
182	}	1✔
183
184	@Override
185	public int getTransactionIsolation() throws SQLException {
186	return original.getTransactionIsolation();	1✔
187	}
188
189	@Override
190	public SQLWarning getWarnings() throws SQLException {
191	return original.getWarnings();	1✔
192	}
193
194	@Override
195	public void clearWarnings() throws SQLException {
196	original.clearWarnings();	1✔
197	}	1✔
198
199	@Override
200	public Statement createStatement(final int resultSetType, final int resultSetConcurrency) throws SQLException {
201	return original.createStatement(resultSetType, resultSetConcurrency);	1✔
202	}
203
204	@Override
205	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
206	throws SQLException {
207	return original.prepareStatement(sql, resultSetType, resultSetConcurrency);	1✔
208	}
209
210	@Override
211	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
212	throws SQLException {
213	return original.prepareCall(sql, resultSetType, resultSetConcurrency);	1✔
214	}
215
216	@Override
217	public Map<String, Class<?>> getTypeMap() throws SQLException {
218	return original.getTypeMap();	1✔
219	}
220
221	@Override
222	public void setTypeMap(final Map<String, Class<?>> map) throws SQLException {
223	original.setTypeMap(map);	1✔
224	}	1✔
225
226	@Override
227	public void setHoldability(final int holdability) throws SQLException {
228	original.setHoldability(holdability);	1✔
229	}	1✔
230
231	@Override
232	public int getHoldability() throws SQLException {
233	return original.getHoldability();	1✔
234	}
235
236	@Override
237	public Savepoint setSavepoint() throws SQLException {
238	return original.setSavepoint();	1✔
239	}
240
241	@Override
242	public Savepoint setSavepoint(final String name) throws SQLException {
243	return original.setSavepoint(name);	1✔
244	}
245
246	@Override
247	public void rollback(final Savepoint savepoint) throws SQLException {
248	original.rollback(savepoint);	1✔
249	}	1✔
250
251	@Override
252	public void releaseSavepoint(final Savepoint savepoint) throws SQLException {
253	original.releaseSavepoint(savepoint);	1✔
254	}	1✔
255
256	@Override
257	public Statement createStatement(final int resultSetType, final int resultSetConcurrency,
258	final int resultSetHoldability)
259	throws SQLException {
260	return original.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
261	}
262
263	@Override
264	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
265	final int resultSetHoldability) throws SQLException {
266	return original.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
267	}
268
269	@Override
270	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
271	final int resultSetHoldability) throws SQLException {
272	return original.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
273	}
274
275	@Override
276	public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
277	return original.prepareStatement(sql, autoGeneratedKeys);	1✔
278	}
279
280	@Override
281	public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
282	return original.prepareStatement(sql, columnIndexes);	1✔
283	}
284
285	@Override
286	public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
287	return original.prepareStatement(sql, columnNames);	1✔
288	}
289
290	@Override
291	public Clob createClob() throws SQLException {
292	return original.createClob();	1✔
293	}
294
295	@Override
296	public Blob createBlob() throws SQLException {
297	return original.createBlob();	1✔
298	}
299
300	@Override
301	public NClob createNClob() throws SQLException {
302	return original.createNClob();	1✔
303	}
304
305	@Override
306	public SQLXML createSQLXML() throws SQLException {
307	return original.createSQLXML();	1✔
308	}
309
310	@Override
311	public boolean isValid(final int timeout) throws SQLException {
312	return original.isValid(timeout);	1✔
313	}
314
315	@Override
316	public void setClientInfo(final String name, final String value) throws SQLClientInfoException {
317	original.setClientInfo(name, value);	1✔
318	}	1✔
319
320	@Override
321	public void setClientInfo(final Properties properties) throws SQLClientInfoException {
322	original.setClientInfo(properties);	1✔
323	}	1✔
324
325	@Override
326	public String getClientInfo(final String name) throws SQLException {
327	return original.getClientInfo(name);	1✔
328	}
329
330	@Override
331	public Properties getClientInfo() throws SQLException {
332	return original.getClientInfo();	1✔
333	}
334
335	@Override
336	public Array createArrayOf(final String typeName, final Object[] elements) throws SQLException {
337	return original.createArrayOf(typeName, elements);	1✔
338	}
339
340	@Override
341	public Struct createStruct(final String typeName, final Object[] attributes) throws SQLException {
NEW 342	return original.createStruct(typeName, attributes);	×
343	}
344
345	@Override
346	public void setSchema(final String schema) throws SQLException {
347	original.setSchema(schema);	1✔
348	cachedSchemaName = schema;	1✔
349	}	1✔
350
351	@Override
352	public String getSchema() throws SQLException {
353	if (!cacheSchema) {	1✔
354	return original.getSchema();	1✔
355	} else {
356	if (cachedSchemaName == null) {	1✔
357	cachedSchemaName = original.getSchema();	1✔
358	}
359	return cachedSchemaName;	1✔
360	}
361	}
362
363	@Override
364	public void abort(final Executor executor) throws SQLException {
365	original.abort(executor);	1✔
366	}	1✔
367
368	@Override
369	public void setNetworkTimeout(final Executor executor, final int milliseconds) throws SQLException {
370	original.setNetworkTimeout(executor, milliseconds);	1✔
371	}	1✔
372
373	@Override
374	public int getNetworkTimeout() throws SQLException {
375	return original.getNetworkTimeout();	1✔
376	}
377
378	@Override
379	public String toString() {
NEW 380	return original.toString();	×
381	}
382
383	}

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