#891

Committed 17 Aug 2025 04:56PM UTC coverage: 87.808% (-0.5%) from 88.265%

Build # #891

Build Type

Committed by

Commit Message

Add ConnectionSupplier Fix schema name option for master.

Pull Request Pull Request #365: Add ConnectionSupplier Fix schema name option for master.

Run Details

75 of 144 new or added lines in 5 files covered. (52.08%)

1 existing line in 1 file now uncovered.

8909 of 10146 relevant lines covered (87.81%)

0.88 hits per line

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

29.41

/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 {
NEW 59	if (!isWrapperFor(iface)) {	×
NEW 60	throw new SQLException("Cannot unwrap to " + iface.getName());	×
61	}
NEW 62	if (iface.isInstance(this)) {	×
NEW 63	return (T) this;	×
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 {
NEW 78	return original.createStatement();	×
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 {
NEW 88	return original.prepareCall(sql);	×
89	}
90
91	@Override
92	public String nativeSQL(final String sql) throws SQLException {
NEW 93	return original.nativeSQL(sql);	×
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 {
NEW 113	original.rollback();	×
NEW 114	}	×
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 {
NEW 139	original.setReadOnly(readOnly);	×
NEW 140	}	×
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 {
NEW 149	original.setCatalog(catalog);	×
NEW 150	}	×
151
152	@Override
153	public String getCatalog() throws SQLException {
NEW 154	return original.getCatalog();	×
155	}
156
157	@Override
158	public void setTransactionIsolation(final int level) throws SQLException {
NEW 159	original.setTransactionIsolation(level);	×
NEW 160	}	×
161
162	@Override
163	public int getTransactionIsolation() throws SQLException {
164	return original.getTransactionIsolation();	1✔
165	}
166
167	@Override
168	public SQLWarning getWarnings() throws SQLException {
NEW 169	return original.getWarnings();	×
170	}
171
172	@Override
173	public void clearWarnings() throws SQLException {
NEW 174	original.clearWarnings();	×
NEW 175	}	×
176
177	@Override
178	public Statement createStatement(final int resultSetType, final int resultSetConcurrency) throws SQLException {
NEW 179	return original.createStatement(resultSetType, resultSetConcurrency);	×
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 {
NEW 191	return original.prepareCall(sql, resultSetType, resultSetConcurrency);	×
192	}
193
194	@Override
195	public Map<String, Class<?>> getTypeMap() throws SQLException {
NEW 196	return original.getTypeMap();	×
197	}
198
199	@Override
200	public void setTypeMap(final Map<String, Class<?>> map) throws SQLException {
NEW 201	original.setTypeMap(map);	×
NEW 202	}	×
203
204	@Override
205	public void setHoldability(final int holdability) throws SQLException {
NEW 206	original.setHoldability(holdability);	×
NEW 207	}	×
208
209	@Override
210	public int getHoldability() throws SQLException {
NEW 211	return original.getHoldability();	×
212	}
213
214	@Override
215	public Savepoint setSavepoint() throws SQLException {
NEW 216	return original.setSavepoint();	×
217	}
218
219	@Override
220	public Savepoint setSavepoint(final String name) throws SQLException {
NEW 221	return original.setSavepoint(name);	×
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 {
NEW 231	original.releaseSavepoint(savepoint);	×
NEW 232	}	×
233
234	@Override
235	public Statement createStatement(final int resultSetType, final int resultSetConcurrency,
236	final int resultSetHoldability)
237	throws SQLException {
NEW 238	return original.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);	×
239	}
240
241	@Override
242	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
243	final int resultSetHoldability) throws SQLException {
NEW 244	return original.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);	×
245	}
246
247	@Override
248	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
249	final int resultSetHoldability) throws SQLException {
NEW 250	return original.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);	×
251	}
252
253	@Override
254	public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
NEW 255	return original.prepareStatement(sql, autoGeneratedKeys);	×
256	}
257
258	@Override
259	public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
NEW 260	return original.prepareStatement(sql, columnIndexes);	×
261	}
262
263	@Override
264	public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
NEW 265	return original.prepareStatement(sql, columnNames);	×
266	}
267
268	@Override
269	public Clob createClob() throws SQLException {
NEW 270	return original.createClob();	×
271	}
272
273	@Override
274	public Blob createBlob() throws SQLException {
NEW 275	return original.createBlob();	×
276	}
277
278	@Override
279	public NClob createNClob() throws SQLException {
NEW 280	return original.createNClob();	×
281	}
282
283	@Override
284	public SQLXML createSQLXML() throws SQLException {
NEW 285	return original.createSQLXML();	×
286	}
287
288	@Override
289	public boolean isValid(final int timeout) throws SQLException {
NEW 290	return original.isValid(timeout);	×
291	}
292
293	@Override
294	public void setClientInfo(final String name, final String value) throws SQLClientInfoException {
NEW 295	original.setClientInfo(name, value);	×
NEW 296	}	×
297
298	@Override
299	public void setClientInfo(final Properties properties) throws SQLClientInfoException {
NEW 300	original.setClientInfo(properties);	×
NEW 301	}	×
302
303	@Override
304	public String getClientInfo(final String name) throws SQLException {
NEW 305	return original.getClientInfo(name);	×
306	}
307
308	@Override
309	public Properties getClientInfo() throws SQLException {
NEW 310	return original.getClientInfo();	×
311	}
312
313	@Override
314	public Array createArrayOf(final String typeName, final Object[] elements) throws SQLException {
NEW 315	return original.createArrayOf(typeName, elements);	×
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 {
NEW 325	throw new UnsupportedOperationException("Schema is fixed.");	×
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 {
NEW 335	original.abort(executor);	×
NEW 336	}	×
337
338	@Override
339	public void setNetworkTimeout(final Executor executor, final int milliseconds) throws SQLException {
NEW 340	original.setNetworkTimeout(executor, milliseconds);	×
NEW 341	}	×
342
343	@Override
344	public int getNetworkTimeout() throws SQLException {
NEW 345	return original.getNetworkTimeout();	×
346	}
347
348	@Override
349	public String toString() {
NEW 350	return original.toString();	×
351	}
352	}

future-architect / uroborosql / #891

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