#867

Committed 03 Aug 2025 06:18PM UTC coverage: 88.253% (-1.6%) from 89.835%

Build # #867

Build Type

Committed by

Commit Message

#360 for master

Pull Request Pull Request #362: cache DatabaseMetaData fixed value and Connection getSchema value. for master

Run Details

136 of 325 new or added lines in 8 files covered. (41.85%)

2 existing lines in 1 file now uncovered.

8835 of 10011 relevant lines covered (88.25%)

0.88 hits per line

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

91.25

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

future-architect / uroborosql / #867

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