#890

Committed 17 Aug 2025 03:45PM UTC coverage: 88.613% (+0.1%) from 88.472%

Build # #890

Build Type

Committed by

Commit Message

fix javadoc comment

Pull Request Pull Request #364: Add ConnectionSupplier Fix schema name option.

Run Details

128 of 140 new or added lines in 5 files covered. (91.43%)

6 existing lines in 3 files now uncovered.

8202 of 9256 relevant lines covered (88.61%)

0.89 hits per line

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

92.94

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

/**
 * スキーマ名を固定したConnectionを提供するためのWrapper
 *
 * @author H.Sugimoto
 * @since v0.26.11
 */
public class SchemaFixedConnectionWrapper implements Connection {

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

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

        /** Fixed Schema Name. */
        private final String fixedSchemaName;

        /**
         * コンストラクタ
         *
         * @param original 元となるコネクション
         * @param fixedSchemaName 固定するスキーマ名
         */
        SchemaFixedConnectionWrapper(final Connection original, final String fixedSchemaName) {
                this.original = original;
                this.fixedSchemaName = fixedSchemaName;
        }

        @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 {
                // コネクションのクローズタイミングでメタデータのキャッシュをクリアすることで、
                // コネクションプールから再取得された場合に前回キャッシュした内容が残ることを防ぐ
                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 {
                throw new UnsupportedOperationException("Schema is fixed.");
        }

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

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

future-architect / uroborosql / #890

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