#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

87.5

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

/**
 * Closeを無視するConnectionを提供するためのWrapper
 * {@link DoNotCloseConnectionWrapper} の代わりにこちらを使用してください
 *
 * @author H.Sugimoto
 */
public class CloseIgnoringConnectionWrapper implements Connection {
        private final Connection original;

        /**
         * コンストラクタ
         *
         * @param original 元となるコネクション
         */
        public CloseIgnoringConnectionWrapper(final Connection original) {
                this.original = original;
        }

        @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 {
                // do nothing
        }

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

        @Override
        public DatabaseMetaData getMetaData() throws SQLException {
                return original.getMetaData();
        }

        @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);
        }

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

        @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();
        }

        @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 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	* Closeを無視するConnectionを提供するためのWrapper
30	* {@link DoNotCloseConnectionWrapper} の代わりにこちらを使用してください
31	*
32	* @author H.Sugimoto
33	*/
34	public class CloseIgnoringConnectionWrapper implements Connection {
35	private final Connection original;
36
37	/**
38	* コンストラクタ
39	*
40	* @param original 元となるコネクション
41	*/
42	public CloseIgnoringConnectionWrapper(final Connection original) {	1✔
43	this.original = original;	1✔
44	}	1✔
45
46	@Override
47	public Statement createStatement() throws SQLException {
48	return original.createStatement();	1✔
49	}
50
51	@Override
52	public PreparedStatement prepareStatement(final String sql) throws SQLException {
53	return original.prepareStatement(sql);	1✔
54	}
55
56	@Override
57	public CallableStatement prepareCall(final String sql) throws SQLException {
58	return original.prepareCall(sql);	1✔
59	}
60
61	@Override
62	public String nativeSQL(final String sql) throws SQLException {
63	return original.nativeSQL(sql);	1✔
64	}
65
66	@Override
67	public void setAutoCommit(final boolean autoCommit) throws SQLException {
68	original.setAutoCommit(autoCommit);	1✔
69	}	1✔
70
71	@Override
72	public boolean getAutoCommit() throws SQLException {
73	return original.getAutoCommit();	1✔
74	}
75
76	@Override
77	public void commit() throws SQLException {
78	original.commit();	1✔
79	}	1✔
80
81	@Override
82	public void rollback() throws SQLException {
83	original.rollback();	1✔
84	}	1✔
85
86	@Override
87	public void close() throws SQLException {
88	// do nothing
89	}	1✔
90
91	@Override
92	public boolean isClosed() throws SQLException {
93	return original.isClosed();	1✔
94	}
95
96	@Override
97	public DatabaseMetaData getMetaData() throws SQLException {
98	return original.getMetaData();	1✔
99	}
100
101	@Override
102	public void setReadOnly(final boolean readOnly) throws SQLException {
103	original.setReadOnly(readOnly);	1✔
104	}	1✔
105
106	@Override
107	public boolean isReadOnly() throws SQLException {
108	return original.isReadOnly();	1✔
109	}
110
111	@Override
112	public void setCatalog(final String catalog) throws SQLException {
113	original.setCatalog(catalog);	1✔
114	}	1✔
115
116	@Override
117	public String getCatalog() throws SQLException {
118	return original.getCatalog();	1✔
119	}
120
121	@Override
122	public void setTransactionIsolation(final int level) throws SQLException {
123	original.setTransactionIsolation(level);	1✔
124	}	1✔
125
126	@Override
127	public int getTransactionIsolation() throws SQLException {
128	return original.getTransactionIsolation();	1✔
129	}
130
131	@Override
132	public SQLWarning getWarnings() throws SQLException {
133	return original.getWarnings();	1✔
134	}
135
136	@Override
137	public void clearWarnings() throws SQLException {
138	original.clearWarnings();	1✔
139	}	1✔
140
141	@Override
142	public Statement createStatement(final int resultSetType, final int resultSetConcurrency) throws SQLException {
143	return original.createStatement(resultSetType, resultSetConcurrency);	1✔
144	}
145
146	@Override
147	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
148	throws SQLException {
149	return original.prepareStatement(sql, resultSetType, resultSetConcurrency);	1✔
150	}
151
152	@Override
153	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
154	throws SQLException {
155	return original.prepareCall(sql, resultSetType, resultSetConcurrency);	1✔
156	}
157
158	@Override
159	public Map<String, Class<?>> getTypeMap() throws SQLException {
160	return original.getTypeMap();	1✔
161	}
162
163	@Override
164	public void setTypeMap(final Map<String, Class<?>> map) throws SQLException {
165	original.setTypeMap(map);	1✔
166	}	1✔
167
168	@Override
169	public void setHoldability(final int holdability) throws SQLException {
170	original.setHoldability(holdability);	1✔
171	}	1✔
172
173	@Override
174	public int getHoldability() throws SQLException {
175	return original.getHoldability();	1✔
176	}
177
178	@Override
179	public Savepoint setSavepoint() throws SQLException {
180	return original.setSavepoint();	1✔
181	}
182
183	@Override
184	public Savepoint setSavepoint(final String name) throws SQLException {
185	return original.setSavepoint(name);	1✔
186	}
187
188	@Override
189	public void rollback(final Savepoint savepoint) throws SQLException {
190	original.rollback(savepoint);	×
191	}	×
192
193	@Override
194	public void releaseSavepoint(final Savepoint savepoint) throws SQLException {
195	original.releaseSavepoint(savepoint);	1✔
196	}	1✔
197
198	@Override
199	public Statement createStatement(final int resultSetType, final int resultSetConcurrency,
200	final int resultSetHoldability)
201	throws SQLException {
202	return original.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
203	}
204
205	@Override
206	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
207	final int resultSetHoldability) throws SQLException {
208	return original.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
209	}
210
211	@Override
212	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
213	final int resultSetHoldability) throws SQLException {
214	return original.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);	1✔
215	}
216
217	@Override
218	public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
219	return original.prepareStatement(sql, autoGeneratedKeys);	1✔
220	}
221
222	@Override
223	public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
224	return original.prepareStatement(sql, columnIndexes);	1✔
225	}
226
227	@Override
228	public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
229	return original.prepareStatement(sql, columnNames);	1✔
230	}
231
232	@Override
233	public Clob createClob() throws SQLException {
234	return original.createClob();	1✔
235	}
236
237	@Override
238	public Blob createBlob() throws SQLException {
239	return original.createBlob();	1✔
240	}
241
242	@Override
243	public NClob createNClob() throws SQLException {
244	return original.createNClob();	1✔
245	}
246
247	@Override
248	public SQLXML createSQLXML() throws SQLException {
249	return original.createSQLXML();	1✔
250	}
251
252	@Override
253	public boolean isValid(final int timeout) throws SQLException {
254	return original.isValid(timeout);	1✔
255	}
256
257	@Override
258	public void setClientInfo(final String name, final String value) throws SQLClientInfoException {
259	original.setClientInfo(name, value);	1✔
260	}	1✔
261
262	@Override
263	public void setClientInfo(final Properties properties) throws SQLClientInfoException {
264	original.setClientInfo(properties);	1✔
265	}	1✔
266
267	@Override
268	public String getClientInfo(final String name) throws SQLException {
269	return original.getClientInfo(name);	1✔
270	}
271
272	@Override
273	public Properties getClientInfo() throws SQLException {
274	return original.getClientInfo();	1✔
275	}
276
277	@Override
278	public Array createArrayOf(final String typeName, final Object[] elements) throws SQLException {
279	return original.createArrayOf(typeName, elements);	1✔
280	}
281
282	@Override
283	public Struct createStruct(final String typeName, final Object[] attributes) throws SQLException {
284	return original.createStruct(typeName, attributes);	×
285	}
286
287	@Override
288	public void setSchema(final String schema) throws SQLException {
289	original.setSchema(schema);	1✔
290	}	1✔
291
292	@Override
293	public String getSchema() throws SQLException {
294	return original.getSchema();	1✔
295	}
296
297	@Override
298	public void abort(final Executor executor) throws SQLException {
299	original.abort(executor);	1✔
300	}	1✔
301
302	@Override
303	public void setNetworkTimeout(final Executor executor, final int milliseconds) throws SQLException {
304	original.setNetworkTimeout(executor, milliseconds);	1✔
305	}	1✔
306
307	@Override
308	public int getNetworkTimeout() throws SQLException {
309	return original.getNetworkTimeout();	1✔
310	}
311
312	@SuppressWarnings("unchecked")
313	@Override
314	public <T> T unwrap(final Class<T> iface) throws SQLException {
NEW 315	if (!isWrapperFor(iface)) {	×
NEW 316	throw new SQLException("Cannot unwrap to " + iface.getName());	×
317	}
NEW 318	if (iface.isInstance(this)) {	×
NEW 319	return (T) this;	×
320	}
UNCOV 321	return original.unwrap(iface);	×
322	}
323
324	@Override
325	public boolean isWrapperFor(final Class<?> iface) throws SQLException {
326	if (iface.isInstance(this)) {	1✔
327	return true;	1✔
328	}
UNCOV 329	return original.isWrapperFor(iface);	×
330	}
331
332	@Override
333	public String toString() {
NEW 334	return original.toString();	×
335	}
336	}

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