mybatis / ibatis-2 / 736

Committed 29 Dec 2025 12:23AM UTC coverage: 65.571% (-0.03%) from 65.597%

Build # 736

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #339 from hazendaz/master

Key set cleanup to use size directly increasing speed for same result

Run Details

1598 of 2797 branches covered (57.13%)

4 of 4 new or added lines in 1 file covered. (100.0%)

149 existing lines in 7 files now uncovered.

5047 of 7697 relevant lines covered (65.57%)

0.66 hits per line

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

66.34

/src/main/java/com/ibatis/sqlmap/engine/mapping/statement/PaginatedDataList.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.mapping.statement;

import com.ibatis.common.util.PaginatedList;
import com.ibatis.sqlmap.client.SqlMapExecutor;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * The Class PaginatedDataList.
 *
 * @deprecated All paginated list features have been deprecated
 */
@Deprecated
public class PaginatedDataList implements PaginatedList {

  /** The sql map executor. */
  private SqlMapExecutor sqlMapExecutor;

  /** The statement name. */
  private String statementName;

  /** The parameter object. */
  private Object parameterObject;

  /** The page size. */
  private int pageSize;

  /** The index. */
  private int index;

  /** The prev page list. */
  private List prevPageList;

  /** The current page list. */
  private List currentPageList;

  /** The next page list. */
  private List nextPageList;

  /**
   * Instantiates a new paginated data list.
   *
   * @param sqlMapExecutor
   *          the sql map executor
   * @param statementName
   *          the statement name
   * @param parameterObject
   *          the parameter object
   * @param pageSize
   *          the page size
   *
   * @throws SQLException
   *           the SQL exception
   */
  public PaginatedDataList(SqlMapExecutor sqlMapExecutor, String statementName, Object parameterObject, int pageSize)
      throws SQLException {
    this.sqlMapExecutor = sqlMapExecutor;
    this.statementName = statementName;
    this.parameterObject = parameterObject;
    this.pageSize = pageSize;
    this.index = 0;
    pageTo(0);
  }

  /**
   * Page forward.
   */
  private void pageForward() {
    try {
      prevPageList = currentPageList;
      currentPageList = nextPageList;
      nextPageList = getList(index + 1, pageSize);
    } catch (SQLException e) {
      throw new RuntimeException("Unexpected error while repaginating paged list.  Cause: " + e, e);
    }
  }

  /**
   * Page back.
   */
  private void pageBack() {
    try {
      nextPageList = currentPageList;
      currentPageList = prevPageList;
      if (index > 0) {
        prevPageList = getList(index - 1, pageSize);
      } else {
        prevPageList = new ArrayList<>();
      }
    } catch (SQLException e) {
      throw new RuntimeException("Unexpected error while repaginating paged list.  Cause: " + e, e);
    }
  }

  /**
   * Safe page to.
   *
   * @param idx
   *          the idx
   */
  private void safePageTo(int idx) {
    try {
      pageTo(idx);
    } catch (SQLException e) {
      throw new RuntimeException("Unexpected error while repaginating paged list.  Cause: " + e, e);
    }
  }

  /**
   * Page to.
   *
   * @param idx
   *          the idx
   *
   * @throws SQLException
   *           the SQL exception
   */
  public void pageTo(int idx) throws SQLException {
    index = idx;

    List list;

    if (idx < 1) {
      list = getList(idx, pageSize * 2);
    } else {
      list = getList(idx - 1, pageSize * 3);
    }

    if (list.size() < 1) {
      prevPageList = new ArrayList<>(0);
      currentPageList = new ArrayList<>(0);
      nextPageList = new ArrayList<>(0);
    } else if (idx < 1) {
      prevPageList = new ArrayList<>(0);
      if (list.size() <= pageSize) {
        currentPageList = list.subList(0, list.size());
        nextPageList = new ArrayList<>(0);
      } else {
        currentPageList = list.subList(0, pageSize);
        nextPageList = list.subList(pageSize, list.size());
      }
    } else {
      if (list.size() <= pageSize) {
        prevPageList = list.subList(0, list.size());
        currentPageList = new ArrayList<>(0);
        nextPageList = new ArrayList<>(0);
      } else if (list.size() <= pageSize * 2) {
        prevPageList = list.subList(0, pageSize);
        currentPageList = list.subList(pageSize, list.size());
        nextPageList = new ArrayList<>(0);
      } else {
        prevPageList = list.subList(0, pageSize);
        currentPageList = list.subList(pageSize, pageSize * 2);
        nextPageList = list.subList(pageSize * 2, list.size());
      }
    }

  }

