mybatis / ibatis-2 / 730

Committed 28 Dec 2025 10:16PM UTC coverage: 65.615% (+0.5%) from 65.146%

Build # 730

Build Type

push

github

Committed by

web-flow

Commit Message

Update README.md

Run Details

1602 of 2802 branches covered (57.17%)

5053 of 7701 relevant lines covered (65.61%)

0.66 hits per line

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

78.26

/src/main/java/com/ibatis/sqlmap/engine/impl/SqlMapSessionImpl.java

/*
 * Copyright 2004-2025 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.ibatis.sqlmap.engine.impl;

import com.ibatis.common.jdbc.exception.NestedSQLException;
import com.ibatis.common.util.PaginatedList;
import com.ibatis.sqlmap.client.SqlMapSession;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.execution.BatchException;
import com.ibatis.sqlmap.engine.execution.SqlExecutor;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.scope.SessionScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionException;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

/**
 * Implementation of SqlMapSession.
 */
public class SqlMapSessionImpl implements SqlMapSession {

  /** The delegate. */
  protected SqlMapExecutorDelegate delegate;

  /** The session scope. */
  protected SessionScope sessionScope;

  /** The closed. */
  protected boolean closed;

  /**
   * Constructor.
   *
   * @param client
   *          - the client that will use the session
   */
  public SqlMapSessionImpl(SqlMapClientImpl client) {
    this.delegate = client.getDelegate();
    this.sessionScope = this.delegate.beginSessionScope();
    this.sessionScope.setSqlMapClient(client);
    this.sessionScope.setSqlMapExecutor(client);
    this.sessionScope.setSqlMapTxMgr(client);
    this.closed = false;
  }

  /**
   * Start the session.
   */
  public void open() {
    sessionScope.setSqlMapTxMgr(this);
  }

  /**
   * Getter to tell if the session is still open.
   *
   * @return - the status of the session
   */
  public boolean isClosed() {
    return closed;
  }

  @Override
  public void close() {
    if (delegate != null && sessionScope != null) {
      delegate.endSessionScope(sessionScope);
    }
    if (sessionScope != null) {
      sessionScope = null;
    }
    if (delegate != null) {
      delegate = null;
    }
    if (!closed) {
      closed = true;
    }
  }

  @Override
  public Object insert(String id, Object param) throws SQLException {
    return delegate.insert(sessionScope, id, param);
  }

  @Override
  public Object insert(String id) throws SQLException {
    return insert(id, null);
  }

  @Override
  public int update(String id, Object param) throws SQLException {
    return delegate.update(sessionScope, id, param);
  }

  @Override
  public int update(String id) throws SQLException {
    return update(id, null);
  }

  @Override
  public int delete(String id, Object param) throws SQLException {
    return delegate.delete(sessionScope, id, param);
  }

  @Override
  public int delete(String id) throws SQLException {
    return delete(id, null);
  }

  @Override
  public Object queryForObject(String id, Object paramObject) throws SQLException {
    return delegate.queryForObject(sessionScope, id, paramObject);
  }

  @Override
  public Object queryForObject(String id) throws SQLException {
    return queryForObject(id, null);
  }

  @Override
  public Object queryForObject(String id, Object paramObject, Object resultObject) throws SQLException {
    return delegate.queryForObject(sessionScope, id, paramObject, resultObject);
  }

  @Override
  public List queryForList(String id, Object paramObject) throws SQLException {
    return delegate.queryForList(sessionScope, id, paramObject);
  }

  @Override
  public List queryForList(String id) throws SQLException {
    return queryForList(id, null);
  }

  @Override
  public List queryForList(String id, Object paramObject, int skip, int max) throws SQLException {
    return delegate.queryForList(sessionScope, id, paramObject, skip, max);
  }

  @Override
  public List queryForList(String id, int skip, int max) throws SQLException {
    return queryForList(id, null, skip, max);
  }

  /**
   * @deprecated All paginated list features have been deprecated
   */
  @Override
  @Deprecated
  public PaginatedList queryForPaginatedList(String id, Object paramObject, int pageSize) throws SQLException {
    return delegate.queryForPaginatedList(sessionScope, id, paramObject, pageSize);
  }

  /**
   * @deprecated All paginated list features have been deprecated
   */
  @Override
  @Deprecated
  public PaginatedList queryForPaginatedList(String id, int pageSize) throws SQLException {
    return queryForPaginatedList(id, null, pageSize);
  }

