TransactionSQL.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.jdbc.container.sql;
// allow for all types that can be returned from a resultset

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

	/**
	  *Constant "insertNotificationStatementAdd" used to reference prepared statement  transaction.insertNotificationStatementAdd
	  *
	  * <code>
	  *  		INSERT INTO {0} (METADATA,NAMEDGRAPHID,SUBJ,PROP,OBJ,NS,NE) VALUES(?,?,?,?,?,1,0) 	
	  * </code>
	  */
	public static final String insertNotificationStatementAdd = "transaction.insertNotificationStatementAdd";

	/**
	  *Constant "insertNotificationStatementDel" used to reference prepared statement  transaction.insertNotificationStatementDel
	  *
	  * <code>
	  *  		INSERT INTO {0} (METADATA,NAMEDGRAPHID,SUBJ,PROP,OBJ,NS,NE) VALUES(?,?,?,?,?,0,1) 	
	  * </code>
	  */
	public static final String insertNotificationStatementDel = "transaction.insertNotificationStatementDel";

	/**
	  *Constant "updateNotificationStatementAdd" used to reference prepared statement  transaction.updateNotificationStatementAdd
	  *
	  * <code>
	  *  		UPDATE {0} SET NS=1,NE=0 WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND (TS_ID IS NOT NULL OR TE_ID IS NOT NULL )  	
	  * </code>
	  */
	public static final String updateNotificationStatementAdd = "transaction.updateNotificationStatementAdd";

	/**
	  *Constant "updateNotificationStatementDel" used to reference prepared statement  transaction.updateNotificationStatementDel
	  *
	  * <code>
	  *  		UPDATE {0} SET NS=0,NE=1 WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND (TS_ID IS NOT NULL OR TE_ID IS NOT NULL )  	
	  * </code>
	  */
	public static final String updateNotificationStatementDel = "transaction.updateNotificationStatementDel";

	/**
	  *Constant "purgeCommitedStatements" used to reference prepared statement  transaction.purgeCommitedStatements
	  *
	  * <code>
	  *  		DELETE FROM  {0}_ST WHERE (TS_ID IS NOT NULL AND TS_ID=?) OR (TE_ID IS NOT NULL AND TE_ID=?) 	
	  * </code>
	  */
	public static final String purgeCommitedStatements = "transaction.purgeCommitedStatements";

	/**
	  *Constant "purgeNotificationStatements" used to reference prepared statement  transaction.purgeNotificationStatements
	  *
	  * <code>
	  *  		DELETE FROM  {0} WHERE TS_ID IS NULL AND TE_ID IS NULL AND (NS=1 OR NE=1) 	
	  * </code>
	  */
	public static final String purgeNotificationStatements = "transaction.purgeNotificationStatements";

	/**
	  *Constant "updateStatementAdd" used to reference prepared statement  transaction.updateStatementAdd
	  *
	  * <code>
	  *  		UPDATE {0} SET NS=0,NE=0,TS_ID=NULL,TE_ID=NULL,CS_ID=NULL,TE_ID=NULL WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND (TS_ID IS NULL OR TS_ID<?) AND (TE_ID IS NULL OR TE_ID<?)  	
	  * </code>
	  */
	public static final String updateStatementAdd = "transaction.updateStatementAdd";

	/**
	  *Constant "updateStatementDel" used to reference prepared statement  transaction.updateStatementDel
	  *
	  * <code>
	  *  		DELETE FROM  {0} WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND (TS_ID IS NULL OR TS_ID<?) AND (TE_ID IS NULL OR TE_ID<?)  	
	  * </code>
	  */
	public static final String updateStatementDel = "transaction.updateStatementDel";

	/**
	  *Constant "insertCommandStatementAdd" used to reference prepared statement  transaction.insertCommandStatementAdd
	  *
	  * <code>
	  *  		INSERT INTO {0}_ST (METADATA,NAMEDGRAPHID,SUBJ,PROP,OBJ,TS_ID,CS_ID) VALUES(?,?,?,?,?,?,?) 	
	  * </code>
	  */
	public static final String insertCommandStatementAdd = "transaction.insertCommandStatementAdd";

	/**
	  *Constant "insertCommandStatementDel" used to reference prepared statement  transaction.insertCommandStatementDel
	  *
	  * <code>
	  *  		INSERT INTO {0}_ST (METADATA,NAMEDGRAPHID,SUBJ,PROP,OBJ,TE_ID,CE_ID) VALUES(?,?,?,?,?,?,?) 	
	  * </code>
	  */
	public static final String insertCommandStatementDel = "transaction.insertCommandStatementDel";

	/**
	  *Constant "updateTransactionStatementDel" used to reference prepared statement  transaction.updateTransactionStatementDel
	  *
	  * <code>
	  *  		UPDATE {0} SET TE_ID=?,CE_ID=? WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND TE_ID  IS NULL 	
	  * </code>
	  */
	public static final String updateTransactionStatementDel = "transaction.updateTransactionStatementDel";

	/**
	  *Constant "updateTransactionStatementAdd" used to reference prepared statement  transaction.updateTransactionStatementAdd
	  *
	  * <code>
	  *  		UPDATE {0} SET TS_ID=?,CS_ID=? WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND TS_ID IS NULL and TE_ID IS NULL AND CS_ID IS NULL AND CE_ID IS NULL 	
	  * </code>
	  */
	public static final String updateTransactionStatementAdd = "transaction.updateTransactionStatementAdd";

	/**
	  *Constant "selectAdditions" used to reference prepared statement  transaction.selectAdditions
	  *
	  * <code>
	  *  		SELECT ST.METADATA,ST.NAMEDGRAPHID,ST.subj,ST.prop,ST.obj FROM {0}_ST ST where ST.ts_id =? AND ST.cs_id=? 	
	  * </code>
	  */
	public static final String selectAdditions = "transaction.selectAdditions";

	/**
	  *Constant "selectDeletions" used to reference prepared statement  transaction.selectDeletions
	  *
	  * <code>
	  *  		SELECT ST.METADATA,ST.NAMEDGRAPHID,ST.subj,ST.prop,ST.obj FROM {0}_ST ST where ST.te_id =? AND ST.ce_id=? 	
	  * </code>
	  */
	public static final String selectDeletions = "transaction.selectDeletions";

	/**
	  *Constant "udpateChangeset" used to reference prepared statement  transaction.udpateChangeset
	  *
	  * <code>
	  *  		UPDATE {0} SET ADDGRAPH=?,REMOVEGRAPH=? ,METAADDGRAPH=?,METAREMOVEGRAPH=? WHERE ID=? 	
	  * </code>
	  */
	public static final String udpateChangeset = "transaction.udpateChangeset";

	/**
	  *Constant "insertChangeset" used to reference prepared statement  transaction.insertChangeset
	  *
	  * <code>
	  *  		INSERT INTO {0} (commandId, addGraph,removeGraph,metaddgraph,metaremovegraph,namedGraphUri) VALUES (?, ?, ?, ?,?,?) 	
	  * </code>
	  */
	public static final String insertChangeset = "transaction.insertChangeset";

	/**
	  *Constant "selectMaxChangesetId" used to reference prepared statement  transaction.selectMaxChangesetId
	  *
	  * <code>
	  *  		SELECT MAX(id) FROM {0} 	
	  * </code>
	  */
	public static final String selectMaxChangesetId = "transaction.selectMaxChangesetId";

	/**
	  *Constant "deleteChangeset" used to reference prepared statement  transaction.deleteChangeset
	  *
	  * <code>
	  *  		DELETE FROM {0} WHERE COMMANDID = ? AND ID = ? 	
	  * </code>
	  */
	public static final String deleteChangeset = "transaction.deleteChangeset";

	/**
	  *Constant "selectChangeset" used to reference prepared statement  transaction.selectChangeset
	  *
	  * <code>
	  *  		SELECT ID,ADDGRAPH,REMOVEGRAPH,METAADDGRAPH,METAREMOVEGRAPH,NAMEDGRAPHURI FROM {0} WHERE COMMANDID = ? ORDER BY ID 	
	  * </code>
	  */
	public static final String selectChangeset = "transaction.selectChangeset";

	/**
	  *Constant "updateCommand" used to reference prepared statement  transaction.updateCommand
	  *
	  * <code>
	  *  		UPDATE {0} set transactionId=?,commandType=?,context=?,preReq=? where id=? 	
	  * </code>
	  */
	public static final String updateCommand = "transaction.updateCommand";

	/**
	  *Constant "insertCommand" used to reference prepared statement  transaction.insertCommand
	  *
	  * <code>
	  *  		INSERT INTO {0} (transactionId, commandType,context,prereq) VALUES (?, ?, ?, ?) 	
	  * </code>
	  */
	public static final String insertCommand = "transaction.insertCommand";

	/**
	  *Constant "deleteCommand" used to reference prepared statement  transaction.deleteCommand
	  *
	  * <code>
	  *  		DELETE FROM {0} WHERE TRANSACTIONID = ? AND ID = ? 	
	  * </code>
	  */
	public static final String deleteCommand = "transaction.deleteCommand";

	/**
	  *Constant "deleteTransaction" used to reference prepared statement  transaction.deleteTransaction
	  *
	  * <code>
	  *  		DELETE FROM {0} WHERE ID = ? 	
	  * </code>
	  */
	public static final String deleteTransaction = "transaction.deleteTransaction";

	/**
	  *Constant "selectCommand" used to reference prepared statement  transaction.selectCommand
	  *
	  * <code>
	  *  		SELECT ID,COMMANDTYPE,PREREQ,CONTEXT FROM {0} WHERE TRANSACTIONID = ? ORDER BY ID 	
	  * </code>
	  */
	public static final String selectCommand = "transaction.selectCommand";

	/**
	  *Constant "insertTransaction" used to reference prepared statement  transaction.insertTransaction
	  *
	  * <code>
	  *  		INSERT INTO {0} (CREATED) VALUES (?) 	
	  * </code>
	  */
	public static final String insertTransaction = "transaction.insertTransaction";

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

	/**
	  *Constant "selectTransactions" used to reference prepared statement  transaction.selectTransactions
	  *
	  * <code>
	  *  	   SELECT ID FROM {0} ORDER BY ID 	
	  * </code>
	  */
	public static final String selectTransactions = "transaction.selectTransactions";



	
	/**
	 * Runs the insertNotificationStatementAdd prepared statement.
	  * <code>
	 *  		INSERT INTO {0} (METADATA,NAMEDGRAPHID,SUBJ,PROP,OBJ,NS,NE) VALUES(?,?,?,?,?,1,0) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int insertNotificationStatementAdd (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertNotificationStatementAdd, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
				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,"insertNotificationStatementAdd",stmtProvider.getSqlString(insertNotificationStatementAdd) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[insertNotificationStatementAdd]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertNotificationStatementAdd prepared statement
	 */
	public static class BatchInsertNotificationStatementAdd extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertNotificationStatementAdd prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertNotificationStatementAdd(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertNotificationStatementAdd,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the insertNotificationStatementAdd prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
				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 insertNotificationStatementDel prepared statement.
	  * <code>
	 *  		INSERT INTO {0} (METADATA,NAMEDGRAPHID,SUBJ,PROP,OBJ,NS,NE) VALUES(?,?,?,?,?,0,1) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int insertNotificationStatementDel (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertNotificationStatementDel, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
				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,"insertNotificationStatementDel",stmtProvider.getSqlString(insertNotificationStatementDel) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[insertNotificationStatementDel]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertNotificationStatementDel prepared statement
	 */
	public static class BatchInsertNotificationStatementDel extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertNotificationStatementDel prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertNotificationStatementDel(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertNotificationStatementDel,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the insertNotificationStatementDel prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
				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 updateNotificationStatementAdd prepared statement.
	  * <code>
	 *  		UPDATE {0} SET NS=1,NE=0 WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND (TS_ID IS NOT NULL OR TE_ID IS NOT NULL )  	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int updateNotificationStatementAdd (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(updateNotificationStatementAdd, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
				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,"updateNotificationStatementAdd",stmtProvider.getSqlString(updateNotificationStatementAdd) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[updateNotificationStatementAdd]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the UpdateNotificationStatementAdd prepared statement
	 */
	public static class BatchUpdateNotificationStatementAdd extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the UpdateNotificationStatementAdd prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchUpdateNotificationStatementAdd(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,updateNotificationStatementAdd,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the updateNotificationStatementAdd prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
				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 updateNotificationStatementDel prepared statement.
	  * <code>
	 *  		UPDATE {0} SET NS=0,NE=1 WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND (TS_ID IS NOT NULL OR TE_ID IS NOT NULL )  	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int updateNotificationStatementDel (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(updateNotificationStatementDel, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
				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,"updateNotificationStatementDel",stmtProvider.getSqlString(updateNotificationStatementDel) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[updateNotificationStatementDel]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the UpdateNotificationStatementDel prepared statement
	 */
	public static class BatchUpdateNotificationStatementDel extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the UpdateNotificationStatementDel prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchUpdateNotificationStatementDel(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,updateNotificationStatementDel,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the updateNotificationStatementDel prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
				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 purgeCommitedStatements prepared statement.
	  * <code>
	 *  		DELETE FROM  {0}_ST WHERE (TS_ID IS NOT NULL AND TS_ID=?) OR (TE_ID IS NOT NULL AND TE_ID=?) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param lastTransaction template parameter
	 *@param lastTransaction2 template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int purgeCommitedStatements (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long lastTransaction, long lastTransaction2, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(purgeCommitedStatements, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, lastTransaction);
			ps.setLong(argc++, lastTransaction2);
				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,"purgeCommitedStatements",stmtProvider.getSqlString(purgeCommitedStatements) ,""+ "lastTransaction="+(lastTransaction) + "," +"lastTransaction2="+(lastTransaction2),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[purgeCommitedStatements]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the PurgeCommitedStatements prepared statement
	 */
	public static class BatchPurgeCommitedStatements extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the PurgeCommitedStatements prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchPurgeCommitedStatements(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,purgeCommitedStatements,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the purgeCommitedStatements prepared statement.
		 *
	 *@param lastTransaction template parameter
	 *@param lastTransaction2 template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (long lastTransaction, long lastTransaction2) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setLong(argc++, lastTransaction);
			ps.setLong(argc++, lastTransaction2);
				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 purgeNotificationStatements prepared statement.
	  * <code>
	 *  		DELETE FROM  {0} WHERE TS_ID IS NULL AND TE_ID IS NULL AND (NS=1 OR NE=1) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int purgeNotificationStatements (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(purgeNotificationStatements, new String[] {transactionTableName},connection);
				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,"purgeNotificationStatements",stmtProvider.getSqlString(purgeNotificationStatements) ,"",""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[purgeNotificationStatements]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the PurgeNotificationStatements prepared statement
	 */
	public static class BatchPurgeNotificationStatements extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the PurgeNotificationStatements prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchPurgeNotificationStatements(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,purgeNotificationStatements,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the purgeNotificationStatements prepared statement.
		 *
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry () throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters();
				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 updateStatementAdd prepared statement.
	  * <code>
	 *  		UPDATE {0} SET NS=0,NE=0,TS_ID=NULL,TE_ID=NULL,CS_ID=NULL,TE_ID=NULL WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND (TS_ID IS NULL OR TS_ID<?) AND (TE_ID IS NULL OR TE_ID<?)  	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param lastTransaction template parameter
	 *@param lastTransaction2 template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int updateStatementAdd (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, long lastTransaction, long lastTransaction2, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(updateStatementAdd, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, lastTransaction);
			ps.setLong(argc++, lastTransaction2);
				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,"updateStatementAdd",stmtProvider.getSqlString(updateStatementAdd) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj) + "," +"lastTransaction="+(lastTransaction) + "," +"lastTransaction2="+(lastTransaction2),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[updateStatementAdd]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the UpdateStatementAdd prepared statement
	 */
	public static class BatchUpdateStatementAdd extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the UpdateStatementAdd prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchUpdateStatementAdd(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,updateStatementAdd,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the updateStatementAdd prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param lastTransaction template parameter
	 *@param lastTransaction2 template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj, long lastTransaction, long lastTransaction2) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, lastTransaction);
			ps.setLong(argc++, lastTransaction2);
				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 updateStatementDel prepared statement.
	  * <code>
	 *  		DELETE FROM  {0} WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND (TS_ID IS NULL OR TS_ID<?) AND (TE_ID IS NULL OR TE_ID<?)  	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param lastTransaction template parameter
	 *@param lastTransaction2 template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int updateStatementDel (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, long lastTransaction, long lastTransaction2, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(updateStatementDel, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, lastTransaction);
			ps.setLong(argc++, lastTransaction2);
				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,"updateStatementDel",stmtProvider.getSqlString(updateStatementDel) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj) + "," +"lastTransaction="+(lastTransaction) + "," +"lastTransaction2="+(lastTransaction2),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[updateStatementDel]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the UpdateStatementDel prepared statement
	 */
	public static class BatchUpdateStatementDel extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the UpdateStatementDel prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchUpdateStatementDel(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,updateStatementDel,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the updateStatementDel prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param lastTransaction template parameter
	 *@param lastTransaction2 template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj, long lastTransaction, long lastTransaction2) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, lastTransaction);
			ps.setLong(argc++, lastTransaction2);
				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 insertCommandStatementAdd prepared statement.
	  * <code>
	 *  		INSERT INTO {0}_ST (METADATA,NAMEDGRAPHID,SUBJ,PROP,OBJ,TS_ID,CS_ID) VALUES(?,?,?,?,?,?,?) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param transId template parameter
	 *@param commandId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int insertCommandStatementAdd (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, long transId, long commandId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertCommandStatementAdd, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, transId);
			ps.setLong(argc++, commandId);
				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,"insertCommandStatementAdd",stmtProvider.getSqlString(insertCommandStatementAdd) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj) + "," +"transId="+(transId) + "," +"commandId="+(commandId),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[insertCommandStatementAdd]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertCommandStatementAdd prepared statement
	 */
	public static class BatchInsertCommandStatementAdd extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertCommandStatementAdd prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertCommandStatementAdd(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertCommandStatementAdd,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the insertCommandStatementAdd prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param transId template parameter
	 *@param commandId template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj, long transId, long commandId) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, transId);
			ps.setLong(argc++, commandId);
				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 insertCommandStatementDel prepared statement.
	  * <code>
	 *  		INSERT INTO {0}_ST (METADATA,NAMEDGRAPHID,SUBJ,PROP,OBJ,TE_ID,CE_ID) VALUES(?,?,?,?,?,?,?) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param transId template parameter
	 *@param commandId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int insertCommandStatementDel (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, long transId, long commandId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertCommandStatementDel, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, transId);
			ps.setLong(argc++, commandId);
				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,"insertCommandStatementDel",stmtProvider.getSqlString(insertCommandStatementDel) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj) + "," +"transId="+(transId) + "," +"commandId="+(commandId),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[insertCommandStatementDel]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertCommandStatementDel prepared statement
	 */
	public static class BatchInsertCommandStatementDel extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertCommandStatementDel prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertCommandStatementDel(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertCommandStatementDel,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the insertCommandStatementDel prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param transId template parameter
	 *@param commandId template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj, long transId, long commandId) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, transId);
			ps.setLong(argc++, commandId);
				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 updateTransactionStatementDel prepared statement.
	  * <code>
	 *  		UPDATE {0} SET TE_ID=?,CE_ID=? WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND TE_ID  IS NULL 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param transactionId template parameter
	 *@param commandId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int updateTransactionStatementDel (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, long transactionId, long commandId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(updateTransactionStatementDel, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, transactionId);
			ps.setLong(argc++, commandId);
				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,"updateTransactionStatementDel",stmtProvider.getSqlString(updateTransactionStatementDel) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj) + "," +"transactionId="+(transactionId) + "," +"commandId="+(commandId),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[updateTransactionStatementDel]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the UpdateTransactionStatementDel prepared statement
	 */
	public static class BatchUpdateTransactionStatementDel extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the UpdateTransactionStatementDel prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchUpdateTransactionStatementDel(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,updateTransactionStatementDel,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the updateTransactionStatementDel prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param transactionId template parameter
	 *@param commandId template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj, long transactionId, long commandId) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, transactionId);
			ps.setLong(argc++, commandId);
				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 updateTransactionStatementAdd prepared statement.
	  * <code>
	 *  		UPDATE {0} SET TS_ID=?,CS_ID=? WHERE METADATA=? AND NAMEDGRAPHID=? AND SUBJ=? AND PROP=? AND OBJ=? AND TS_ID IS NULL and TE_ID IS NULL AND CS_ID IS NULL AND CE_ID IS NULL 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param transactionId template parameter
	 *@param commandId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int updateTransactionStatementAdd (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, int metadata, long namedgraphid, long subj, long prop, long obj, long transactionId, long commandId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(updateTransactionStatementAdd, new String[] {transactionTableName},connection); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, transactionId);
			ps.setLong(argc++, commandId);
				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,"updateTransactionStatementAdd",stmtProvider.getSqlString(updateTransactionStatementAdd) ,""+ "metadata="+(metadata) + "," +"namedgraphid="+(namedgraphid) + "," +"subj="+(subj) + "," +"prop="+(prop) + "," +"obj="+(obj) + "," +"transactionId="+(transactionId) + "," +"commandId="+(commandId),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[updateTransactionStatementAdd]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the UpdateTransactionStatementAdd prepared statement
	 */
	public static class BatchUpdateTransactionStatementAdd extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the UpdateTransactionStatementAdd prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchUpdateTransactionStatementAdd(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,updateTransactionStatementAdd,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the updateTransactionStatementAdd prepared statement.
		 *
	 *@param metadata template parameter
	 *@param namedgraphid template parameter
	 *@param subj template parameter
	 *@param prop template parameter
	 *@param obj template parameter
	 *@param transactionId template parameter
	 *@param commandId template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (int metadata, long namedgraphid, long subj, long prop, long obj, long transactionId, long commandId) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setInt(argc++, metadata);
			ps.setLong(argc++, namedgraphid);
			ps.setLong(argc++, subj);
			ps.setLong(argc++, prop);
			ps.setLong(argc++, obj);
			ps.setLong(argc++, transactionId);
			ps.setLong(argc++, commandId);
				ps.addBatch();
			}catch(java.sql.SQLException sqle){
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle);
			}
		}
	}




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

			
				SelectAdditionsResult result = new SelectAdditionsResult();
				try {
				result.metadata=rs.getInt(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:metadata",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.ng=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:ng",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subj=rs.getLong(3);
				} 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(4);
				} 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(5);
				} 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 selectAdditions prepared statement.
	  * <code>
	 *  		SELECT ST.METADATA,ST.NAMEDGRAPHID,ST.subj,ST.prop,ST.obj FROM {0}_ST ST where ST.ts_id =? AND ST.cs_id=? 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param transactionId template parameter
	 *@param commandId2 template parameter
	 *
	 *@param containerName template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<SelectAdditionsResult> selectAdditions (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long transactionId, long commandId2, String containerName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(selectAdditions, new String[] {containerName},connection); int argc = 1;
			ps.setLong(argc++, transactionId);
			ps.setLong(argc++, commandId2);
			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<SelectAdditionsResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectAdditionsResult>(rs, ps, stmtProvider, transformSelectAdditions);
			return iter;

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


	
	/**
	 *Default implementation of SelectAdditionsResult
	 */
	public static class SelectAdditionsResult {
			/**Value for the "metadata" result value*/
			private int metadata;
			/**Value for the "ng" result value*/
			private long ng;
			/**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 Metadata value
		  *@return Metadata value
		  */
			public int getMetadata() {
				return this.metadata;
			}

		/**
		  *Get Ng value
		  *@return Ng value
		  */
			public long getNg() {
				return this.ng;
			}

		/**
		  *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 selectDeletions prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<SelectDeletionsResult> transformSelectDeletions = new org.openanzo.jdbc.utils.Transformer<SelectDeletionsResult>(){
		public SelectDeletionsResult transform(java.sql.ResultSet rs) {

			
				SelectDeletionsResult result = new SelectDeletionsResult();
				try {
				result.metadata=rs.getInt(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:metadata",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.ng=rs.getLong(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:ng",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.subj=rs.getLong(3);
				} 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(4);
				} 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(5);
				} 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 selectDeletions prepared statement.
	  * <code>
	 *  		SELECT ST.METADATA,ST.NAMEDGRAPHID,ST.subj,ST.prop,ST.obj FROM {0}_ST ST where ST.te_id =? AND ST.ce_id=? 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param transactionId template parameter
	 *@param commandId template parameter
	 *
	 *@param containerName template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<SelectDeletionsResult> selectDeletions (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long transactionId, long commandId, String containerName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(selectDeletions, new String[] {containerName},connection); int argc = 1;
			ps.setLong(argc++, transactionId);
			ps.setLong(argc++, commandId);
			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<SelectDeletionsResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectDeletionsResult>(rs, ps, stmtProvider, transformSelectDeletions);
			return iter;

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


	
	/**
	 *Default implementation of SelectDeletionsResult
	 */
	public static class SelectDeletionsResult {
			/**Value for the "metadata" result value*/
			private int metadata;
			/**Value for the "ng" result value*/
			private long ng;
			/**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 Metadata value
		  *@return Metadata value
		  */
			public int getMetadata() {
				return this.metadata;
			}

		/**
		  *Get Ng value
		  *@return Ng value
		  */
			public long getNg() {
				return this.ng;
			}

		/**
		  *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;
			}

	}



	
	/**
	 * Runs the udpateChangeset prepared statement.
	  * <code>
	 *  		UPDATE {0} SET ADDGRAPH=?,REMOVEGRAPH=? ,METAADDGRAPH=?,METAREMOVEGRAPH=? WHERE ID=? 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param addGraph template parameter
	 *@param removeGraph template parameter
	 *@param addMetaGraph template parameter
	 *@param removeMetaGraph template parameter
	 *@param id template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int udpateChangeset (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, java.sql.Clob addGraph, java.sql.Clob removeGraph, java.sql.Clob addMetaGraph, java.sql.Clob removeMetaGraph, long id, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(udpateChangeset, new String[] {transactionTableName},connection); int argc = 1;
			if(addGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, addGraph);
			}
			if(removeGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, removeGraph);
			}
			if(addMetaGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, addMetaGraph);
			}
			if(removeMetaGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, removeMetaGraph);
			}
			ps.setLong(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,"udpateChangeset",stmtProvider.getSqlString(udpateChangeset) ,""+ "addGraph="+((addGraph!=null)?addGraph.toString():"null") + "," +"removeGraph="+((removeGraph!=null)?removeGraph.toString():"null") + "," +"addMetaGraph="+((addMetaGraph!=null)?addMetaGraph.toString():"null") + "," +"removeMetaGraph="+((removeMetaGraph!=null)?removeMetaGraph.toString():"null") + "," +"id="+(id),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[udpateChangeset]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the UdpateChangeset prepared statement
	 */
	public static class BatchUdpateChangeset extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the UdpateChangeset prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchUdpateChangeset(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,udpateChangeset,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the udpateChangeset prepared statement.
		 *
	 *@param addGraph template parameter
	 *@param removeGraph template parameter
	 *@param addMetaGraph template parameter
	 *@param removeMetaGraph template parameter
	 *@param id template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (java.sql.Clob addGraph, java.sql.Clob removeGraph, java.sql.Clob addMetaGraph, java.sql.Clob removeMetaGraph, long id) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			if(addGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, addGraph);
			}
			if(removeGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, removeGraph);
			}
			if(addMetaGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, addMetaGraph);
			}
			if(removeMetaGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, removeMetaGraph);
			}
			ps.setLong(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 insertChangeset prepared statement.
	  * <code>
	 *  		INSERT INTO {0} (commandId, addGraph,removeGraph,metaddgraph,metaremovegraph,namedGraphUri) VALUES (?, ?, ?, ?,?,?) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param commandId template parameter
	 *@param addGraph template parameter
	 *@param removeGraph template parameter
	 *@param addMetaGraph template parameter
	 *@param removeMetaGraph template parameter
	 *@param uri template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int insertChangeset (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long commandId, java.sql.Clob addGraph, java.sql.Clob removeGraph, java.sql.Clob addMetaGraph, java.sql.Clob removeMetaGraph, String uri, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertChangeset, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, commandId);
			if(addGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, addGraph);
			}
			if(removeGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, removeGraph);
			}
			if(addMetaGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, addMetaGraph);
			}
			if(removeMetaGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, removeMetaGraph);
			}
			if(uri == null) {
				ps.setNull(argc++, java.sql.Types.VARCHAR);
			} else {
				ps.setString(argc++, uri);
			}
				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,"insertChangeset",stmtProvider.getSqlString(insertChangeset) ,""+ "commandId="+(commandId) + "," +"addGraph="+((addGraph!=null)?addGraph.toString():"null") + "," +"removeGraph="+((removeGraph!=null)?removeGraph.toString():"null") + "," +"addMetaGraph="+((addMetaGraph!=null)?addMetaGraph.toString():"null") + "," +"removeMetaGraph="+((removeMetaGraph!=null)?removeMetaGraph.toString():"null") + "," +"uri="+((uri!=null)?uri.toString():"null"),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[insertChangeset]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertChangeset prepared statement
	 */
	public static class BatchInsertChangeset extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertChangeset prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertChangeset(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertChangeset,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the insertChangeset prepared statement.
		 *
	 *@param commandId template parameter
	 *@param addGraph template parameter
	 *@param removeGraph template parameter
	 *@param addMetaGraph template parameter
	 *@param removeMetaGraph template parameter
	 *@param uri template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (long commandId, java.sql.Clob addGraph, java.sql.Clob removeGraph, java.sql.Clob addMetaGraph, java.sql.Clob removeMetaGraph, String uri) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setLong(argc++, commandId);
			if(addGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, addGraph);
			}
			if(removeGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, removeGraph);
			}
			if(addMetaGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, addMetaGraph);
			}
			if(removeMetaGraph == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, removeMetaGraph);
			}
			if(uri == null) {
				ps.setNull(argc++, java.sql.Types.VARCHAR);
			} else {
				ps.setString(argc++, uri);
			}
				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 selectMaxChangesetId prepared statement.
	  * <code>
	 *  		SELECT MAX(id) FROM {0} 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *
	 *@param transactionTableName template parameter
	 *@return  Long
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static Long selectMaxChangesetId (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(selectMaxChangesetId, new String[] {transactionTableName},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;				 
				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,"selectMaxChangesetId",stmtProvider.getSqlString(selectMaxChangesetId) ,"",""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[selectMaxChangesetId]"+endtimer);
		}
	}




	
	/**
	 * Runs the deleteChangeset prepared statement.
	  * <code>
	 *  		DELETE FROM {0} WHERE COMMANDID = ? AND ID = ? 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param cmdId template parameter
	 *@param csId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int deleteChangeset (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long cmdId, long csId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(deleteChangeset, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, cmdId);
			ps.setLong(argc++, csId);
				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,"deleteChangeset",stmtProvider.getSqlString(deleteChangeset) ,""+ "cmdId="+(cmdId) + "," +"csId="+(csId),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[deleteChangeset]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the DeleteChangeset prepared statement
	 */
	public static class BatchDeleteChangeset extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the DeleteChangeset prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchDeleteChangeset(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,deleteChangeset,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the deleteChangeset prepared statement.
		 *
	 *@param cmdId template parameter
	 *@param csId template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (long cmdId, long csId) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setLong(argc++, cmdId);
			ps.setLong(argc++, csId);
				ps.addBatch();
			}catch(java.sql.SQLException sqle){
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle);
			}
		}
	}




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

			
				SelectChangesetResult result = new SelectChangesetResult();
				try {
				result.id=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:id",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.addGraph=rs.getClob(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:addGraph",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.removeGraph=rs.getClob(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:removeGraph",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.metaAddGraph=rs.getClob(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:metaAddGraph",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.metaRemoveGraph=rs.getClob(5);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:metaRemoveGraph",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.nameGraphUri=rs.getString(6);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:nameGraphUri",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the selectChangeset prepared statement.
	  * <code>
	 *  		SELECT ID,ADDGRAPH,REMOVEGRAPH,METAADDGRAPH,METAREMOVEGRAPH,NAMEDGRAPHURI FROM {0} WHERE COMMANDID = ? ORDER BY ID 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param cmdId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<SelectChangesetResult> selectChangeset (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long cmdId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(selectChangeset, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, cmdId);
			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<SelectChangesetResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectChangesetResult>(rs, ps, stmtProvider, transformSelectChangeset);
			return iter;

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


	
	/**
	 *Default implementation of SelectChangesetResult
	 */
	public static class SelectChangesetResult {
			/**Value for the "id" result value*/
			private long id;
			/**Value for the "addGraph" result value*/
			private java.sql.Clob addGraph;
			/**Value for the "removeGraph" result value*/
			private java.sql.Clob removeGraph;
			/**Value for the "metaAddGraph" result value*/
			private java.sql.Clob metaAddGraph;
			/**Value for the "metaRemoveGraph" result value*/
			private java.sql.Clob metaRemoveGraph;
			/**Value for the "nameGraphUri" result value*/
			private String nameGraphUri;

		/**
		  *Get Id value
		  *@return Id value
		  */
			public long getId() {
				return this.id;
			}

		/**
		  *Get AddGraph value
		  *@return AddGraph value
		  */
			public java.sql.Clob getAddGraph() {
				return this.addGraph;
			}

		/**
		  *Get RemoveGraph value
		  *@return RemoveGraph value
		  */
			public java.sql.Clob getRemoveGraph() {
				return this.removeGraph;
			}

		/**
		  *Get MetaAddGraph value
		  *@return MetaAddGraph value
		  */
			public java.sql.Clob getMetaAddGraph() {
				return this.metaAddGraph;
			}

		/**
		  *Get MetaRemoveGraph value
		  *@return MetaRemoveGraph value
		  */
			public java.sql.Clob getMetaRemoveGraph() {
				return this.metaRemoveGraph;
			}

		/**
		  *Get NameGraphUri value
		  *@return NameGraphUri value
		  */
			public String getNameGraphUri() {
				return this.nameGraphUri;
			}

	}



	
	/**
	 * Runs the updateCommand prepared statement.
	  * <code>
	 *  		UPDATE {0} set transactionId=?,commandType=?,context=?,preReq=? where id=? 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param transactionId template parameter
	 *@param commandType template parameter
	 *@param context template parameter
	 *@param preReq template parameter
	 *@param id template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int updateCommand (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long transactionId, String commandType, java.sql.Clob context, java.sql.Clob preReq, long id, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(updateCommand, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, transactionId);
			if(commandType == null) {
				ps.setNull(argc++, java.sql.Types.VARCHAR);
			} else {
				ps.setString(argc++, commandType);
			}
			if(context == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, context);
			}
			if(preReq == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, preReq);
			}
			ps.setLong(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,"updateCommand",stmtProvider.getSqlString(updateCommand) ,""+ "transactionId="+(transactionId) + "," +"commandType="+((commandType!=null)?commandType.toString():"null") + "," +"context="+((context!=null)?context.toString():"null") + "," +"preReq="+((preReq!=null)?preReq.toString():"null") + "," +"id="+(id),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[updateCommand]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the UpdateCommand prepared statement
	 */
	public static class BatchUpdateCommand extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the UpdateCommand prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchUpdateCommand(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,updateCommand,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the updateCommand prepared statement.
		 *
	 *@param transactionId template parameter
	 *@param commandType template parameter
	 *@param context template parameter
	 *@param preReq template parameter
	 *@param id template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (long transactionId, String commandType, java.sql.Clob context, java.sql.Clob preReq, long id) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setLong(argc++, transactionId);
			if(commandType == null) {
				ps.setNull(argc++, java.sql.Types.VARCHAR);
			} else {
				ps.setString(argc++, commandType);
			}
			if(context == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, context);
			}
			if(preReq == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, preReq);
			}
			ps.setLong(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 insertCommand prepared statement.
	  * <code>
	 *  		INSERT INTO {0} (transactionId, commandType,context,prereq) VALUES (?, ?, ?, ?) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param transactionId template parameter
	 *@param commandType template parameter
	 *@param context template parameter
	 *@param preReq template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int insertCommand (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long transactionId, String commandType, java.sql.Clob context, java.sql.Clob preReq, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertCommand, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, transactionId);
			if(commandType == null) {
				ps.setNull(argc++, java.sql.Types.VARCHAR);
			} else {
				ps.setString(argc++, commandType);
			}
			if(context == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, context);
			}
			if(preReq == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, preReq);
			}
				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,"insertCommand",stmtProvider.getSqlString(insertCommand) ,""+ "transactionId="+(transactionId) + "," +"commandType="+((commandType!=null)?commandType.toString():"null") + "," +"context="+((context!=null)?context.toString():"null") + "," +"preReq="+((preReq!=null)?preReq.toString():"null"),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[insertCommand]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertCommand prepared statement
	 */
	public static class BatchInsertCommand extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertCommand prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertCommand(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertCommand,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the insertCommand prepared statement.
		 *
	 *@param transactionId template parameter
	 *@param commandType template parameter
	 *@param context template parameter
	 *@param preReq template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (long transactionId, String commandType, java.sql.Clob context, java.sql.Clob preReq) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setLong(argc++, transactionId);
			if(commandType == null) {
				ps.setNull(argc++, java.sql.Types.VARCHAR);
			} else {
				ps.setString(argc++, commandType);
			}
			if(context == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, context);
			}
			if(preReq == null) {
				ps.setNull(argc++, java.sql.Types.CLOB);
			} else {
				ps.setClob(argc++, preReq);
			}
				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 deleteCommand prepared statement.
	  * <code>
	 *  		DELETE FROM {0} WHERE TRANSACTIONID = ? AND ID = ? 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param transactionId template parameter
	 *@param cmdId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int deleteCommand (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long transactionId, long cmdId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(deleteCommand, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, transactionId);
			ps.setLong(argc++, cmdId);
				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,"deleteCommand",stmtProvider.getSqlString(deleteCommand) ,""+ "transactionId="+(transactionId) + "," +"cmdId="+(cmdId),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[deleteCommand]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the DeleteCommand prepared statement
	 */
	public static class BatchDeleteCommand extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the DeleteCommand prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchDeleteCommand(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,deleteCommand,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the deleteCommand prepared statement.
		 *
	 *@param transactionId template parameter
	 *@param cmdId template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (long transactionId, long cmdId) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setLong(argc++, transactionId);
			ps.setLong(argc++, cmdId);
				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 deleteTransaction prepared statement.
	  * <code>
	 *  		DELETE FROM {0} WHERE ID = ? 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param transactionId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int deleteTransaction (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long transactionId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(deleteTransaction, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, transactionId);
				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,"deleteTransaction",stmtProvider.getSqlString(deleteTransaction) ,""+ "transactionId="+(transactionId),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[deleteTransaction]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the DeleteTransaction prepared statement
	 */
	public static class BatchDeleteTransaction extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the DeleteTransaction prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchDeleteTransaction(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,deleteTransaction,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the deleteTransaction prepared statement.
		 *
	 *@param transactionId template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (long transactionId) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			ps.setLong(argc++, transactionId);
				ps.addBatch();
			}catch(java.sql.SQLException sqle){
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle);
			}
		}
	}




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

			
				SelectCommandResult result = new SelectCommandResult();
				try {
				result.id=rs.getLong(1);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:id",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.commandType=rs.getString(2);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:commandType",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.prereq=rs.getClob(3);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:prereq",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				try {
				result.context=rs.getClob(4);
				} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set param:context",e);
				throw new org.apache.commons.collections.FunctorException(e);
				}
				return result;
			
		}

	};
	
	/**
	 * Runs the selectCommand prepared statement.
	  * <code>
	 *  		SELECT ID,COMMANDTYPE,PREREQ,CONTEXT FROM {0} WHERE TRANSACTIONID = ? ORDER BY ID 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param transactionId template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<SelectCommandResult> selectCommand (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, long transactionId, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(selectCommand, new String[] {transactionTableName},connection); int argc = 1;
			ps.setLong(argc++, transactionId);
			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<SelectCommandResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectCommandResult>(rs, ps, stmtProvider, transformSelectCommand);
			return iter;

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


	
	/**
	 *Default implementation of SelectCommandResult
	 */
	public static class SelectCommandResult {
			/**Value for the "id" result value*/
			private long id;
			/**Value for the "commandType" result value*/
			private String commandType;
			/**Value for the "prereq" result value*/
			private java.sql.Clob prereq;
			/**Value for the "context" result value*/
			private java.sql.Clob context;

		/**
		  *Get Id value
		  *@return Id value
		  */
			public long getId() {
				return this.id;
			}

		/**
		  *Get CommandType value
		  *@return CommandType value
		  */
			public String getCommandType() {
				return this.commandType;
			}

		/**
		  *Get Prereq value
		  *@return Prereq value
		  */
			public java.sql.Clob getPrereq() {
				return this.prereq;
			}

		/**
		  *Get Context value
		  *@return Context value
		  */
			public java.sql.Clob getContext() {
				return this.context;
			}

	}



	
	/**
	 * Runs the insertTransaction prepared statement.
	  * <code>
	 *  		INSERT INTO {0} (CREATED) VALUES (?) 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *@param created template parameter
	 *
	 *@param transactionTableName template parameter
	 *@return  int
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static int insertTransaction (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, java.sql.Timestamp created, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(insertTransaction, new String[] {transactionTableName},connection); int argc = 1;
			if(created == null) {
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER,"created","insertTransaction");
			} else {
				ps.setTimestamp(argc++, created);
			}
				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,"insertTransaction",stmtProvider.getSqlString(insertTransaction) ,""+ "created="+((created!=null)?created.toString():"null"),""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[insertTransaction]"+endtimer);
		}
	}
	/**
	 *Batch operation for adding parameters to the InsertTransaction prepared statement
	 */
	public static class BatchInsertTransaction extends org.openanzo.jdbc.utils.PreparedStatementExecutor {
		/**
		 * Batch operation for adding parameters to the InsertTransaction prepared statement
		 * @param connection Connection to execute 
		 * @param provider Prepared statement provider
		 * 
	 *@param transactionTableName template parameter
		 * @throws org.openanzo.jdbc.utils.RdbException
		 */
		public BatchInsertTransaction(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException {
			super(connection,provider,insertTransaction,new String[] {transactionTableName});
		}
		
		/**
		 * Sets the input parameters for the insertTransaction prepared statement.
		 *
	 *@param created template parameter
		 *@throws org.openanzo.jdbc.utils.RdbException
		 */
		public void addEntry (java.sql.Timestamp created) throws org.openanzo.jdbc.utils.RdbException {
	 		try{
		 		ps.clearParameters(); int argc = 1;
			if(created == null) {
				throw new org.openanzo.jdbc.utils.RdbException(org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER,"created","insertTransaction");
			} else {
				ps.setTimestamp(argc++, created);
			}
				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 maxId prepared statement.
	  * <code>
	 *  		SELECT MAX(ID) FROM {0} 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *
	 *@param transactionTableName template parameter
	 *@return  Long
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static Long maxId (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(maxId, new String[] {transactionTableName},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;				 
				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,"maxId",stmtProvider.getSqlString(maxId) ,"",""+ "transactionTableName="+((transactionTableName!=null)?transactionTableName.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("[maxId]"+endtimer);
		}
	}




	/**
	 * Transformer that transforms the rows in the result set for the selectTransactions prepared statement.
	 */
	static final org.openanzo.jdbc.utils.Transformer<Long> transformSelectTransactions = new org.openanzo.jdbc.utils.Transformer<Long>(){
		public Long transform(java.sql.ResultSet rs) {
			try {
				Long val = rs.getLong(1);
				return val;
			} catch (java.sql.SQLException e) {
				log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER,"Error transforming result set value:Long",e);
				throw new org.apache.commons.collections.FunctorException(e);
			}
			}

	};
	
	/**
	 * Runs the selectTransactions prepared statement.
	  * <code>
	 *  	   SELECT ID FROM {0} ORDER BY ID 	
	 * </code>
	 *
	 *@param stmtProvider
	 *			factory and cache of PreparedStatments
	 *@param connection
	 * 			connection to underlying database
	 *
	 *
	 *@param transactionTableName template parameter
	 *@return  org.openanzo.jdbc.utils.ClosableIterator
	 *@throws  org.openanzo.jdbc.utils.RdbException
	 */
	public static org.openanzo.jdbc.utils.ClosableIterator<Long> selectTransactions (final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider,final java.sql.Connection connection, String transactionTableName) throws org.openanzo.jdbc.utils.RdbException{
		java.sql.PreparedStatement ps = null;
		//long startTimer=System.currentTimeMillis();
		try {		
			ps = stmtProvider.getPreparedSQLStatement(selectTransactions, new String[] {transactionTableName},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<Long> iter = new org.openanzo.jdbc.utils.ResultSetIterator<Long>(rs, ps, stmtProvider, transformSelectTransactions);
			return iter;

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


}