StatementRdbWrapper.java

/*******************************************************************************
 * Copyright (c) 2004, 2007-2009 IBM Corporation and Cambridge Semantics Incorporated.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Created by:  Generated Source from org.openanzo.jdbc.utils.opgen.jet
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *	   Cambridge Semantics Incorporated - Fork to Anzo
 *******************************************************************************/
package org.openanzo.datasource.nodecentric.sql;
// allow for all types that can be returned from a resultset

/**
 *	StatementRdbWrapper provides wrappers around SQL queries and transforms ResultSets into java objects
 *
 *	@author Generated Source from org.openanzo.jdbc.utils.opgen.jet
 */
public class StatementRdbWrapper {
	private static final org.slf4j.Logger                           log                   = org.slf4j.LoggerFactory.getLogger(StatementRdbWrapper.class);
	static final long CUTOFF=5;

	/**
	  *Constant "selectStatementId" used to reference prepared statement  Statement.selectStatementId
	  *
	  * <code>
	  *  		SELECT S.ID 		FROM STATEMENTS S 		WHERE SUBJECT = ? AND PREDICATE = ? AND OBJECT = ? AND S.NAMEDGRAPHID = ? AND REND IS NULL; 	
	  * </code>
	  */
	public static final String selectStatementId = "Statement.selectStatementId";

	/**
	  *Constant "insertStatement" used to reference prepared statement  Statement.insertStatement
	  *
	  * <code>
	  *  		INSERT INTO STATEMENTS(ID,METADATA,UUID,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,RSTART,COMMITTED) VALUES (?,?,?,?, ?, ?, ?, ?,0); 	
	  * </code>
	  */
	public static final String insertStatement = "Statement.insertStatement";

	/**
	  *Constant "insertStatementNR" used to reference prepared statement  Statement.insertStatementNR
	  *
	  * <code>
	  *  		INSERT INTO STATEMENTS_NR(ID,METADATA,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,COMMITTED) VALUES (?, ?,?, ?, ?, ?,0); 	
	  * </code>
	  */
	public static final String insertStatementNR = "Statement.insertStatementNR";

	/**
	  *Constant "deleteStatement" used to reference prepared statement  Statement.deleteStatement
	  *
	  * <code>
	  *  		UPDATE STATEMENTS SET REND=? WHERE ID=?; 	
	  * </code>
	  */
	public static final String deleteStatement = "Statement.deleteStatement";

	/**
	  *Constant "deleteStatementNR" used to reference prepared statement  Statement.deleteStatementNR
	  *
	  * <code>
	  *  		DELETE FROM STATEMENTS_NR WHERE ID=?; 	
	  * </code>
	  */
	public static final String deleteStatementNR = "Statement.deleteStatementNR";

	/**
	  *Constant "countStatements" used to reference prepared statement  Statement.countStatements
	  *
	  * <code>
	  *  		SELECT COUNT(1) 		FROM STATEMENTS 		WHERE ((REND IS NULL AND COMMITTED=0) OR (REND IS NOT NULL AND COMMITTED<0)); 		
	  * </code>
	  */
	public static final String countStatements = "Statement.countStatements";

	/**
	  *Constant "resolveDataset" used to reference prepared statement  Statement.resolveDataset
	  *
	  * <code>
	  *          SELECT PREDICATE,OBJECT         FROM STATEMENTS         WHERE ((REND IS NULL AND COMMITTED=0) OR (REND IS NOT NULL AND COMMITTED<0)) AND         PREDICATE IN ({0},{1},{2}) AND         SUBJECT = ? AND         NAMEDGRAPHID = ?         
	  * </code>
	  */
	public static final String resolveDataset = "Statement.resolveDataset";

	/**
	  *Constant "resolveDatasetNR" used to reference prepared statement  Statement.resolveDatasetNR
	  *
	  * <code>
	  *          SELECT PREDICATE,OBJECT         FROM STATEMENTS_NR         WHERE COMMITTED<=0 AND         PREDICATE IN ({0},{1},{2}) AND         SUBJECT = ? AND         NAMEDGRAPHID = ?         
	  * </code>
	  */
	public static final String resolveDatasetNR = "Statement.resolveDatasetNR";

	/**
	  *Constant "countStatementsNR" used to reference prepared statement  Statement.countStatementsNR
	  *
	  * <code>
	  *   		SELECT COUNT(1) 		FROM STATEMENTS_NR WHERE COMMITTED <=0; 		
	  * </code>
	  */
	public static final String countStatementsNR = "Statement.countStatementsNR";

	/**
	  *Constant "findMinMaxId" used to reference prepared statement  Statement.findMinMaxId
	  *
	  * <code>
	  *          SELECT MIN(ID),MAX(ID) FROM {0}     
	  * </code>
	  */
	public static final String findMinMaxId = "Statement.findMinMaxId";

	/**
	  *Constant "findLiteralStatementsRange" used to reference prepared statement  Statement.findLiteralStatementsRange
	  *
	  * <code>
	  *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > ? and OBJECT < ?         
	  * </code>
	  */
	public static final String findLiteralStatementsRange = "Statement.findLiteralStatementsRange";

	/**
	  *Constant "findLiteralStatementsNRRange" used to reference prepared statement  Statement.findLiteralStatementsNRRange
	  *
	  * <code>
	  *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT          FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > ? and OBJECT < ?         
	  * </code>
	  */
	public static final String findLiteralStatementsNRRange = "Statement.findLiteralStatementsNRRange";

