ResultSetCollection.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.sql;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;

/**
 * Collection backed by the database. It doesn't hold resultsets open
 * but executes SQL statements for every method call. Iterators produced
 * by this collection are backed by open ResultSet.
 * @author Pavel Vlasov
 * @version $Revision: 1.6 $
 */
class ResultSetCollection implements Collection {
	private SQLProcessor processor;
	private String sql;
	private Parameterizer parameterizer;
	private Projector projector;
	private Integer pageSize;
	private int pageNum;
	
	
	/**
	 * @param processor
	 * @param sql
	 * @param parameterizer
	 * @param projector
	 */
	public ResultSetCollection(SQLProcessor processor, String sql, Parameterizer parameterizer, Projector projector) {
		this.processor=processor;
		this.sql=sql;
		this.parameterizer=parameterizer;
		this.projector=projector;
	}

	/**
	 * @param processor2
	 * @param string
	 * @param parameterizer2
	 * @param projector2
	 * @param pageNum
	 * @param pageSize
	 */
	public ResultSetCollection(SQLProcessor processor, String sql, Parameterizer parameterizer, Projector projector, int pageNum, int pageSize) {
		this(processor, sql, parameterizer, projector);
		this.pageSize=new Integer(pageSize);
		this.pageNum=pageNum;
	}

	public int size() {
		try {
			final int[] ret={0};
			final int[] counter={0};
			processor.processSelect(
					sql, 
					parameterizer, 
					new RowProcessor() {
						public boolean process(ResultSet rs) {
							if (onPage(counter)) {
								++ret[0];
							}
							return true;
						}
					});
			return ret[0];
		} catch (SQLException e) {
			throw new SQLRuntimeException(e);
		}
	}

	public void clear() {
		throw new UnsupportedOperationException();
	}

	public boolean isEmpty() {
		try {
			final boolean[] ret={true};
			final int[] counter={0};
			processor.processSelect(
					sql, 
					parameterizer, 
					new RowProcessor() {
						public boolean process(ResultSet rs) {
							if (onPage(counter)) {
								ret[0]=false;
								return false;
							}
							return true;
						}
					});
			return ret[0];
		} catch (SQLException e) {
			throw new SQLRuntimeException(e);
		}
	}

	public Object[] toArray() {
		LinkedList ll = new LinkedList();
		Iterator it = iterator();
		while (it.hasNext()) {
			ll.add(it.next());
		}
		return ll.toArray();
	}