  /**
   * Gets the list.
   *
   * @param idx
   *          the idx
   * @param localPageSize
   *          the local page size
   *
   * @return the list
   *
   * @throws SQLException
   *           the SQL exception
   */
  private List getList(int idx, int localPageSize) throws SQLException {
    return sqlMapExecutor.queryForList(statementName, parameterObject, idx * pageSize, localPageSize);
  }

  @Override
  public boolean nextPage() {
    if (isNextPageAvailable()) {
      index++;
      pageForward();
      return true;
    }
    return false;
  }

  @Override
  public boolean previousPage() {
    if (isPreviousPageAvailable()) {
      index--;
      pageBack();
      return true;
    }
    return false;
  }

  @Override
  public void gotoPage(int pageNumber) {
    safePageTo(pageNumber);
  }

  @Override
  public int getPageSize() {
    return pageSize;
  }

  @Override
  public boolean isFirstPage() {
    return index == 0;
  }

  @Override
  public boolean isMiddlePage() {
    return !isFirstPage() && !isLastPage();
  }

  @Override
  public boolean isLastPage() {
    return nextPageList.size() < 1;
  }

  @Override
  public boolean isNextPageAvailable() {
    return nextPageList.size() > 0;
  }

  @Override
  public boolean isPreviousPageAvailable() {
    return prevPageList.size() > 0;
  }

  @Override
  public int size() {
    return currentPageList.size();
  }

  @Override
  public boolean isEmpty() {
    return currentPageList.isEmpty();
  }

  @Override
  public boolean contains(Object o) {
    return currentPageList.contains(o);
  }

  @Override
  public Iterator iterator() {
    return currentPageList.iterator();
  }

  @Override
  public Object[] toArray() {
    return currentPageList.toArray();
  }

  @Override
  public Object[] toArray(Object a[]) {
    return currentPageList.toArray(a);
  }

  @Override
  public boolean containsAll(Collection c) {
    return currentPageList.containsAll(c);
  }

  @Override
  public Object get(int index) {
    return currentPageList.get(index);
  }

  @Override
  public int indexOf(Object o) {
    return currentPageList.indexOf(o);
  }

  @Override
  public int lastIndexOf(Object o) {
    return currentPageList.lastIndexOf(o);
  }

  @Override
  public ListIterator listIterator() {
    return currentPageList.listIterator();
  }

  @Override
  public ListIterator listIterator(int index) {
    return currentPageList.listIterator(index);
  }

  @Override
  public List subList(int fromIndex, int toIndex) {
    return currentPageList.subList(fromIndex, toIndex);
  }

  @Override
  public boolean add(Object o) {
    return currentPageList.add(o);
  }

  @Override
  public boolean remove(Object o) {
    return currentPageList.remove(o);
  }

  @Override
  public boolean addAll(Collection c) {
    return currentPageList.addAll(c);
  }

  @Override
  public boolean addAll(int index, Collection c) {
    return currentPageList.addAll(index, c);
  }

  @Override
  public boolean removeAll(Collection c) {
    return currentPageList.removeAll(c);
  }

  @Override
  public boolean retainAll(Collection c) {
    return currentPageList.retainAll(c);
  }

  @Override
  public void clear() {
    currentPageList.clear();
  }

  @Override
  public Object set(int index, Object element) {
    return currentPageList.set(index, element);
  }

  @Override
  public void add(int index, Object element) {
    currentPageList.add(index, element);
  }

  @Override
  public Object remove(int index) {
    return currentPageList.remove(index);
  }

