Java tutorial
/******************************************************************************* * Copyright (c) 2004, 2007-2009 IBM Corporation and Cambridge Semantics Incorporated. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Created by: Generated Source from org.openanzo.jdbc.utils.opgen.jet * * Contributors: * IBM Corporation - initial API and implementation * Cambridge Semantics Incorporated - Fork to Anzo *******************************************************************************/ package org.openanzo.datasource.nodecentric.sql; // allow for all types that can be returned from a resultset /** * StatementRdbWrapper provides wrappers around SQL queries and transforms ResultSets into java objects * * @author Generated Source from org.openanzo.jdbc.utils.opgen.jet */ public class StatementRdbWrapper { private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(StatementRdbWrapper.class); static final long CUTOFF = 5; /** *Constant "selectStatementId" used to reference prepared statement Statement.selectStatementId * * <code> * SELECT S.ID FROM STATEMENTS S WHERE SUBJECT = ? AND PREDICATE = ? AND OBJECT = ? AND S.NAMEDGRAPHID = ? AND REND IS NULL; * </code> */ public static final String selectStatementId = "Statement.selectStatementId"; /** *Constant "insertStatement" used to reference prepared statement Statement.insertStatement * * <code> * INSERT INTO STATEMENTS(ID,METADATA,UUID,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,RSTART,COMMITTED) VALUES (?,?,?,?, ?, ?, ?, ?,0); * </code> */ public static final String insertStatement = "Statement.insertStatement"; /** *Constant "insertStatementNR" used to reference prepared statement Statement.insertStatementNR * * <code> * INSERT INTO STATEMENTS_NR(ID,METADATA,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,COMMITTED) VALUES (?, ?,?, ?, ?, ?,0); * </code> */ public static final String insertStatementNR = "Statement.insertStatementNR"; /** *Constant "deleteStatement" used to reference prepared statement Statement.deleteStatement * * <code> * UPDATE STATEMENTS SET REND=? WHERE ID=?; * </code> */ public static final String deleteStatement = "Statement.deleteStatement"; /** *Constant "deleteStatementNR" used to reference prepared statement Statement.deleteStatementNR * * <code> * DELETE FROM STATEMENTS_NR WHERE ID=?; * </code> */ public static final String deleteStatementNR = "Statement.deleteStatementNR"; /** *Constant "countStatements" used to reference prepared statement Statement.countStatements * * <code> * SELECT COUNT(1) FROM STATEMENTS WHERE ((REND IS NULL AND COMMITTED=0) OR (REND IS NOT NULL AND COMMITTED<0)); * </code> */ public static final String countStatements = "Statement.countStatements"; /** *Constant "resolveDataset" used to reference prepared statement Statement.resolveDataset * * <code> * SELECT PREDICATE,OBJECT FROM STATEMENTS WHERE ((REND IS NULL AND COMMITTED=0) OR (REND IS NOT NULL AND COMMITTED<0)) AND PREDICATE IN ({0},{1},{2}) AND SUBJECT = ? AND NAMEDGRAPHID = ? * </code> */ public static final String resolveDataset = "Statement.resolveDataset"; /** *Constant "resolveDatasetNR" used to reference prepared statement Statement.resolveDatasetNR * * <code> * SELECT PREDICATE,OBJECT FROM STATEMENTS_NR WHERE COMMITTED<=0 AND PREDICATE IN ({0},{1},{2}) AND SUBJECT = ? AND NAMEDGRAPHID = ? * </code> */ public static final String resolveDatasetNR = "Statement.resolveDatasetNR"; /** *Constant "countStatementsNR" used to reference prepared statement Statement.countStatementsNR * * <code> * SELECT COUNT(1) FROM STATEMENTS_NR WHERE COMMITTED <=0; * </code> */ public static final String countStatementsNR = "Statement.countStatementsNR"; /** *Constant "findMinMaxId" used to reference prepared statement Statement.findMinMaxId * * <code> * SELECT MIN(ID),MAX(ID) FROM {0} * </code> */ public static final String findMinMaxId = "Statement.findMinMaxId"; /** *Constant "findLiteralStatementsRange" used to reference prepared statement Statement.findLiteralStatementsRange * * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > ? and OBJECT < ? * </code> */ public static final String findLiteralStatementsRange = "Statement.findLiteralStatementsRange"; /** *Constant "findLiteralStatementsNRRange" used to reference prepared statement Statement.findLiteralStatementsNRRange * * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > ? and OBJECT < ? * </code> */ public static final String findLiteralStatementsNRRange = "Statement.findLiteralStatementsNRRange"; /** *Constant "findLiteralStatements" used to reference prepared statement Statement.findLiteralStatements * * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM ALL_STMTS_VIEW WHERE OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855 * </code> */ public static final String findLiteralStatements = "Statement.findLiteralStatements"; /** *Constant "findLiteralStatementsLimited" used to reference prepared statement Statement.findLiteralStatementsLimited * * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM( SELECT ROW_NUMBER() OVER (ORDER BY NAMEDGRAPHID) AS ROWNUM,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855) AS FOO WHERE ROWNUM > ? AND ROWNUM<= ? * </code> */ public static final String findLiteralStatementsLimited = "Statement.findLiteralStatementsLimited"; /** *Constant "findLiteralStatementsNRLimited" used to reference prepared statement Statement.findLiteralStatementsNRLimited * * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM( SELECT ROW_NUMBER() OVER (ORDER BY NAMEDGRAPHID) AS ROWNUM,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855) AS FOO WHERE ROWNUM > ? AND ROWNUM<= ? * </code> */ public static final String findLiteralStatementsNRLimited = "Statement.findLiteralStatementsNRLimited"; /** *Constant "findLiteralStatementsLimitOffset" used to reference prepared statement Statement.findLiteralStatementsLimitOffset * * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855 ORDER BY NAMEDGRAPHID ASC LIMIT ? OFFSET ? * </code> */ public static final String findLiteralStatementsLimitOffset = "Statement.findLiteralStatementsLimitOffset"; /** *Constant "findLiteralStatementsNRLimitOffset" used to reference prepared statement Statement.findLiteralStatementsNRLimitOffset * * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855 ORDER BY NAMEDGRAPHID ASC LIMIT ? OFFSET ? * </code> */ public static final String findLiteralStatementsNRLimitOffset = "Statement.findLiteralStatementsNRLimitOffset"; /** * Runs the selectStatementId prepared statement. * <code> * SELECT S.ID FROM STATEMENTS S WHERE SUBJECT = ? AND PREDICATE = ? AND OBJECT = ? AND S.NAMEDGRAPHID = ? AND REND IS NULL; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param subject template parameter *@param predicate template parameter *@param object template parameter *@param namedGraph template parameter * *@return long *@throws org.openanzo.jdbc.utils.RdbException */ public static long selectStatementId(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long subject, long predicate, long object, long namedGraph) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectStatementId, new String[] {}, connection); int argc = 1; ps.setLong(argc++, subject); ps.setLong(argc++, predicate); ps.setLong(argc++, object); ps.setLong(argc++, namedGraph); java.sql.ResultSet rs = null; try { try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } if (!rs.next()) return 0; long val = rs.getLong(1); return val; } finally { if (rs != null) { try { rs.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing result set", sqle); } } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectStatementId", stmtProvider.getSqlString(selectStatementId), "" + "subject=" + (subject) + "," + "predicate=" + (predicate) + "," + "object=" + (object) + "," + "namedGraph=" + (namedGraph), ""); } finally { if (ps != null) { try { ps.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing prepared statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectStatementId]"+endtimer); } } /** * Runs the insertStatement prepared statement. * <code> * INSERT INTO STATEMENTS(ID,METADATA,UUID,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,RSTART,COMMITTED) VALUES (?,?,?,?, ?, ?, ?, ?,0); * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter *@param metadata template parameter *@param uuid template parameter *@param namedGraphId template parameter *@param subject template parameter *@param predicate template parameter *@param object template parameter *@param rstart template parameter * * *@throws org.openanzo.jdbc.utils.RdbException */ public static void insertStatement(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String id, int metadata, long uuid, long namedGraphId, long subject, long predicate, long object, long rstart) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(insertStatement, new String[] {}, connection); int argc = 1; if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "insertStatement"); } else { ps.setString(argc++, id); } ps.setInt(argc++, metadata); ps.setLong(argc++, uuid); ps.setLong(argc++, namedGraphId); ps.setLong(argc++, subject); ps.setLong(argc++, predicate); ps.setLong(argc++, object); ps.setLong(argc++, rstart); try { ps.execute(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { ps.execute(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "insertStatement", stmtProvider.getSqlString(insertStatement), "" + "id=" + ((id != null) ? id.toString() : "null") + "," + "metadata=" + (metadata) + "," + "uuid=" + (uuid) + "," + "namedGraphId=" + (namedGraphId) + "," + "subject=" + (subject) + "," + "predicate=" + (predicate) + "," + "object=" + (object) + "," + "rstart=" + (rstart), ""); } finally { if (ps != null) { try { ps.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing prepared statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[insertStatement]"+endtimer); } } /** *Batch operation for adding parameters to the InsertStatement prepared statement */ public static class BatchInsertStatement extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the InsertStatement prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchInsertStatement(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, insertStatement, new String[] {}); } /** * Sets the input parameters for the insertStatement prepared statement. * *@param id template parameter *@param metadata template parameter *@param uuid template parameter *@param namedGraphId template parameter *@param subject template parameter *@param predicate template parameter *@param object template parameter *@param rstart template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(String id, int metadata, long uuid, long namedGraphId, long subject, long predicate, long object, long rstart) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "insertStatement"); } else { ps.setString(argc++, id); } ps.setInt(argc++, metadata); ps.setLong(argc++, uuid); ps.setLong(argc++, namedGraphId); ps.setLong(argc++, subject); ps.setLong(argc++, predicate); ps.setLong(argc++, object); ps.setLong(argc++, rstart); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the insertStatementNR prepared statement. * <code> * INSERT INTO STATEMENTS_NR(ID,METADATA,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,COMMITTED) VALUES (?, ?,?, ?, ?, ?,0); * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter *@param metadata template parameter *@param namedGraphId template parameter *@param subject template parameter *@param predicate template parameter *@param object template parameter * * *@throws org.openanzo.jdbc.utils.RdbException */ public static void insertStatementNR(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String id, int metadata, long namedGraphId, long subject, long predicate, long object) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(insertStatementNR, new String[] {}, connection); int argc = 1; if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "insertStatementNR"); } else { ps.setString(argc++, id); } ps.setInt(argc++, metadata); ps.setLong(argc++, namedGraphId); ps.setLong(argc++, subject); ps.setLong(argc++, predicate); ps.setLong(argc++, object); try { ps.execute(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { ps.execute(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "insertStatementNR", stmtProvider.getSqlString(insertStatementNR), "" + "id=" + ((id != null) ? id.toString() : "null") + "," + "metadata=" + (metadata) + "," + "namedGraphId=" + (namedGraphId) + "," + "subject=" + (subject) + "," + "predicate=" + (predicate) + "," + "object=" + (object), ""); } finally { if (ps != null) { try { ps.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing prepared statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[insertStatementNR]"+endtimer); } } /** *Batch operation for adding parameters to the InsertStatementNR prepared statement */ public static class BatchInsertStatementNR extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the InsertStatementNR prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchInsertStatementNR(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, insertStatementNR, new String[] {}); } /** * Sets the input parameters for the insertStatementNR prepared statement. * *@param id template parameter *@param metadata template parameter *@param namedGraphId template parameter *@param subject template parameter *@param predicate template parameter *@param object template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(String id, int metadata, long namedGraphId, long subject, long predicate, long object) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "insertStatementNR"); } else { ps.setString(argc++, id); } ps.setInt(argc++, metadata); ps.setLong(argc++, namedGraphId); ps.setLong(argc++, subject); ps.setLong(argc++, predicate); ps.setLong(argc++, object); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the deleteStatement prepared statement. * <code> * UPDATE STATEMENTS SET REND=? WHERE ID=?; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param rend template parameter *@param id template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int deleteStatement(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long rend, String id) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(deleteStatement, new String[] {}, connection); int argc = 1; ps.setLong(argc++, rend); if (id == null) { ps.setNull(argc++, java.sql.Types.VARCHAR); } else { ps.setString(argc++, id); } int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "deleteStatement", stmtProvider.getSqlString(deleteStatement), "" + "rend=" + (rend) + "," + "id=" + ((id != null) ? id.toString() : "null"), ""); } finally { if (ps != null) { try { ps.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing prepared statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[deleteStatement]"+endtimer); } } /** *Batch operation for adding parameters to the DeleteStatement prepared statement */ public static class BatchDeleteStatement extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the DeleteStatement prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchDeleteStatement(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, deleteStatement, new String[] {}); } /** * Sets the input parameters for the deleteStatement prepared statement. * *@param rend template parameter *@param id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long rend, String id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, rend); if (id == null) { ps.setNull(argc++, java.sql.Types.VARCHAR); } else { ps.setString(argc++, id); } ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the deleteStatementNR prepared statement. * <code> * DELETE FROM STATEMENTS_NR WHERE ID=?; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int deleteStatementNR(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String id) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(deleteStatementNR, new String[] {}, connection); int argc = 1; if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "deleteStatementNR"); } else { ps.setString(argc++, id); } int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "deleteStatementNR", stmtProvider.getSqlString(deleteStatementNR), "" + "id=" + ((id != null) ? id.toString() : "null"), ""); } finally { if (ps != null) { try { ps.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing prepared statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[deleteStatementNR]"+endtimer); } } /** *Batch operation for adding parameters to the DeleteStatementNR prepared statement */ public static class BatchDeleteStatementNR extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the DeleteStatementNR prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchDeleteStatementNR(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, deleteStatementNR, new String[] {}); } /** * Sets the input parameters for the deleteStatementNR prepared statement. * *@param id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(String id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "deleteStatementNR"); } else { ps.setString(argc++, id); } ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the countStatements prepared statement. * <code> * SELECT COUNT(1) FROM STATEMENTS WHERE ((REND IS NULL AND COMMITTED=0) OR (REND IS NOT NULL AND COMMITTED<0)); * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@return long *@throws org.openanzo.jdbc.utils.RdbException */ public static long countStatements(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(countStatements, new String[] {}, connection); java.sql.ResultSet rs = null; try { try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } if (!rs.next()) return 0; long val = rs.getLong(1); return val; } finally { if (rs != null) { try { rs.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing result set", sqle); } } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "countStatements", stmtProvider.getSqlString(countStatements), "", ""); } finally { if (ps != null) { try { ps.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing prepared statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[countStatements]"+endtimer); } } /** * Transformer that transforms the rows in the result set for the resolveDataset prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<ResolveDatasetResult> transformResolveDataset = new org.openanzo.jdbc.utils.Transformer<ResolveDatasetResult>() { public ResolveDatasetResult transform(java.sql.ResultSet rs) { ResolveDatasetResult result = new ResolveDatasetResult(); try { result.predicateId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:predicateId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.object = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:object", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the resolveDataset prepared statement. * <code> * SELECT PREDICATE,OBJECT FROM STATEMENTS WHERE ((REND IS NULL AND COMMITTED=0) OR (REND IS NOT NULL AND COMMITTED<0)) AND PREDICATE IN ({0},{1},{2}) AND SUBJECT = ? AND NAMEDGRAPHID = ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param gId template parameter *@param g2Id template parameter * *@param ngId template parameter *@param dgId template parameter *@param dngId template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<ResolveDatasetResult> resolveDataset( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long gId, long g2Id, String ngId, String dgId, String dngId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveDataset, new String[] { ngId, dgId, dngId }, connection); int argc = 1; ps.setLong(argc++, gId); ps.setLong(argc++, g2Id); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<ResolveDatasetResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveDatasetResult>( rs, ps, stmtProvider, transformResolveDataset); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveDataset", stmtProvider.getSqlString(resolveDataset), "" + "gId=" + (gId) + "," + "g2Id=" + (g2Id), "" + "ngId=" + ((ngId != null) ? ngId.toString() : "null") + "," + "dgId=" + ((dgId != null) ? dgId.toString() : "null") + "," + "dngId=" + ((dngId != null) ? dngId.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[resolveDataset]"+endtimer); } } /** *Default implementation of ResolveDatasetResult */ public static class ResolveDatasetResult { /**Value for the "predicateId" result value*/ private long predicateId; /**Value for the "object" result value*/ private long object; /** *Get PredicateId value *@return PredicateId value */ public long getPredicateId() { return this.predicateId; } /** *Get Object value *@return Object value */ public long getObject() { return this.object; } } /** * Transformer that transforms the rows in the result set for the resolveDatasetNR prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<ResolveDatasetNRResult> transformResolveDatasetNR = new org.openanzo.jdbc.utils.Transformer<ResolveDatasetNRResult>() { public ResolveDatasetNRResult transform(java.sql.ResultSet rs) { ResolveDatasetNRResult result = new ResolveDatasetNRResult(); try { result.predicateId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:predicateId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.object = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:object", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the resolveDatasetNR prepared statement. * <code> * SELECT PREDICATE,OBJECT FROM STATEMENTS_NR WHERE COMMITTED<=0 AND PREDICATE IN ({0},{1},{2}) AND SUBJECT = ? AND NAMEDGRAPHID = ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param gId template parameter *@param g2Id template parameter * *@param ngId template parameter *@param dgId template parameter *@param dngId template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<ResolveDatasetNRResult> resolveDatasetNR( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long gId, long g2Id, String ngId, String dgId, String dngId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveDatasetNR, new String[] { ngId, dgId, dngId }, connection); int argc = 1; ps.setLong(argc++, gId); ps.setLong(argc++, g2Id); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<ResolveDatasetNRResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveDatasetNRResult>( rs, ps, stmtProvider, transformResolveDatasetNR); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveDatasetNR", stmtProvider.getSqlString(resolveDatasetNR), "" + "gId=" + (gId) + "," + "g2Id=" + (g2Id), "" + "ngId=" + ((ngId != null) ? ngId.toString() : "null") + "," + "dgId=" + ((dgId != null) ? dgId.toString() : "null") + "," + "dngId=" + ((dngId != null) ? dngId.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[resolveDatasetNR]"+endtimer); } } /** *Default implementation of ResolveDatasetNRResult */ public static class ResolveDatasetNRResult { /**Value for the "predicateId" result value*/ private long predicateId; /**Value for the "object" result value*/ private long object; /** *Get PredicateId value *@return PredicateId value */ public long getPredicateId() { return this.predicateId; } /** *Get Object value *@return Object value */ public long getObject() { return this.object; } } /** * Runs the countStatementsNR prepared statement. * <code> * SELECT COUNT(1) FROM STATEMENTS_NR WHERE COMMITTED <=0; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@return long *@throws org.openanzo.jdbc.utils.RdbException */ public static long countStatementsNR(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(countStatementsNR, new String[] {}, connection); java.sql.ResultSet rs = null; try { try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } if (!rs.next()) return 0; long val = rs.getLong(1); return val; } finally { if (rs != null) { try { rs.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing result set", sqle); } } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "countStatementsNR", stmtProvider.getSqlString(countStatementsNR), "", ""); } finally { if (ps != null) { try { ps.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing prepared statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[countStatementsNR]"+endtimer); } } /** * Runs the findMinMaxId prepared statement. * <code> * SELECT MIN(ID),MAX(ID) FROM {0} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param tableName template parameter *@return FindMinMaxIdResult *@throws org.openanzo.jdbc.utils.RdbException */ public static FindMinMaxIdResult findMinMaxId( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String tableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findMinMaxId, new String[] { tableName }, connection); java.sql.ResultSet rs = null; try { try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } if (!rs.next()) return null; FindMinMaxIdResult result = new FindMinMaxIdResult(); result.min = rs.getLong(1); result.max = rs.getLong(2); return result; } finally { if (rs != null) { try { rs.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing result set", sqle); } } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findMinMaxId", stmtProvider.getSqlString(findMinMaxId), "", "" + "tableName=" + ((tableName != null) ? tableName.toString() : "null")); } finally { if (ps != null) { try { ps.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing prepared statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findMinMaxId]"+endtimer); } } /** *Default implementation of FindMinMaxIdResult */ public static class FindMinMaxIdResult { /**Value for the "min" result value*/ private long min; /**Value for the "max" result value*/ private long max; /** *Get Min value *@return Min value */ public long getMin() { return this.min; } /** *Get Max value *@return Max value */ public long getMax() { return this.max; } } /** * Transformer that transforms the rows in the result set for the findLiteralStatementsRange prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsRangeResult> transformFindLiteralStatementsRange = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsRangeResult>() { public FindLiteralStatementsRangeResult transform(java.sql.ResultSet rs) { FindLiteralStatementsRangeResult result = new FindLiteralStatementsRangeResult(); try { result.namedGraphId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:namedGraphId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.subj = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:subj", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.prop = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:prop", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.obj = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:obj", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the findLiteralStatementsRange prepared statement. * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > ? and OBJECT < ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param start template parameter *@param end template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsRangeResult> findLiteralStatementsRange( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long start, long end) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsRange, new String[] {}, connection); int argc = 1; ps.setLong(argc++, start); ps.setLong(argc++, end); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsRangeResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsRangeResult>( rs, ps, stmtProvider, transformFindLiteralStatementsRange); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findLiteralStatementsRange", stmtProvider.getSqlString(findLiteralStatementsRange), "" + "start=" + (start) + "," + "end=" + (end), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsRange]"+endtimer); } } /** *Default implementation of FindLiteralStatementsRangeResult */ public static class FindLiteralStatementsRangeResult { /**Value for the "namedGraphId" result value*/ private long namedGraphId; /**Value for the "subj" result value*/ private long subj; /**Value for the "prop" result value*/ private long prop; /**Value for the "obj" result value*/ private long obj; /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } /** *Get Subj value *@return Subj value */ public long getSubj() { return this.subj; } /** *Get Prop value *@return Prop value */ public long getProp() { return this.prop; } /** *Get Obj value *@return Obj value */ public long getObj() { return this.obj; } } /** * Transformer that transforms the rows in the result set for the findLiteralStatementsNRRange prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRRangeResult> transformFindLiteralStatementsNRRange = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRRangeResult>() { public FindLiteralStatementsNRRangeResult transform(java.sql.ResultSet rs) { FindLiteralStatementsNRRangeResult result = new FindLiteralStatementsNRRangeResult(); try { result.namedGraphId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:namedGraphId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.subj = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:subj", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.prop = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:prop", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.obj = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:obj", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the findLiteralStatementsNRRange prepared statement. * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > ? and OBJECT < ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param start template parameter *@param end template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRRangeResult> findLiteralStatementsNRRange( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long start, long end) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsNRRange, new String[] {}, connection); int argc = 1; ps.setLong(argc++, start); ps.setLong(argc++, end); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRRangeResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsNRRangeResult>( rs, ps, stmtProvider, transformFindLiteralStatementsNRRange); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findLiteralStatementsNRRange", stmtProvider.getSqlString(findLiteralStatementsNRRange), "" + "start=" + (start) + "," + "end=" + (end), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsNRRange]"+endtimer); } } /** *Default implementation of FindLiteralStatementsNRRangeResult */ public static class FindLiteralStatementsNRRangeResult { /**Value for the "namedGraphId" result value*/ private long namedGraphId; /**Value for the "subj" result value*/ private long subj; /**Value for the "prop" result value*/ private long prop; /**Value for the "obj" result value*/ private long obj; /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } /** *Get Subj value *@return Subj value */ public long getSubj() { return this.subj; } /** *Get Prop value *@return Prop value */ public long getProp() { return this.prop; } /** *Get Obj value *@return Obj value */ public long getObj() { return this.obj; } } /** * Transformer that transforms the rows in the result set for the findLiteralStatements prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsResult> transformFindLiteralStatements = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsResult>() { public FindLiteralStatementsResult transform(java.sql.ResultSet rs) { FindLiteralStatementsResult result = new FindLiteralStatementsResult(); try { result.namedGraphId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:namedGraphId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.subject = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:subject", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.predicate = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:predicate", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.object = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:object", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the findLiteralStatements prepared statement. * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM ALL_STMTS_VIEW WHERE OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855 * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsResult> findLiteralStatements( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findLiteralStatements, new String[] {}, connection); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsResult>( rs, ps, stmtProvider, transformFindLiteralStatements); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findLiteralStatements", stmtProvider.getSqlString(findLiteralStatements), "", ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findLiteralStatements]"+endtimer); } } /** *Default implementation of FindLiteralStatementsResult */ public static class FindLiteralStatementsResult { /**Value for the "namedGraphId" result value*/ private long namedGraphId; /**Value for the "subject" result value*/ private long subject; /**Value for the "predicate" result value*/ private long predicate; /**Value for the "object" result value*/ private long object; /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } /** *Get Subject value *@return Subject value */ public long getSubject() { return this.subject; } /** *Get Predicate value *@return Predicate value */ public long getPredicate() { return this.predicate; } /** *Get Object value *@return Object value */ public long getObject() { return this.object; } } /** * Transformer that transforms the rows in the result set for the findLiteralStatementsLimited prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsLimitedResult> transformFindLiteralStatementsLimited = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsLimitedResult>() { public FindLiteralStatementsLimitedResult transform(java.sql.ResultSet rs) { FindLiteralStatementsLimitedResult result = new FindLiteralStatementsLimitedResult(); try { result.namedGraphId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:namedGraphId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.subj = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:subj", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.prop = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:prop", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.obj = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:obj", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the findLiteralStatementsLimited prepared statement. * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM( SELECT ROW_NUMBER() OVER (ORDER BY NAMEDGRAPHID) AS ROWNUM,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855) AS FOO WHERE ROWNUM > ? AND ROWNUM<= ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param start template parameter *@param end template parameter * *@param sessionPrefix template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsLimitedResult> findLiteralStatementsLimited( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long start, long end, String sessionPrefix) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsLimited, new String[] { sessionPrefix }, connection); int argc = 1; ps.setLong(argc++, start); ps.setLong(argc++, end); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsLimitedResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsLimitedResult>( rs, ps, stmtProvider, transformFindLiteralStatementsLimited); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findLiteralStatementsLimited", stmtProvider.getSqlString(findLiteralStatementsLimited), "" + "start=" + (start) + "," + "end=" + (end), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsLimited]"+endtimer); } } /** *Default implementation of FindLiteralStatementsLimitedResult */ public static class FindLiteralStatementsLimitedResult { /**Value for the "namedGraphId" result value*/ private long namedGraphId; /**Value for the "subj" result value*/ private long subj; /**Value for the "prop" result value*/ private long prop; /**Value for the "obj" result value*/ private long obj; /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } /** *Get Subj value *@return Subj value */ public long getSubj() { return this.subj; } /** *Get Prop value *@return Prop value */ public long getProp() { return this.prop; } /** *Get Obj value *@return Obj value */ public long getObj() { return this.obj; } } /** * Transformer that transforms the rows in the result set for the findLiteralStatementsNRLimited prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRLimitedResult> transformFindLiteralStatementsNRLimited = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRLimitedResult>() { public FindLiteralStatementsNRLimitedResult transform(java.sql.ResultSet rs) { FindLiteralStatementsNRLimitedResult result = new FindLiteralStatementsNRLimitedResult(); try { result.namedGraphId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:namedGraphId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.subj = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:subj", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.prop = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:prop", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.obj = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:obj", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the findLiteralStatementsNRLimited prepared statement. * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM( SELECT ROW_NUMBER() OVER (ORDER BY NAMEDGRAPHID) AS ROWNUM,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855) AS FOO WHERE ROWNUM > ? AND ROWNUM<= ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param start template parameter *@param end template parameter * *@param sessionPrefix template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRLimitedResult> findLiteralStatementsNRLimited( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long start, long end, String sessionPrefix) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsNRLimited, new String[] { sessionPrefix }, connection); int argc = 1; ps.setLong(argc++, start); ps.setLong(argc++, end); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRLimitedResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsNRLimitedResult>( rs, ps, stmtProvider, transformFindLiteralStatementsNRLimited); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findLiteralStatementsNRLimited", stmtProvider.getSqlString(findLiteralStatementsNRLimited), "" + "start=" + (start) + "," + "end=" + (end), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsNRLimited]"+endtimer); } } /** *Default implementation of FindLiteralStatementsNRLimitedResult */ public static class FindLiteralStatementsNRLimitedResult { /**Value for the "namedGraphId" result value*/ private long namedGraphId; /**Value for the "subj" result value*/ private long subj; /**Value for the "prop" result value*/ private long prop; /**Value for the "obj" result value*/ private long obj; /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } /** *Get Subj value *@return Subj value */ public long getSubj() { return this.subj; } /** *Get Prop value *@return Prop value */ public long getProp() { return this.prop; } /** *Get Obj value *@return Obj value */ public long getObj() { return this.obj; } } /** * Transformer that transforms the rows in the result set for the findLiteralStatementsLimitOffset prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsLimitOffsetResult> transformFindLiteralStatementsLimitOffset = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsLimitOffsetResult>() { public FindLiteralStatementsLimitOffsetResult transform(java.sql.ResultSet rs) { FindLiteralStatementsLimitOffsetResult result = new FindLiteralStatementsLimitOffsetResult(); try { result.namedGraphId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:namedGraphId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.subj = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:subj", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.prop = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:prop", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.obj = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:obj", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the findLiteralStatementsLimitOffset prepared statement. * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS WHERE COMMITTED=0 AND REND IS NULL AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855 ORDER BY NAMEDGRAPHID ASC LIMIT ? OFFSET ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param start template parameter *@param end template parameter * *@param sessionPrefix template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsLimitOffsetResult> findLiteralStatementsLimitOffset( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long start, long end, String sessionPrefix) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsLimitOffset, new String[] { sessionPrefix }, connection); int argc = 1; ps.setLong(argc++, start); ps.setLong(argc++, end); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsLimitOffsetResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsLimitOffsetResult>( rs, ps, stmtProvider, transformFindLiteralStatementsLimitOffset); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findLiteralStatementsLimitOffset", stmtProvider.getSqlString(findLiteralStatementsLimitOffset), "" + "start=" + (start) + "," + "end=" + (end), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsLimitOffset]"+endtimer); } } /** *Default implementation of FindLiteralStatementsLimitOffsetResult */ public static class FindLiteralStatementsLimitOffsetResult { /**Value for the "namedGraphId" result value*/ private long namedGraphId; /**Value for the "subj" result value*/ private long subj; /**Value for the "prop" result value*/ private long prop; /**Value for the "obj" result value*/ private long obj; /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } /** *Get Subj value *@return Subj value */ public long getSubj() { return this.subj; } /** *Get Prop value *@return Prop value */ public long getProp() { return this.prop; } /** *Get Obj value *@return Obj value */ public long getObj() { return this.obj; } } /** * Transformer that transforms the rows in the result set for the findLiteralStatementsNRLimitOffset prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRLimitOffsetResult> transformFindLiteralStatementsNRLimitOffset = new org.openanzo.jdbc.utils.Transformer<FindLiteralStatementsNRLimitOffsetResult>() { public FindLiteralStatementsNRLimitOffsetResult transform(java.sql.ResultSet rs) { FindLiteralStatementsNRLimitOffsetResult result = new FindLiteralStatementsNRLimitOffsetResult(); try { result.namedGraphId = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:namedGraphId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.subj = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:subj", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.prop = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:prop", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.obj = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:obj", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the findLiteralStatementsNRLimitOffset prepared statement. * <code> * SELECT NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT FROM STATEMENTS_NR WHERE COMMITTED=0 AND OBJECT > 2305843009213693953 and OBJECT < 6917529027641081855 ORDER BY NAMEDGRAPHID ASC LIMIT ? OFFSET ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param start template parameter *@param end template parameter * *@param sessionPrefix template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRLimitOffsetResult> findLiteralStatementsNRLimitOffset( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long start, long end, String sessionPrefix) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findLiteralStatementsNRLimitOffset, new String[] { sessionPrefix }, connection); int argc = 1; ps.setLong(argc++, start); ps.setLong(argc++, end); java.sql.ResultSet rs = null; try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } org.openanzo.jdbc.utils.ClosableIterator<FindLiteralStatementsNRLimitOffsetResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FindLiteralStatementsNRLimitOffsetResult>( rs, ps, stmtProvider, transformFindLiteralStatementsNRLimitOffset); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findLiteralStatementsNRLimitOffset", stmtProvider.getSqlString(findLiteralStatementsNRLimitOffset), "" + "start=" + (start) + "," + "end=" + (end), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findLiteralStatementsNRLimitOffset]"+endtimer); } } /** *Default implementation of FindLiteralStatementsNRLimitOffsetResult */ public static class FindLiteralStatementsNRLimitOffsetResult { /**Value for the "namedGraphId" result value*/ private long namedGraphId; /**Value for the "subj" result value*/ private long subj; /**Value for the "prop" result value*/ private long prop; /**Value for the "obj" result value*/ private long obj; /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } /** *Get Subj value *@return Subj value */ public long getSubj() { return this.subj; } /** *Get Prop value *@return Prop value */ public long getProp() { return this.prop; } /** *Get Obj value *@return Obj value */ public long getObj() { return this.obj; } } }