  @Override
  public Map queryForMap(String id, Object paramObject, String keyProp) throws SQLException {
    return delegate.queryForMap(sessionScope, id, paramObject, keyProp);
  }

  @Override
  public Map queryForMap(String id, Object paramObject, String keyProp, String valueProp) throws SQLException {
    return delegate.queryForMap(sessionScope, id, paramObject, keyProp, valueProp);
  }

  @Override
  public void queryWithRowHandler(String id, Object paramObject, RowHandler rowHandler) throws SQLException {
    delegate.queryWithRowHandler(sessionScope, id, paramObject, rowHandler);
  }

  @Override
  public void queryWithRowHandler(String id, RowHandler rowHandler) throws SQLException {
    queryWithRowHandler(id, null, rowHandler);
  }

  @Override
  public void startTransaction() throws SQLException {
    delegate.startTransaction(sessionScope);
  }

  @Override
  public void startTransaction(int transactionIsolation) throws SQLException {
    delegate.startTransaction(sessionScope, transactionIsolation);
  }

  @Override
  public void commitTransaction() throws SQLException {
    delegate.commitTransaction(sessionScope);
  }

  @Override
  public void endTransaction() throws SQLException {
    delegate.endTransaction(sessionScope);
  }

  @Override
  public void startBatch() throws SQLException {
    delegate.startBatch(sessionScope);
  }

  @Override
  public int executeBatch() throws SQLException {
    return delegate.executeBatch(sessionScope);
  }

  @Override
  public List executeBatchDetailed() throws SQLException, BatchException {
    return delegate.executeBatchDetailed(sessionScope);
  }

  @Override
  public void setUserConnection(Connection connection) throws SQLException {
    delegate.setUserProvidedTransaction(sessionScope, connection);
  }

  /**
   * Get User connection.
   *
   * @return Current connection
   *
   * @throws SQLException
   *           the SQL exception
   *
   * @deprecated Use {@link #getCurrentConnection()} instead.
   */
  @Override
  @Deprecated
  public Connection getUserConnection() throws SQLException {
    return getCurrentConnection();
  }

  @Override
  public Connection getCurrentConnection() throws SQLException {
    try {
      Connection conn = null;
      Transaction trans = delegate.getTransaction(sessionScope);
      if (trans != null) {
        conn = trans.getConnection();
      }
      return conn;
    } catch (TransactionException e) {
      throw new NestedSQLException("Error getting Connection from Transaction.  Cause: " + e, e);
    }
  }

  @Override
  public DataSource getDataSource() {
    return delegate.getDataSource();
  }

  /**
   * Gets a mapped statement by ID.
   *
   * @param id
   *          - the ID
   *
   * @return - the mapped statement
   */
  public MappedStatement getMappedStatement(String id) {
    return delegate.getMappedStatement(id);
  }

  /**
   * Get the status of lazy loading.
   *
   * @return - the status
   */
  public boolean isLazyLoadingEnabled() {
    return delegate.isLazyLoadingEnabled();
  }

  /**
   * Get the status of CGLib enhancements.
   *
   * @return - the status
   */
  public boolean isEnhancementEnabled() {
    return delegate.isEnhancementEnabled();
  }

  /**
   * Get the SQL executor.
   *
   * @return - the executor
   */
  public SqlExecutor getSqlExecutor() {
    return delegate.getSqlExecutor();
  }

  /**
   * Get the delegate.
   *
   * @return - the delegate
   */
  public SqlMapExecutorDelegate getDelegate() {
    return delegate;
  }

}