	public boolean add(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean contains(final Object o) {
		try {
			final boolean[] ret={false};
			final int[] counter={0};
			processor.processSelect(
					sql, 
					parameterizer, 
					new RowProcessor() {
						public boolean process(ResultSet rs) throws SQLException {
							if (onPage(counter)) {
								if (o.equals(projector.project(rs))) {
									ret[0]=true;
								}
							}
							return !ret[0];
						}
					});
			return ret[0];
		} catch (SQLException e) {
			throw new SQLRuntimeException(e);
		}
	}

	public boolean remove(final Object o) {
		try {
			final boolean[] ret={false};
			final int[] counter={0};
			processor.processSelect(
					sql, 
					parameterizer, 
					new RowProcessor() {
						public boolean process(ResultSet rs) throws SQLException {
							if (onPage(counter)) {
								if (o.equals(projector.project(rs))) {
									rs.deleteRow();
									ret[0]=true;								
								}
							}
							return true;
						}
					});
			return ret[0];
		} catch (SQLException e) {
			throw new SQLRuntimeException(e);
		}
	}

	public boolean addAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean containsAll(Collection c) {
		try {
			final Collection param=new LinkedList(c);
			final int[] counter={0};
			processor.processSelect(
					sql, 
					parameterizer, 
					new RowProcessor() {
						public boolean process(ResultSet rs) throws SQLException {
							if (onPage(counter)) {
								Object o=projector.project(rs);
								param.remove(o);
							}
							return !param.isEmpty();
						}
					});
			return param.isEmpty();
		} catch (SQLException e) {
			throw new SQLRuntimeException(e);
		}
	}

	public boolean removeAll(final Collection c) {
		try {
			final boolean[] ret={false};
			final int[] counter={0};
			processor.processSelect(
					sql, 
					parameterizer, 
					new RowProcessor() {
						public boolean process(ResultSet rs) throws SQLException {							
							if (onPage(counter)) {
								if (c.contains(projector.project(rs))) {
									rs.deleteRow();
									ret[0]=true;								
								}
							}
							return true;
						}
					});
			return ret[0];
		} catch (SQLException e) {
			throw new SQLRuntimeException(e);
		}
	}

	public boolean retainAll(final Collection c) {
		try {
			final boolean[] ret={false};
			final int[] counter={0};
			processor.processSelect(
					sql, 
					parameterizer, 
					new RowProcessor() {
						public boolean process(ResultSet rs) throws SQLException {							
							if (onPage(counter)) {
								if (!c.contains(projector.project(rs))) {
									rs.deleteRow();
									ret[0]=true;								
								}
							}
							return true;
						}
					});
			return ret[0];
		} catch (SQLException e) {
			throw new SQLRuntimeException(e);
		}
	}

	public Iterator iterator() {		
		return new DataIterator() {
			private Connection connection;
			private Statement statement;
			private ResultSet rs;
			private int counter;
			
			public void close() throws SQLException {
				//System.out.println("Iterator close: "+ --openIteratorCounter);

				
				try {
					if (rs!=null) {
						rs.close();
					}
				} finally {
					rs=null;
					try {
						if (statement!=null) {
							statement.close();
						}
					} finally {
						statement=null;
						try {
							if (connection!=null) {
								processor.releaseConnection(connection);
							}
						} finally {
							connection=null;
						}
					}
				}
			}
			
			private Object o;
			
			{
				//System.out.println("Iterator open: "+ ++openIteratorCounter);

				//new Exception("Iterator stack trace for debugging").printStackTrace(System.out);

				
				long start = processor.getTimeIntervalCategory()==null ? 0 : processor.getTimeIntervalCategory().getTime();
				try {
					connection=processor.getConnection();
					if (parameterizer==null) {
						statement=connection.createStatement();
						rs=statement.executeQuery(sql);
					} else {
						PreparedStatement ps=connection.prepareStatement(sql);
						statement=ps;
						parameterizer.parameterize(ps, 1);
						rs=ps.executeQuery();
						// moving to the first record in page.

						while (pageSize!=null && (++counter<pageSize.intValue()*(pageNum-1)) && rs.next());
					}
				} catch (SQLException e) {
					try {
						close();
					} catch (SQLException ee) {
						// We already have an exception, so we ignore cleanup one.

					}
					throw new SQLRuntimeException(e);
				} finally {
					if (processor.getTimeIntervalCategory()!=null) {
						processor.getTimeIntervalCategory().addInterval(sql, start);
					}
				}
			}

			public void remove() {
				if (nextCalled) {
					try {
						rs.deleteRow();
					} catch (SQLException e) {
						try {
							close();
						} catch (SQLException ee) {
							// Nothing

						}
					
						throw new SQLRuntimeException(e);
					}
				} else {
					throw new IllegalStateException("Call next() first");
				}
			}

			private boolean nextCalled=true;
			private boolean lastResult=false;
			
			public boolean hasNext() {
				if (nextCalled) {
					nextCalled=false;
					try {
						if ((pageSize==null || counter<pageSize.intValue()*pageNum) && rs.next()) {
							o=projector.project(rs);
							if (o instanceof DataAccessObject) {
								((DataAccessObject) o).setSQLProcessor(processor);
							}
							
							lastResult=true;
						} else {
							lastResult=false;
							close();
						}
					} catch (SQLException e) {
						try {
							close();
						} catch (SQLException ee) {
							// Nothing

						}
					
						throw new SQLRuntimeException(e);
					}					
				}
				
				return lastResult; 
			}

			public Object next() {
				if (nextCalled) {
					if (!hasNext()) {
						throw new NoSuchElementException();
					}
				}
				
				nextCalled=true;
				++counter;
				return o;
			}
			
			protected void finalize() throws Throwable {
				if (connection!=null) {
					System.err.println("WARN ["+this.getClass().getName()+"]: Connection leak for query '"+sql+"'");
				}
				
				try {
					close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
				super.finalize();
			}

		};
	}
	

	public Object[] toArray(Object[] a) {
		LinkedList ll = new LinkedList();
		Iterator it = iterator();
		while (it.hasNext()) {
			ll.add(it.next());
		}
		return ll.toArray(a);
	}

	/**
	 * @param counter
	 * @return
	 */
	private boolean onPage(final int[] counter) {
		return pageSize==null || (++counter[0]>(pageNum-1)*pageSize.intValue() && counter[0]<=pageNum*pageSize.intValue());
	}

}