  @Override
  public int getPageIndex() {
    return index;
  }

}

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.mapping.statement;
17
18	import com.ibatis.common.util.PaginatedList;
19	import com.ibatis.sqlmap.client.SqlMapExecutor;
20
21	import java.sql.SQLException;
22	import java.util.ArrayList;
23	import java.util.Collection;
24	import java.util.Iterator;
25	import java.util.List;
26	import java.util.ListIterator;
27
28	/**
29	* The Class PaginatedDataList.
30	*
31	* @deprecated All paginated list features have been deprecated
32	*/
33	@Deprecated
34	public class PaginatedDataList implements PaginatedList {
35
36	/** The sql map executor. */
37	private SqlMapExecutor sqlMapExecutor;
38
39	/** The statement name. */
40	private String statementName;
41
42	/** The parameter object. */
43	private Object parameterObject;
44
45	/** The page size. */
46	private int pageSize;
47
48	/** The index. */
49	private int index;
50
51	/** The prev page list. */
52	private List prevPageList;
53
54	/** The current page list. */
55	private List currentPageList;
56
57	/** The next page list. */
58	private List nextPageList;
59
60	/**
61	* Instantiates a new paginated data list.
62	*
63	* @param sqlMapExecutor
64	* the sql map executor
65	* @param statementName
66	* the statement name
67	* @param parameterObject
68	* the parameter object
69	* @param pageSize
70	* the page size
71	*
72	* @throws SQLException
73	* the SQL exception
74	*/
75	public PaginatedDataList(SqlMapExecutor sqlMapExecutor, String statementName, Object parameterObject, int pageSize)
76	throws SQLException {	1✔
77	this.sqlMapExecutor = sqlMapExecutor;	1✔
78	this.statementName = statementName;	1✔
79	this.parameterObject = parameterObject;	1✔
80	this.pageSize = pageSize;	1✔
81	this.index = 0;	1✔
82	pageTo(0);	1✔
83	}	1✔
84
85	/**
86	* Page forward.
87	*/
88	private void pageForward() {
89	try {
90	prevPageList = currentPageList;	1✔
91	currentPageList = nextPageList;	1✔
92	nextPageList = getList(index + 1, pageSize);	1✔
93	} catch (SQLException e) {	×
94	throw new RuntimeException("Unexpected error while repaginating paged list. Cause: " + e, e);	×
95	}	1✔
96	}	1✔
97
98	/**
99	* Page back.
100	*/
101	private void pageBack() {
102	try {
103	nextPageList = currentPageList;	1✔
104	currentPageList = prevPageList;	1✔
105	if (index > 0) {	1✔
106	prevPageList = getList(index - 1, pageSize);	1✔
107	} else {
108	prevPageList = new ArrayList<>();	1✔
109	}
110	} catch (SQLException e) {	×
111	throw new RuntimeException("Unexpected error while repaginating paged list. Cause: " + e, e);	×
112	}	1✔
113	}	1✔
114
115	/**
116	* Safe page to.
117	*
118	* @param idx
119	* the idx
120	*/
121	private void safePageTo(int idx) {
122	try {
123	pageTo(idx);	1✔
124	} catch (SQLException e) {	×
125	throw new RuntimeException("Unexpected error while repaginating paged list. Cause: " + e, e);	×
126	}	1✔
127	}	1✔
128
129	/**
130	* Page to.
131	*
132	* @param idx
133	* the idx
134	*
135	* @throws SQLException
136	* the SQL exception
137	*/
138	public void pageTo(int idx) throws SQLException {
139	index = idx;	1✔
140
141	List list;
142
143	if (idx < 1) {	1✔
144	list = getList(idx, pageSize * 2);	1✔
145	} else {
146	list = getList(idx - 1, pageSize * 3);	1✔
147	}
148
149	if (list.size() < 1) {	1✔
150	prevPageList = new ArrayList<>(0);	1✔
151	currentPageList = new ArrayList<>(0);	1✔
152	nextPageList = new ArrayList<>(0);	1✔
153	} else if (idx < 1) {	1✔
154	prevPageList = new ArrayList<>(0);	1✔
155	if (list.size() <= pageSize) {	1✔
156	currentPageList = list.subList(0, list.size());	1✔
157	nextPageList = new ArrayList<>(0);	1✔
158	} else {
159	currentPageList = list.subList(0, pageSize);	1✔
160	nextPageList = list.subList(pageSize, list.size());	1✔
161	}
162	} else {
163	if (list.size() <= pageSize) {	1✔
164	prevPageList = list.subList(0, list.size());	1✔
165	currentPageList = new ArrayList<>(0);	1✔
166	nextPageList = new ArrayList<>(0);	1✔
167	} else if (list.size() <= pageSize * 2) {	1✔
168	prevPageList = list.subList(0, pageSize);	1✔
169	currentPageList = list.subList(pageSize, list.size());	1✔
170	nextPageList = new ArrayList<>(0);	1✔
171	} else {
172	prevPageList = list.subList(0, pageSize);	1✔
173	currentPageList = list.subList(pageSize, pageSize * 2);	1✔
174	nextPageList = list.subList(pageSize * 2, list.size());	1✔
175	}
176	}
177
178	}	1✔
179
180	/**
181	* Gets the list.
182	*
183	* @param idx
184	* the idx
185	* @param localPageSize
186	* the local page size
187	*
188	* @return the list
189	*
190	* @throws SQLException
191	* the SQL exception
192	*/
193	private List getList(int idx, int localPageSize) throws SQLException {
194	return sqlMapExecutor.queryForList(statementName, parameterObject, idx * pageSize, localPageSize);	1✔
195	}
196
197	@Override
198	public boolean nextPage() {
199	if (isNextPageAvailable()) {	1✔
200	index++;	1✔
201	pageForward();	1✔
202	return true;	1✔
203	}
204	return false;	1✔
205	}
206
207	@Override
208	public boolean previousPage() {
209	if (isPreviousPageAvailable()) {	1✔
210	index--;	1✔
211	pageBack();	1✔
212	return true;	1✔
213	}
214	return false;	1✔
215	}
216
217	@Override
218	public void gotoPage(int pageNumber) {
219	safePageTo(pageNumber);	1✔
220	}	1✔
221
222	@Override
223	public int getPageSize() {
UNCOV 224	return pageSize;	×
225	}
226
227	@Override
228	public boolean isFirstPage() {
UNCOV 229	return index == 0;	×
230	}
231
232	@Override
233	public boolean isMiddlePage() {
UNCOV 234	return !isFirstPage() && !isLastPage();	×
235	}
236
237	@Override
238	public boolean isLastPage() {
UNCOV 239	return nextPageList.size() < 1;	×
240	}
241
242	@Override
243	public boolean isNextPageAvailable() {
244	return nextPageList.size() > 0;	1✔
245	}
246
247	@Override
248	public boolean isPreviousPageAvailable() {
249	return prevPageList.size() > 0;	1✔
250	}
251
252	@Override
253	public int size() {
254	return currentPageList.size();	1✔
255	}
256
257	@Override
258	public boolean isEmpty() {
UNCOV 259	return currentPageList.isEmpty();	×
260	}
261
262	@Override
263	public boolean contains(Object o) {
UNCOV 264	return currentPageList.contains(o);	×
265	}
266
267	@Override
268	public Iterator iterator() {
UNCOV 269	return currentPageList.iterator();	×
270	}
271
272	@Override
273	public Object[] toArray() {
UNCOV 274	return currentPageList.toArray();	×
275	}
276
277	@Override
278	public Object[] toArray(Object a[]) {
UNCOV 279	return currentPageList.toArray(a);	×
280	}
281
282	@Override
283	public boolean containsAll(Collection c) {
UNCOV 284	return currentPageList.containsAll(c);	×
285	}
286
287	@Override
288	public Object get(int index) {
289	return currentPageList.get(index);	1✔
290	}
291
292	@Override
293	public int indexOf(Object o) {
UNCOV 294	return currentPageList.indexOf(o);	×
295	}
296
297	@Override
298	public int lastIndexOf(Object o) {
UNCOV 299	return currentPageList.lastIndexOf(o);	×
300	}
301
302	@Override
303	public ListIterator listIterator() {
UNCOV 304	return currentPageList.listIterator();	×
305	}
306
307	@Override
308	public ListIterator listIterator(int index) {
UNCOV 309	return currentPageList.listIterator(index);	×
310	}
311
312	@Override
313	public List subList(int fromIndex, int toIndex) {
UNCOV 314	return currentPageList.subList(fromIndex, toIndex);	×
315	}
316
317	@Override
318	public boolean add(Object o) {
UNCOV 319	return currentPageList.add(o);	×
320	}
321
322	@Override
323	public boolean remove(Object o) {
UNCOV 324	return currentPageList.remove(o);	×
325	}
326
327	@Override
328	public boolean addAll(Collection c) {
UNCOV 329	return currentPageList.addAll(c);	×
330	}
331
332	@Override
333	public boolean addAll(int index, Collection c) {
UNCOV 334	return currentPageList.addAll(index, c);	×
335	}
336
337	@Override
338	public boolean removeAll(Collection c) {
UNCOV 339	return currentPageList.removeAll(c);	×
340	}
341
342	@Override
343	public boolean retainAll(Collection c) {
UNCOV 344	return currentPageList.retainAll(c);	×
345	}
346
347	@Override
348	public void clear() {
UNCOV 349	currentPageList.clear();	×
UNCOV 350	}	×
351
352	@Override
353	public Object set(int index, Object element) {
UNCOV 354	return currentPageList.set(index, element);	×
355	}
356
357	@Override
358	public void add(int index, Object element) {
UNCOV 359	currentPageList.add(index, element);	×
UNCOV 360	}	×
361
362	@Override
363	public Object remove(int index) {
UNCOV 364	return currentPageList.remove(index);	×
365	}
366
367	@Override
368	public int getPageIndex() {
UNCOV 369	return index;	×
370	}
371
372	}

mybatis / ibatis-2 / 736

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