1	/*
2	* Copyright 2004-2025 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package com.ibatis.sqlmap.engine.impl;
17
18	import com.ibatis.common.jdbc.exception.NestedSQLException;
19	import com.ibatis.common.util.PaginatedList;
20	import com.ibatis.sqlmap.client.SqlMapSession;
21	import com.ibatis.sqlmap.client.event.RowHandler;
22	import com.ibatis.sqlmap.engine.execution.BatchException;
23	import com.ibatis.sqlmap.engine.execution.SqlExecutor;
24	import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
25	import com.ibatis.sqlmap.engine.scope.SessionScope;
26	import com.ibatis.sqlmap.engine.transaction.Transaction;
27	import com.ibatis.sqlmap.engine.transaction.TransactionException;
28
29	import java.sql.Connection;
30	import java.sql.SQLException;
31	import java.util.List;
32	import java.util.Map;
33
34	import javax.sql.DataSource;
35
36	/**
37	* Implementation of SqlMapSession.
38	*/
39	public class SqlMapSessionImpl implements SqlMapSession {
40
41	/** The delegate. */
42	protected SqlMapExecutorDelegate delegate;
43
44	/** The session scope. */
45	protected SessionScope sessionScope;
46
47	/** The closed. */
48	protected boolean closed;
49
50	/**
51	* Constructor.
52	*
53	* @param client
54	* - the client that will use the session
55	*/
56	public SqlMapSessionImpl(SqlMapClientImpl client) {	1✔
57	this.delegate = client.getDelegate();	1✔
58	this.sessionScope = this.delegate.beginSessionScope();	1✔
59	this.sessionScope.setSqlMapClient(client);	1✔
60	this.sessionScope.setSqlMapExecutor(client);	1✔
61	this.sessionScope.setSqlMapTxMgr(client);	1✔
62	this.closed = false;	1✔
63	}	1✔
64
65	/**
66	* Start the session.
67	*/
68	public void open() {
69	sessionScope.setSqlMapTxMgr(this);	1✔
70	}	1✔
71
72	/**
73	* Getter to tell if the session is still open.
74	*
75	* @return - the status of the session
76	*/
77	public boolean isClosed() {
78	return closed;	1✔
79	}
80
81	@Override
82	public void close() {
83	if (delegate != null && sessionScope != null) {	1!
84	delegate.endSessionScope(sessionScope);	1✔
85	}
86	if (sessionScope != null) {	1!
87	sessionScope = null;	1✔
88	}
89	if (delegate != null) {	1!
90	delegate = null;	1✔
91	}
92	if (!closed) {	1!
93	closed = true;	1✔
94	}
95	}	1✔
96
97	@Override
98	public Object insert(String id, Object param) throws SQLException {
99	return delegate.insert(sessionScope, id, param);	1✔
100	}
101
102	@Override
103	public Object insert(String id) throws SQLException {
104	return insert(id, null);	×
105	}
106
107	@Override
108	public int update(String id, Object param) throws SQLException {
109	return delegate.update(sessionScope, id, param);	1✔
110	}
111
112	@Override
113	public int update(String id) throws SQLException {
114	return update(id, null);	1✔
115	}
116
117	@Override
118	public int delete(String id, Object param) throws SQLException {
119	return delegate.delete(sessionScope, id, param);	×
120	}
121
122	@Override
123	public int delete(String id) throws SQLException {
124	return delete(id, null);	×
125	}
126
127	@Override
128	public Object queryForObject(String id, Object paramObject) throws SQLException {
129	return delegate.queryForObject(sessionScope, id, paramObject);	1✔
130	}
131
132	@Override
133	public Object queryForObject(String id) throws SQLException {
134	return queryForObject(id, null);	1✔
135	}
136
137	@Override
138	public Object queryForObject(String id, Object paramObject, Object resultObject) throws SQLException {
139	return delegate.queryForObject(sessionScope, id, paramObject, resultObject);	1✔
140	}
141
142	@Override
143	public List queryForList(String id, Object paramObject) throws SQLException {
144	return delegate.queryForList(sessionScope, id, paramObject);	1✔
145	}
146
147	@Override
148	public List queryForList(String id) throws SQLException {
149	return queryForList(id, null);	1✔
150	}
151
152	@Override
153	public List queryForList(String id, Object paramObject, int skip, int max) throws SQLException {
154	return delegate.queryForList(sessionScope, id, paramObject, skip, max);	1✔
155	}
156
157	@Override
158	public List queryForList(String id, int skip, int max) throws SQLException {
159	return queryForList(id, null, skip, max);	×
160	}
161
162	/**
163	* @deprecated All paginated list features have been deprecated
164	*/
165	@Override
166	@Deprecated
167	public PaginatedList queryForPaginatedList(String id, Object paramObject, int pageSize) throws SQLException {
168	return delegate.queryForPaginatedList(sessionScope, id, paramObject, pageSize);	1✔
169	}
170
171	/**
172	* @deprecated All paginated list features have been deprecated
173	*/
174	@Override
175	@Deprecated
176	public PaginatedList queryForPaginatedList(String id, int pageSize) throws SQLException {
177	return queryForPaginatedList(id, null, pageSize);	1✔
178	}
179
180	@Override
181	public Map queryForMap(String id, Object paramObject, String keyProp) throws SQLException {
182	return delegate.queryForMap(sessionScope, id, paramObject, keyProp);	1✔
183	}
184
185	@Override
186	public Map queryForMap(String id, Object paramObject, String keyProp, String valueProp) throws SQLException {
187	return delegate.queryForMap(sessionScope, id, paramObject, keyProp, valueProp);	1✔
188	}
189
190	@Override
191	public void queryWithRowHandler(String id, Object paramObject, RowHandler rowHandler) throws SQLException {
192	delegate.queryWithRowHandler(sessionScope, id, paramObject, rowHandler);	1✔
193	}	1✔
194
195	@Override
196	public void queryWithRowHandler(String id, RowHandler rowHandler) throws SQLException {
197	queryWithRowHandler(id, null, rowHandler);	1✔
198	}	1✔
199
200	@Override
201	public void startTransaction() throws SQLException {
202	delegate.startTransaction(sessionScope);	1✔
203	}	1✔
204
205	@Override
206	public void startTransaction(int transactionIsolation) throws SQLException {
207	delegate.startTransaction(sessionScope, transactionIsolation);	×
208	}	×
209
210	@Override
211	public void commitTransaction() throws SQLException {
212	delegate.commitTransaction(sessionScope);	1✔
213	}	1✔
214
215	@Override
216	public void endTransaction() throws SQLException {
217	delegate.endTransaction(sessionScope);	1✔
218	}	1✔
219
220	@Override
221	public void startBatch() throws SQLException {
222	delegate.startBatch(sessionScope);	1✔
223	}	1✔
224
225	@Override
226	public int executeBatch() throws SQLException {
227	return delegate.executeBatch(sessionScope);	1✔
228	}
229
230	@Override
231	public List executeBatchDetailed() throws SQLException, BatchException {
232	return delegate.executeBatchDetailed(sessionScope);	1✔
233	}
234
235	@Override
236	public void setUserConnection(Connection connection) throws SQLException {
237	delegate.setUserProvidedTransaction(sessionScope, connection);	1✔
238	}	1✔
239
240	/**
241	* Get User connection.
242	*
243	* @return Current connection
244	*
245	* @throws SQLException
246	* the SQL exception
247	*
248	* @deprecated Use {@link #getCurrentConnection()} instead.
249	*/
250	@Override
251	@Deprecated
252	public Connection getUserConnection() throws SQLException {
253	return getCurrentConnection();	×
254	}
255
256	@Override
257	public Connection getCurrentConnection() throws SQLException {
258	try {
259	Connection conn = null;	1✔
260	Transaction trans = delegate.getTransaction(sessionScope);	1✔
261	if (trans != null) {	1!
262	conn = trans.getConnection();	1✔
263	}
264	return conn;	1✔
265	} catch (TransactionException e) {	×
266	throw new NestedSQLException("Error getting Connection from Transaction. Cause: " + e, e);	×
267	}
268	}
269
270	@Override
271	public DataSource getDataSource() {
272	return delegate.getDataSource();	×
273	}
274
275	/**
276	* Gets a mapped statement by ID.
277	*
278	* @param id
279	* - the ID
280	*
281	* @return - the mapped statement
282	*/
283	public MappedStatement getMappedStatement(String id) {
284	return delegate.getMappedStatement(id);	×
285	}
286
287	/**
288	* Get the status of lazy loading.
289	*
290	* @return - the status
291	*/
292	public boolean isLazyLoadingEnabled() {
293	return delegate.isLazyLoadingEnabled();	×
294	}
295
296	/**
297	* Get the status of CGLib enhancements.
298	*
299	* @return - the status
300	*/
301	public boolean isEnhancementEnabled() {
302	return delegate.isEnhancementEnabled();	×
303	}
304
305	/**
306	* Get the SQL executor.
307	*
308	* @return - the executor
309	*/
310	public SqlExecutor getSqlExecutor() {
311	return delegate.getSqlExecutor();	×
312	}
313
314	/**
315	* Get the delegate.
316	*
317	* @return - the delegate
318	*/
319	public SqlMapExecutorDelegate getDelegate() {
320	return delegate;	×
321	}
322
323	}

mybatis / ibatis-2 / 730

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