	/**
	  *Constant "findLiteralStatements" used to reference prepared statement  Statement.findLiteralStatements
	  *
	  * <code>
	  *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM ALL_STMTS_VIEW WHERE OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855         
	  * </code>
	  */
	public static final String findLiteralStatements = "Statement.findLiteralStatements";

	/**
	  *Constant "findLiteralStatementsLimited" used to reference prepared statement  Statement.findLiteralStatementsLimited
	  *
	  * <code>
	  *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM(         SELECT ROW_NUMBER() OVER (ORDER BY NAMEDGRAPHID) AS ROWNUM,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855) AS FOO         WHERE ROWNUM > ? AND ROWNUM<= ?         
	  * </code>
	  */
	public static final String findLiteralStatementsLimited = "Statement.findLiteralStatementsLimited";

	/**
	  *Constant "findLiteralStatementsNRLimited" used to reference prepared statement  Statement.findLiteralStatementsNRLimited
	  *
	  * <code>
	  *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM(         SELECT ROW_NUMBER() OVER (ORDER BY NAMEDGRAPHID) AS ROWNUM,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855) AS FOO         WHERE ROWNUM > ? AND ROWNUM<= ?                  
	  * </code>
	  */
	public static final String findLiteralStatementsNRLimited = "Statement.findLiteralStatementsNRLimited";

	/**
	  *Constant "findLiteralStatementsLimitOffset" used to reference prepared statement  Statement.findLiteralStatementsLimitOffset
	  *
	  * <code>
	  *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855         ORDER BY NAMEDGRAPHID ASC         LIMIT ? OFFSET ?         
	  * </code>
	  */
	public static final String findLiteralStatementsLimitOffset = "Statement.findLiteralStatementsLimitOffset";

	/**
	  *Constant "findLiteralStatementsNRLimitOffset" used to reference prepared statement  Statement.findLiteralStatementsNRLimitOffset
	  *
	  * <code>
	  *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855         ORDER BY NAMEDGRAPHID ASC         LIMIT ? OFFSET ?         
	  * </code>
	  */
	public static final String findLiteralStatementsNRLimitOffset = "Statement.findLiteralStatementsNRLimitOffset";



	
	/**
	 * Runs the selectStatementId prepared statement.
	  * <code>
	 *  		SELECT S.ID 		FROM STATEMENTS S 		WHERE SUBJECT = ? AND PREDICATE = ? AND OBJECT = ? AND S.NAMEDGRAPHID = ? AND REND IS NULL; 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param subject template parameter
	 *@param predicate template parameter
	 *@param object template parameter
	 *@param namedGraph template parameter
	 *
	 *@return  long
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static long selectStatementId (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long subject, long predicate, long object, long namedGraph) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(selectStatementId, new String[] {},connection); int argc = 1;
			ps.setLong(argc++, subject);
			ps.setLong(argc++, predicate);
			ps.setLong(argc++, object);
			ps.setLong(argc++, namedGraph);
			java.sql.ResultSet rs = null;
			try {
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}
				if(!rs.next())
					return 0;				 
				long val = rs.getLong(1);
				return val;
			} finally {
				if(rs != null) {
					try {
						rs.close();
					} catch (java.sql.SQLException sqle) {
						if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing result set",sqle);
					}
				}
			}

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"selectStatementId",stmtProvider.getSqlString(selectStatementId) ,""+ "subject="+(subject) + "," +"predicate="+(predicate) + "," +"object="+(object) + "," +"namedGraph="+(namedGraph),"");
		} finally {
			if (ps != null) {
				try { 
					ps.close(); 
				} catch (java.sql.SQLException sqle) {
					if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing prepared statement",sqle);
				}
			}
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[selectStatementId]"+endtimer);
		}
	}




	
	/**
	 * Runs the insertStatement prepared statement.
	  * <code>
	 *  		INSERT INTO STATEMENTS(ID,METADATA,UUID,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,RSTART,COMMITTED) VALUES (?,?,?,?, ?, ?, ?, ?,0); 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param id template parameter
	 *@param metadata template parameter
	 *@param uuid template parameter
	 *@param namedGraphId template parameter
	 *@param subject template parameter
	 *@param predicate template parameter
	 *@param object template parameter
	 *@param rstart template parameter
	 *
	 *
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static void insertStatement (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, String id, int metadata, long uuid, long namedGraphId, long subject, long predicate, long object, long rstart) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertStatement, new String[] {},connection); int argc = 1;
			if(id == null) {
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER,"id","insertStatement");
			} else {
				ps.setString(argc++, id);
			}
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, uuid);
			ps.setLong(argc++, namedGraphId);
			ps.setLong(argc++, subject);
			ps.setLong(argc++, predicate);
			ps.setLong(argc++, object);
			ps.setLong(argc++, rstart);
			try{			
				ps.execute();
			}catch(java.sql.SQLException sqle){
				if(sqle.getErrorCode()==1205){
					int retries=0;
					while(retries<5){
						try {
                        	Thread.sleep(5000);
                        }catch(InterruptedException ie) {
                            throw sqle;
                        }
						try{			
							ps.execute();
							break;
						}catch(java.sql.SQLException sqleInner){
							if(sqleInner.getErrorCode()==1205){
								retries++;
							}else{
								throw sqleInner;
							}
						}
					}
					if(retries>=5){
						throw sqle;
					}
				}else{
					throw sqle;
				}
			}

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"insertStatement",stmtProvider.getSqlString(insertStatement) ,""+ "id="+((id!=null)?id.toString():"null") + "," +"metadata="+(metadata) + "," +"uuid="+(uuid) + "," +"namedGraphId="+(namedGraphId) + "," +"subject="+(subject) + "," +"predicate="+(predicate) + "," +"object="+(object) + "," +"rstart="+(rstart),"");
		} finally {
			if (ps != null) {
				try { 
					ps.close(); 
				} catch (java.sql.SQLException sqle) {
					if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing prepared statement",sqle);
				}
			}
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[insertStatement]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertStatement prepared statement
	 */
	public static class BatchInsertStatement extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertStatement prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertStatement(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertStatement,new String[] {});
		}
		
		/**
		 * Sets the input parameters for the insertStatement prepared statement.
		 *
	 *@param id template parameter
	 *@param metadata template parameter
	 *@param uuid template parameter
	 *@param namedGraphId template parameter
	 *@param subject template parameter
	 *@param predicate template parameter
	 *@param object template parameter
	 *@param rstart template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (String id, int metadata, long uuid, long namedGraphId, long subject, long predicate, long object, long rstart) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			if(id == null) {
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER,"id","insertStatement");
			} else {
				ps.setString(argc++, id);
			}
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, uuid);
			ps.setLong(argc++, namedGraphId);
			ps.setLong(argc++, subject);
			ps.setLong(argc++, predicate);
			ps.setLong(argc++, object);
			ps.setLong(argc++, rstart);
				ps.addBatch();
			}catch(java.sql.SQLException sqle){
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle);
			}
		}
	}




	
	/**
	 * Runs the insertStatementNR prepared statement.
	  * <code>
	 *  		INSERT INTO STATEMENTS_NR(ID,METADATA,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,COMMITTED) VALUES (?, ?,?, ?, ?, ?,0); 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param id template parameter
	 *@param metadata template parameter
	 *@param namedGraphId template parameter
	 *@param subject template parameter
	 *@param predicate template parameter
	 *@param object template parameter
	 *
	 *
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static void insertStatementNR (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, String id, int metadata, long namedGraphId, long subject, long predicate, long object) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertStatementNR, new String[] {},connection); int argc = 1;
			if(id == null) {
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER,"id","insertStatementNR");
			} else {
				ps.setString(argc++, id);
			}
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedGraphId);
			ps.setLong(argc++, subject);
			ps.setLong(argc++, predicate);
			ps.setLong(argc++, object);
			try{			
				ps.execute();
			}catch(java.sql.SQLException sqle){
				if(sqle.getErrorCode()==1205){
					int retries=0;
					while(retries<5){
						try {
                        	Thread.sleep(5000);
                        }catch(InterruptedException ie) {
                            throw sqle;
                        }
						try{			
							ps.execute();
							break;
						}catch(java.sql.SQLException sqleInner){
							if(sqleInner.getErrorCode()==1205){
								retries++;
							}else{
								throw sqleInner;
							}
						}
					}
					if(retries>=5){
						throw sqle;
					}
				}else{
					throw sqle;
				}
			}

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"insertStatementNR",stmtProvider.getSqlString(insertStatementNR) ,""+ "id="+((id!=null)?id.toString():"null") + "," +"metadata="+(metadata) + "," +"namedGraphId="+(namedGraphId) + "," +"subject="+(subject) + "," +"predicate="+(predicate) + "," +"object="+(object),"");
		} finally {
			if (ps != null) {
				try { 
					ps.close(); 
				} catch (java.sql.SQLException sqle) {
					if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing prepared statement",sqle);
				}
			}
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[insertStatementNR]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertStatementNR prepared statement
	 */
	public static class BatchInsertStatementNR extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertStatementNR prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertStatementNR(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertStatementNR,new String[] {});
		}
		
		/**
		 * Sets the input parameters for the insertStatementNR prepared statement.
		 *
	 *@param id template parameter
	 *@param metadata template parameter
	 *@param namedGraphId template parameter
	 *@param subject template parameter
	 *@param predicate template parameter
	 *@param object template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (String id, int metadata, long namedGraphId, long subject, long predicate, long object) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			if(id == null) {
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER,"id","insertStatementNR");
			} else {
				ps.setString(argc++, id);
			}
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedGraphId);
			ps.setLong(argc++, subject);
			ps.setLong(argc++, predicate);
			ps.setLong(argc++, object);
				ps.addBatch();
			}catch(java.sql.SQLException sqle){
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle);
			}
		}
	}




	
	/**
	 * Runs the deleteStatement prepared statement.
	  * <code>
	 *  		UPDATE STATEMENTS SET REND=? WHERE ID=?; 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param rend template parameter
	 *@param id template parameter
	 *
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int deleteStatement (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long rend, String id) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(deleteStatement, new String[] {},connection); int argc = 1;
			ps.setLong(argc++, rend);
			if(id == null) {
				ps.setNull(argc++, java.sql.Types.VARCHAR);
			} else {
				ps.setString(argc++, id);
			}
				int counter = 0;
				try{
					counter=ps.executeUpdate();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								counter=ps.executeUpdate();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}
				return counter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"deleteStatement",stmtProvider.getSqlString(deleteStatement) ,""+ "rend="+(rend) + "," +"id="+((id!=null)?id.toString():"null"),"");
		} finally {
			if (ps != null) {
				try { 
					ps.close(); 
				} catch (java.sql.SQLException sqle) {
					if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing prepared statement",sqle);
				}
			}
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[deleteStatement]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the DeleteStatement prepared statement
	 */
	public static class BatchDeleteStatement extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the DeleteStatement prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchDeleteStatement(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,deleteStatement,new String[] {});
		}
		
		/**
		 * Sets the input parameters for the deleteStatement prepared statement.
		 *
	 *@param rend template parameter
	 *@param id template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (long rend, String id) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setLong(argc++, rend);
			if(id == null) {
				ps.setNull(argc++, java.sql.Types.VARCHAR);
			} else {
				ps.setString(argc++, id);
			}
				ps.addBatch();
			}catch(java.sql.SQLException sqle){
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle);
			}
		}
	}




	
	/**
	 * Runs the deleteStatementNR prepared statement.
	  * <code>
	 *  		DELETE FROM STATEMENTS_NR WHERE ID=?; 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param id template parameter
	 *
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int deleteStatementNR (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, String id) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(deleteStatementNR, new String[] {},connection); int argc = 1;
			if(id == null) {
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER,"id","deleteStatementNR");
			} else {
				ps.setString(argc++, id);
			}
				int counter = 0;
				try{
					counter=ps.executeUpdate();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								counter=ps.executeUpdate();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}
				return counter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"deleteStatementNR",stmtProvider.getSqlString(deleteStatementNR) ,""+ "id="+((id!=null)?id.toString():"null"),"");
		} finally {
			if (ps != null) {
				try { 
					ps.close(); 
				} catch (java.sql.SQLException sqle) {
					if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing prepared statement",sqle);
				}
			}
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[deleteStatementNR]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the DeleteStatementNR prepared statement
	 */
	public static class BatchDeleteStatementNR extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the DeleteStatementNR prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchDeleteStatementNR(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,deleteStatementNR,new String[] {});
		}
		
		/**
		 * Sets the input parameters for the deleteStatementNR prepared statement.
		 *
	 *@param id template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (String id) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			if(id == null) {
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER,"id","deleteStatementNR");
			} else {
				ps.setString(argc++, id);
			}
				ps.addBatch();
			}catch(java.sql.SQLException sqle){
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle);
			}
		}
	}




	
	/**
	 * Runs the countStatements prepared statement.
	  * <code>
	 *  		SELECT COUNT(1) 		FROM STATEMENTS 		WHERE ((REND IS NULL AND COMMITTED=0) OR (REND IS NOT NULL AND COMMITTED<0)); 		
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *
	 *@return  long
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static long countStatements (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(countStatements, new String[] {},connection);
			java.sql.ResultSet rs = null;
			try {
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}
				if(!rs.next())
					return 0;				 
				long val = rs.getLong(1);
				return val;
			} finally {
				if(rs != null) {
					try {
						rs.close();
					} catch (java.sql.SQLException sqle) {
						if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing result set",sqle);
					}
				}
			}

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"countStatements",stmtProvider.getSqlString(countStatements) ,"","");
		} finally {
			if (ps != null) {
				try { 
					ps.close(); 
				} catch (java.sql.SQLException sqle) {
					if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing prepared statement",sqle);
				}
			}
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[countStatements]"+endtimer);
		}
	}




	/**
	 * Transformer that transforms the rows in the result set for the resolveDataset prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<ResolveDatasetResult> transformResolveDataset = new org.openanzo.jdbc.utils.Transformer<ResolveDatasetResult>(){
		public ResolveDatasetResult transform(java.sql.ResultSet rs) {

			
				ResolveDatasetResult result = new ResolveDatasetResult();
				try {
				result.predicateId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:predicateId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.object=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:object",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the resolveDataset prepared statement.
	  * <code>
	 *          SELECT PREDICATE,OBJECT         FROM STATEMENTS         WHERE ((REND IS NULL AND COMMITTED=0) OR (REND IS NOT NULL AND COMMITTED<0)) AND         PREDICATE IN ({0},{1},{2}) AND         SUBJECT = ? AND         NAMEDGRAPHID = ?         
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param gId template parameter
	 *@param g2Id template parameter
	 *
	 *@param ngId template parameter
	 *@param dgId template parameter
	 *@param dngId template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<ResolveDatasetResult> resolveDataset (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long gId, long g2Id, String ngId, String dgId, String dngId) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(resolveDataset, new String[] {ngId, dgId, dngId},connection); int argc = 1;
			ps.setLong(argc++, gId);
			ps.setLong(argc++, g2Id);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<ResolveDatasetResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveDatasetResult>(rs, ps, stmtProvider, transformResolveDataset);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"resolveDataset",stmtProvider.getSqlString(resolveDataset) ,""+ "gId="+(gId) + "," +"g2Id="+(g2Id),""+ "ngId="+((ngId!=null)?ngId.toString():"null") + "," +"dgId="+((dgId!=null)?dgId.toString():"null") + "," +"dngId="+((dngId!=null)?dngId.toString():"null"));
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[resolveDataset]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of ResolveDatasetResult
	 */
	public static class ResolveDatasetResult {
			/**Value for the "predicateId" result value*/
			private long predicateId;
			/**Value for the "object" result value*/
			private long object;

		/**
		  *Get PredicateId value
		  *@return PredicateId value
		  */
			public long getPredicateId() {
				return this.predicateId;
			}

		/**
		  *Get Object value
		  *@return Object value
		  */
			public long getObject() {
				return this.object;
			}

	}



	/**
	 * Transformer that transforms the rows in the result set for the resolveDatasetNR prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<ResolveDatasetNRResult> transformResolveDatasetNR = new org.openanzo.jdbc.utils.Transformer<ResolveDatasetNRResult>(){
		public ResolveDatasetNRResult transform(java.sql.ResultSet rs) {

			
				ResolveDatasetNRResult result = new ResolveDatasetNRResult();
				try {
				result.predicateId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:predicateId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.object=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:object",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the resolveDatasetNR prepared statement.
	  * <code>
	 *          SELECT PREDICATE,OBJECT         FROM STATEMENTS_NR         WHERE COMMITTED<=0 AND         PREDICATE IN ({0},{1},{2}) AND         SUBJECT = ? AND         NAMEDGRAPHID = ?         
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param gId template parameter
	 *@param g2Id template parameter
	 *
	 *@param ngId template parameter
	 *@param dgId template parameter
	 *@param dngId template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<ResolveDatasetNRResult> resolveDatasetNR (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long gId, long g2Id, String ngId, String dgId, String dngId) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(resolveDatasetNR, new String[] {ngId, dgId, dngId},connection); int argc = 1;
			ps.setLong(argc++, gId);
			ps.setLong(argc++, g2Id);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<ResolveDatasetNRResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveDatasetNRResult>(rs, ps, stmtProvider, transformResolveDatasetNR);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"resolveDatasetNR",stmtProvider.getSqlString(resolveDatasetNR) ,""+ "gId="+(gId) + "," +"g2Id="+(g2Id),""+ "ngId="+((ngId!=null)?ngId.toString():"null") + "," +"dgId="+((dgId!=null)?dgId.toString():"null") + "," +"dngId="+((dngId!=null)?dngId.toString():"null"));
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[resolveDatasetNR]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of ResolveDatasetNRResult
	 */
	public static class ResolveDatasetNRResult {
			/**Value for the "predicateId" result value*/
			private long predicateId;
			/**Value for the "object" result value*/
			private long object;

		/**
		  *Get PredicateId value
		  *@return PredicateId value
		  */
			public long getPredicateId() {
				return this.predicateId;
			}

		/**
		  *Get Object value
		  *@return Object value
		  */
			public long getObject() {
				return this.object;
			}

	}



	
	/**
	 * Runs the countStatementsNR prepared statement.
	  * <code>
	 *   		SELECT COUNT(1) 		FROM STATEMENTS_NR WHERE COMMITTED <=0; 		
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *
	 *@return  long
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static long countStatementsNR (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(countStatementsNR, new String[] {},connection);
			java.sql.ResultSet rs = null;
			try {
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}
				if(!rs.next())
					return 0;				 
				long val = rs.getLong(1);
				return val;
			} finally {
				if(rs != null) {
					try {
						rs.close();
					} catch (java.sql.SQLException sqle) {
						if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing result set",sqle);
					}
				}
			}

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"countStatementsNR",stmtProvider.getSqlString(countStatementsNR) ,"","");
		} finally {
			if (ps != null) {
				try { 
					ps.close(); 
				} catch (java.sql.SQLException sqle) {
					if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing prepared statement",sqle);
				}
			}
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[countStatementsNR]"+endtimer);
		}
	}




	
	/**
	 * Runs the findMinMaxId prepared statement.
	  * <code>
	 *          SELECT MIN(ID),MAX(ID) FROM {0}     
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *
	 *@param tableName template parameter
	 *@return  FindMinMaxIdResult
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static FindMinMaxIdResult findMinMaxId (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, String tableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(findMinMaxId, new String[] {tableName},connection);
			java.sql.ResultSet rs = null;
			try {
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}
				if(!rs.next()) return null;
		FindMinMaxIdResult result=new FindMinMaxIdResult();
				result.min=rs.getLong(1);
				result.max=rs.getLong(2);
				return result;
			} finally {
				if(rs != null) {
					try {
						rs.close();
					} catch (java.sql.SQLException sqle) {
						if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing result set",sqle);
					}
				}
			}

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"findMinMaxId",stmtProvider.getSqlString(findMinMaxId) ,"",""+ "tableName="+((tableName!=null)?tableName.toString():"null"));
		} finally {
			if (ps != null) {
				try { 
					ps.close(); 
				} catch (java.sql.SQLException sqle) {
					if(log.isDebugEnabled())log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error closing prepared statement",sqle);
				}
			}
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[findMinMaxId]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of FindMinMaxIdResult
	 */
	public static class FindMinMaxIdResult {
			/**Value for the "min" result value*/
			private long min;
			/**Value for the "max" result value*/
			private long max;

		/**
		  *Get Min value
		  *@return Min value
		  */
			public long getMin() {
				return this.min;
			}

		/**
		  *Get Max value
		  *@return Max value
		  */
			public long getMax() {
				return this.max;
			}

	}



	/**
	 * Transformer that transforms the rows in the result set for the findLiteralStatementsRange prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsRangeResult> transformFindLiteralStatementsRange = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsRangeResult>(){
		public FindLiteralStatementsRangeResult transform(java.sql.ResultSet rs) {

			
				FindLiteralStatementsRangeResult result = new FindLiteralStatementsRangeResult();
				try {
				result.namedGraphId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:namedGraphId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subj=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:subj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.prop=rs.getLong(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:prop",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.obj=rs.getLong(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:obj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the findLiteralStatementsRange prepared statement.
	  * <code>
	 *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > ? and OBJECT < ?         
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param start template parameter
	 *@param end template parameter
	 *
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsRangeResult> findLiteralStatementsRange (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long start, long end) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsRange, new String[] {},connection); int argc = 1;
			ps.setLong(argc++, start);
			ps.setLong(argc++, end);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsRangeResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsRangeResult>(rs, ps, stmtProvider, transformFindLiteralStatementsRange);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"findLiteralStatementsRange",stmtProvider.getSqlString(findLiteralStatementsRange) ,""+ "start="+(start) + "," +"end="+(end),"");
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsRange]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of FindLiteralStatementsRangeResult
	 */
	public static class FindLiteralStatementsRangeResult {
			/**Value for the "namedGraphId" result value*/
			private long namedGraphId;
			/**Value for the "subj" result value*/
			private long subj;
			/**Value for the "prop" result value*/
			private long prop;
			/**Value for the "obj" result value*/
			private long obj;

		/**
		  *Get NamedGraphId value
		  *@return NamedGraphId value
		  */
			public long getNamedGraphId() {
				return this.namedGraphId;
			}

		/**
		  *Get Subj value
		  *@return Subj value
		  */
			public long getSubj() {
				return this.subj;
			}

		/**
		  *Get Prop value
		  *@return Prop value
		  */
			public long getProp() {
				return this.prop;
			}

		/**
		  *Get Obj value
		  *@return Obj value
		  */
			public long getObj() {
				return this.obj;
			}

	}



	/**
	 * Transformer that transforms the rows in the result set for the findLiteralStatementsNRRange prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRRangeResult> transformFindLiteralStatementsNRRange = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRRangeResult>(){
		public FindLiteralStatementsNRRangeResult transform(java.sql.ResultSet rs) {

			
				FindLiteralStatementsNRRangeResult result = new FindLiteralStatementsNRRangeResult();
				try {
				result.namedGraphId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:namedGraphId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subj=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:subj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.prop=rs.getLong(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:prop",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.obj=rs.getLong(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:obj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the findLiteralStatementsNRRange prepared statement.
	  * <code>
	 *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT          FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > ? and OBJECT < ?         
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param start template parameter
	 *@param end template parameter
	 *
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRRangeResult> findLiteralStatementsNRRange (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long start, long end) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsNRRange, new String[] {},connection); int argc = 1;
			ps.setLong(argc++, start);
			ps.setLong(argc++, end);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRRangeResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsNRRangeResult>(rs, ps, stmtProvider, transformFindLiteralStatementsNRRange);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"findLiteralStatementsNRRange",stmtProvider.getSqlString(findLiteralStatementsNRRange) ,""+ "start="+(start) + "," +"end="+(end),"");
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsNRRange]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of FindLiteralStatementsNRRangeResult
	 */
	public static class FindLiteralStatementsNRRangeResult {
			/**Value for the "namedGraphId" result value*/
			private long namedGraphId;
			/**Value for the "subj" result value*/
			private long subj;
			/**Value for the "prop" result value*/
			private long prop;
			/**Value for the "obj" result value*/
			private long obj;

		/**
		  *Get NamedGraphId value
		  *@return NamedGraphId value
		  */
			public long getNamedGraphId() {
				return this.namedGraphId;
			}

		/**
		  *Get Subj value
		  *@return Subj value
		  */
			public long getSubj() {
				return this.subj;
			}

		/**
		  *Get Prop value
		  *@return Prop value
		  */
			public long getProp() {
				return this.prop;
			}

		/**
		  *Get Obj value
		  *@return Obj value
		  */
			public long getObj() {
				return this.obj;
			}

	}



	/**
	 * Transformer that transforms the rows in the result set for the findLiteralStatements prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsResult> transformFindLiteralStatements = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsResult>(){
		public FindLiteralStatementsResult transform(java.sql.ResultSet rs) {

			
				FindLiteralStatementsResult result = new FindLiteralStatementsResult();
				try {
				result.namedGraphId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:namedGraphId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subject=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:subject",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.predicate=rs.getLong(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:predicate",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.object=rs.getLong(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:object",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the findLiteralStatements prepared statement.
	  * <code>
	 *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM ALL_STMTS_VIEW WHERE OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855         
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsResult> findLiteralStatements (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(findLiteralStatements, new String[] {},connection);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsResult>(rs, ps, stmtProvider, transformFindLiteralStatements);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"findLiteralStatements",stmtProvider.getSqlString(findLiteralStatements) ,"","");
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[findLiteralStatements]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of FindLiteralStatementsResult
	 */
	public static class FindLiteralStatementsResult {
			/**Value for the "namedGraphId" result value*/
			private long namedGraphId;
			/**Value for the "subject" result value*/
			private long subject;
			/**Value for the "predicate" result value*/
			private long predicate;
			/**Value for the "object" result value*/
			private long object;

		/**
		  *Get NamedGraphId value
		  *@return NamedGraphId value
		  */
			public long getNamedGraphId() {
				return this.namedGraphId;
			}

		/**
		  *Get Subject value
		  *@return Subject value
		  */
			public long getSubject() {
				return this.subject;
			}

		/**
		  *Get Predicate value
		  *@return Predicate value
		  */
			public long getPredicate() {
				return this.predicate;
			}

		/**
		  *Get Object value
		  *@return Object value
		  */
			public long getObject() {
				return this.object;
			}

	}



	/**
	 * Transformer that transforms the rows in the result set for the findLiteralStatementsLimited prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsLimitedResult> transformFindLiteralStatementsLimited = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsLimitedResult>(){
		public FindLiteralStatementsLimitedResult transform(java.sql.ResultSet rs) {

			
				FindLiteralStatementsLimitedResult result = new FindLiteralStatementsLimitedResult();
				try {
				result.namedGraphId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:namedGraphId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subj=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:subj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.prop=rs.getLong(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:prop",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.obj=rs.getLong(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:obj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the findLiteralStatementsLimited prepared statement.
	  * <code>
	 *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM(         SELECT ROW_NUMBER() OVER (ORDER BY NAMEDGRAPHID) AS ROWNUM,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855) AS FOO         WHERE ROWNUM > ? AND ROWNUM<= ?         
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param start template parameter
	 *@param end template parameter
	 *
	 *@param sessionPrefix template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsLimitedResult> findLiteralStatementsLimited (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long start, long end, String sessionPrefix) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsLimited, new String[] {sessionPrefix},connection); int argc = 1;
			ps.setLong(argc++, start);
			ps.setLong(argc++, end);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsLimitedResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsLimitedResult>(rs, ps, stmtProvider, transformFindLiteralStatementsLimited);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"findLiteralStatementsLimited",stmtProvider.getSqlString(findLiteralStatementsLimited) ,""+ "start="+(start) + "," +"end="+(end),""+ "sessionPrefix="+((sessionPrefix!=null)?sessionPrefix.toString():"null"));
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsLimited]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of FindLiteralStatementsLimitedResult
	 */
	public static class FindLiteralStatementsLimitedResult {
			/**Value for the "namedGraphId" result value*/
			private long namedGraphId;
			/**Value for the "subj" result value*/
			private long subj;
			/**Value for the "prop" result value*/
			private long prop;
			/**Value for the "obj" result value*/
			private long obj;

		/**
		  *Get NamedGraphId value
		  *@return NamedGraphId value
		  */
			public long getNamedGraphId() {
				return this.namedGraphId;
			}

		/**
		  *Get Subj value
		  *@return Subj value
		  */
			public long getSubj() {
				return this.subj;
			}

		/**
		  *Get Prop value
		  *@return Prop value
		  */
			public long getProp() {
				return this.prop;
			}

		/**
		  *Get Obj value
		  *@return Obj value
		  */
			public long getObj() {
				return this.obj;
			}

	}



	/**
	 * Transformer that transforms the rows in the result set for the findLiteralStatementsNRLimited prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRLimitedResult> transformFindLiteralStatementsNRLimited = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRLimitedResult>(){
		public FindLiteralStatementsNRLimitedResult transform(java.sql.ResultSet rs) {

			
				FindLiteralStatementsNRLimitedResult result = new FindLiteralStatementsNRLimitedResult();
				try {
				result.namedGraphId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:namedGraphId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subj=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:subj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.prop=rs.getLong(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:prop",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.obj=rs.getLong(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:obj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the findLiteralStatementsNRLimited prepared statement.
	  * <code>
	 *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM(         SELECT ROW_NUMBER() OVER (ORDER BY NAMEDGRAPHID) AS ROWNUM,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855) AS FOO         WHERE ROWNUM > ? AND ROWNUM<= ?                  
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param start template parameter
	 *@param end template parameter
	 *
	 *@param sessionPrefix template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRLimitedResult> findLiteralStatementsNRLimited (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long start, long end, String sessionPrefix) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsNRLimited, new String[] {sessionPrefix},connection); int argc = 1;
			ps.setLong(argc++, start);
			ps.setLong(argc++, end);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRLimitedResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsNRLimitedResult>(rs, ps, stmtProvider, transformFindLiteralStatementsNRLimited);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"findLiteralStatementsNRLimited",stmtProvider.getSqlString(findLiteralStatementsNRLimited) ,""+ "start="+(start) + "," +"end="+(end),""+ "sessionPrefix="+((sessionPrefix!=null)?sessionPrefix.toString():"null"));
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsNRLimited]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of FindLiteralStatementsNRLimitedResult
	 */
	public static class FindLiteralStatementsNRLimitedResult {
			/**Value for the "namedGraphId" result value*/
			private long namedGraphId;
			/**Value for the "subj" result value*/
			private long subj;
			/**Value for the "prop" result value*/
			private long prop;
			/**Value for the "obj" result value*/
			private long obj;

		/**
		  *Get NamedGraphId value
		  *@return NamedGraphId value
		  */
			public long getNamedGraphId() {
				return this.namedGraphId;
			}

		/**
		  *Get Subj value
		  *@return Subj value
		  */
			public long getSubj() {
				return this.subj;
			}

		/**
		  *Get Prop value
		  *@return Prop value
		  */
			public long getProp() {
				return this.prop;
			}

		/**
		  *Get Obj value
		  *@return Obj value
		  */
			public long getObj() {
				return this.obj;
			}

	}



	/**
	 * Transformer that transforms the rows in the result set for the findLiteralStatementsLimitOffset prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsLimitOffsetResult> transformFindLiteralStatementsLimitOffset = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsLimitOffsetResult>(){
		public FindLiteralStatementsLimitOffsetResult transform(java.sql.ResultSet rs) {

			
				FindLiteralStatementsLimitOffsetResult result = new FindLiteralStatementsLimitOffsetResult();
				try {
				result.namedGraphId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:namedGraphId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subj=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:subj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.prop=rs.getLong(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:prop",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.obj=rs.getLong(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:obj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the findLiteralStatementsLimitOffset prepared statement.
	  * <code>
	 *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855         ORDER BY NAMEDGRAPHID ASC         LIMIT ? OFFSET ?         
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param start template parameter
	 *@param end template parameter
	 *
	 *@param sessionPrefix template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsLimitOffsetResult> findLiteralStatementsLimitOffset (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long start, long end, String sessionPrefix) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsLimitOffset, new String[] {sessionPrefix},connection); int argc = 1;
			ps.setLong(argc++, start);
			ps.setLong(argc++, end);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsLimitOffsetResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsLimitOffsetResult>(rs, ps, stmtProvider, transformFindLiteralStatementsLimitOffset);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"findLiteralStatementsLimitOffset",stmtProvider.getSqlString(findLiteralStatementsLimitOffset) ,""+ "start="+(start) + "," +"end="+(end),""+ "sessionPrefix="+((sessionPrefix!=null)?sessionPrefix.toString():"null"));
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsLimitOffset]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of FindLiteralStatementsLimitOffsetResult
	 */
	public static class FindLiteralStatementsLimitOffsetResult {
			/**Value for the "namedGraphId" result value*/
			private long namedGraphId;
			/**Value for the "subj" result value*/
			private long subj;
			/**Value for the "prop" result value*/
			private long prop;
			/**Value for the "obj" result value*/
			private long obj;

		/**
		  *Get NamedGraphId value
		  *@return NamedGraphId value
		  */
			public long getNamedGraphId() {
				return this.namedGraphId;
			}

		/**
		  *Get Subj value
		  *@return Subj value
		  */
			public long getSubj() {
				return this.subj;
			}

		/**
		  *Get Prop value
		  *@return Prop value
		  */
			public long getProp() {
				return this.prop;
			}

		/**
		  *Get Obj value
		  *@return Obj value
		  */
			public long getObj() {
				return this.obj;
			}

	}



	/**
	 * Transformer that transforms the rows in the result set for the findLiteralStatementsNRLimitOffset prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRLimitOffsetResult> transformFindLiteralStatementsNRLimitOffset = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRLimitOffsetResult>(){
		public FindLiteralStatementsNRLimitOffsetResult transform(java.sql.ResultSet rs) {

			
				FindLiteralStatementsNRLimitOffsetResult result = new FindLiteralStatementsNRLimitOffsetResult();
				try {
				result.namedGraphId=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:namedGraphId",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subj=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:subj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.prop=rs.getLong(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:prop",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.obj=rs.getLong(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:obj",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the findLiteralStatementsNRLimitOffset prepared statement.
	  * <code>
	 *          SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT         FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855         ORDER BY NAMEDGRAPHID ASC         LIMIT ? OFFSET ?         
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param start template parameter
	 *@param end template parameter
	 *
	 *@param sessionPrefix template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRLimitOffsetResult> findLiteralStatementsNRLimitOffset (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long start, long end, String sessionPrefix) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsNRLimitOffset, new String[] {sessionPrefix},connection); int argc = 1;
			ps.setLong(argc++, start);
			ps.setLong(argc++, end);
			java.sql.ResultSet rs = null;
				try{
					rs = ps.executeQuery();
				}catch(java.sql.SQLException sqle){
					if(sqle.getErrorCode()==1205){
						int retries=0;
						while(retries<5){
							try {
	                        	Thread.sleep(5000);
	                        }catch(InterruptedException ie) {
	                            throw sqle;
	                        }
							try{			
								rs = ps.executeQuery();
								break;
							}catch(java.sql.SQLException sqleInner){
								if(sqleInner.getErrorCode()==1205){
									retries++;
								}else{
									throw sqleInner;
								}
							}
						}
						if(retries>=5){
							throw sqle;
						}
					}else{
						throw sqle;
					}
				}

			org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRLimitOffsetResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsNRLimitOffsetResult>(rs, ps, stmtProvider, transformFindLiteralStatementsNRLimitOffset);
			return iter;

		} catch (java.sql.SQLException e) {
			throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL,e,"findLiteralStatementsNRLimitOffset",stmtProvider.getSqlString(findLiteralStatementsNRLimitOffset) ,""+ "start="+(start) + "," +"end="+(end),""+ "sessionPrefix="+((sessionPrefix!=null)?sessionPrefix.toString():"null"));
		} finally {
			//long endtimer=(System.currentTimeMillis()-startTimer);
			//if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsNRLimitOffset]"+endtimer);
		}
	}


	
	/**
	 *Default implementation of FindLiteralStatementsNRLimitOffsetResult
	 */
	public static class FindLiteralStatementsNRLimitOffsetResult {
			/**Value for the "namedGraphId" result value*/
			private long namedGraphId;
			/**Value for the "subj" result value*/
			private long subj;
			/**Value for the "prop" result value*/
			private long prop;
			/**Value for the "obj" result value*/
			private long obj;

		/**
		  *Get NamedGraphId value
		  *@return NamedGraphId value
		  */
			public long getNamedGraphId() {
				return this.namedGraphId;
			}

		/**
		  *Get Subj value
		  *@return Subj value
		  */
			public long getSubj() {
				return this.subj;
			}

		/**
		  *Get Prop value
		  *@return Prop value
		  */
			public long getProp() {
				return this.prop;
			}

		/**
		  *Get Obj value
		  *@return Obj value
		  */
			public long getObj() {
				return this.obj;
			}

	}

}