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 /** * Backup provides wrappers around SQL queries and transforms ResultSets into java objects * * @author Generated Source from org.openanzo.jdbc.utils.opgen.jet */ public class Backup { private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Backup.class); static final long CUTOFF = 5; /** *Constant "selectDistinctRevisionedUUIDs" used to reference prepared statement Backup.selectDistinctRevisionedUUIDs * * <code> * SELECT DISTINCT UUID FROM NAMEDGRAPHS; * </code> */ public static final String selectDistinctRevisionedUUIDs = "Backup.selectDistinctRevisionedUUIDs"; /** *Constant "selectRevisionedGraphUUIDs" used to reference prepared statement Backup.selectRevisionedGraphUUIDs * * <code> * SELECT DISTINCT UUID FROM NAMEDGRAPHS WHERE ID=?; * </code> */ public static final String selectRevisionedGraphUUIDs = "Backup.selectRevisionedGraphUUIDs"; /** *Constant "selectDistinctNonRevisionedUUIDs" used to reference prepared statement Backup.selectDistinctNonRevisionedUUIDs * * <code> * SELECT DISTINCT UUID FROM NAMEDGRAPHS_NR; * </code> */ public static final String selectDistinctNonRevisionedUUIDs = "Backup.selectDistinctNonRevisionedUUIDs"; /** *Constant "selectNonRevisionedGraphUUIDs" used to reference prepared statement Backup.selectNonRevisionedGraphUUIDs * * <code> * SELECT DISTINCT UUID FROM NAMEDGRAPHS_NR WHERE ID=?; * </code> */ public static final String selectNonRevisionedGraphUUIDs = "Backup.selectNonRevisionedGraphUUIDs"; /** *Constant "selectNamedGraphsRevisioned" used to reference prepared statement Backup.selectNamedGraphsRevisioned * * <code> * SELECT ID,METAID,REVISION,HSTART,HEND,LASTMODIFIEDBY FROM NAMEDGRAPHS WHERE UUID=? ORDER BY REVISION ; * </code> */ public static final String selectNamedGraphsRevisioned = "Backup.selectNamedGraphsRevisioned"; /** *Constant "purgeNamedGraphRevisioned" used to reference prepared statement Backup.purgeNamedGraphRevisioned * * <code> * DELETE FROM NAMEDGRAPHS WHERE ID=? * </code> */ public static final String purgeNamedGraphRevisioned = "Backup.purgeNamedGraphRevisioned"; /** *Constant "purgeNamedGraphNonRevisioned" used to reference prepared statement Backup.purgeNamedGraphNonRevisioned * * <code> * DELETE FROM NAMEDGRAPHS_NR WHERE ID=? * </code> */ public static final String purgeNamedGraphNonRevisioned = "Backup.purgeNamedGraphNonRevisioned"; /** *Constant "purgeNamedGraphStatementsRevisioned" used to reference prepared statement Backup.purgeNamedGraphStatementsRevisioned * * <code> * DELETE FROM STATEMENTS WHERE (NAMEDGRAPHID=? OR NAMEDGRAPHID=?) * </code> */ public static final String purgeNamedGraphStatementsRevisioned = "Backup.purgeNamedGraphStatementsRevisioned"; /** *Constant "purgeNamedGraphStatementsNonRevisioned" used to reference prepared statement Backup.purgeNamedGraphStatementsNonRevisioned * * <code> * DELETE FROM STATEMENTS_NR WHERE (NAMEDGRAPHID=? OR NAMEDGRAPHID=?) * </code> */ public static final String purgeNamedGraphStatementsNonRevisioned = "Backup.purgeNamedGraphStatementsNonRevisioned"; /** *Constant "selectStatementsRevisioned" used to reference prepared statement Backup.selectStatementsRevisioned * * <code> * SELECT SUBJECT,PREDICATE,OBJECT,RSTART,REND FROM STATEMENTS WHERE UUID=? AND NAMEDGRAPHID=? ORDER BY (RSTART); * </code> */ public static final String selectStatementsRevisioned = "Backup.selectStatementsRevisioned"; /** *Constant "selectNamedGraphsNonRevisioned" used to reference prepared statement Backup.selectNamedGraphsNonRevisioned * * <code> * SELECT ID,METAID,REVISION,HSTART,LASTMODIFIEDBY FROM NAMEDGRAPHS_NR WHERE UUID=? ORDER BY REVISION; * </code> */ public static final String selectNamedGraphsNonRevisioned = "Backup.selectNamedGraphsNonRevisioned"; /** *Constant "selectStatementsNonRevisioned" used to reference prepared statement Backup.selectStatementsNonRevisioned * * <code> * SELECT SUBJECT,PREDICATE,OBJECT FROM STATEMENTS_NR WHERE NAMEDGRAPHID=?; * </code> */ public static final String selectStatementsNonRevisioned = "Backup.selectStatementsNonRevisioned"; /** *Constant "restoreNamedGraph" used to reference prepared statement Backup.restoreNamedGraph * * <code> * INSERT INTO NAMEDGRAPHS (HSTART,HEND, ID, METAID,UUID,REVISION,LASTMODIFIEDBY,COMMITTED) VALUES (?,?, ?, ?,?, ?,?,0); * </code> */ public static final String restoreNamedGraph = "Backup.restoreNamedGraph"; /** *Constant "restoreNamedGraphNR" used to reference prepared statement Backup.restoreNamedGraphNR * * <code> * INSERT INTO NAMEDGRAPHS_NR (HSTART, ID, METAID,UUID, REVISION,LASTMODIFIEDBY,COMMITTED) VALUES (?, ?,?,?,?,?,0); * </code> */ public static final String restoreNamedGraphNR = "Backup.restoreNamedGraphNR"; /** *Constant "restoreStatement" used to reference prepared statement Backup.restoreStatement * * <code> * INSERT INTO STATEMENTS(ID,METADATA,UUID,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,RSTART,REND,COMMITTED) VALUES (?,?,?,?,?,?,?,?,?,0); * </code> */ public static final String restoreStatement = "Backup.restoreStatement"; /** *Constant "restoreStatementNR" used to reference prepared statement Backup.restoreStatementNR * * <code> * INSERT INTO STATEMENTS_NR(ID,METADATA,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,COMMITTED) VALUES (?, ?,?, ?, ?, ?,0); * </code> */ public static final String restoreStatementNR = "Backup.restoreStatementNR"; /** *Constant "replaceStatement" used to reference prepared statement Backup.replaceStatement * * <code> * UPDATE STATEMENTS SET STATEMENTS.ID=?, STATEMENTS.OBJECT=? WHERE STATEMENTS.ID=? * </code> */ public static final String replaceStatement = "Backup.replaceStatement"; /** *Constant "replaceStatementNR" used to reference prepared statement Backup.replaceStatementNR * * <code> * UPDATE STATEMENTS_NR SET STATEMENTS_NR.ID=?, STATEMENTS_NR.OBJECT=? WHERE STATEMENTS_NR.ID=? * </code> */ public static final String replaceStatementNR = "Backup.replaceStatementNR"; /** *Constant "selectFullStatements" used to reference prepared statement Backup.selectFullStatements * * <code> * SELECT ID,UUID,SUBJECT,PREDICATE,OBJECT,NAMEDGRAPHID,RSTART,REND FROM STATEMENTS WHERE PREDICATE=? AND METADATA=1; * </code> */ public static final String selectFullStatements = "Backup.selectFullStatements"; /** *Constant "selectFullStatementsNR" used to reference prepared statement Backup.selectFullStatementsNR * * <code> * SELECT ID,SUBJECT,PREDICATE,OBJECT,NAMEDGRAPHID FROM STATEMENTS_NR WHERE PREDICATE=? AND METADATA=1 * </code> */ public static final String selectFullStatementsNR = "Backup.selectFullStatementsNR"; /** * Transformer that transforms the rows in the result set for the selectDistinctRevisionedUUIDs prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<Long> transformSelectDistinctRevisionedUUIDs = 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 selectDistinctRevisionedUUIDs prepared statement. * <code> * SELECT DISTINCT UUID FROM NAMEDGRAPHS; * </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<Long> selectDistinctRevisionedUUIDs( 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(selectDistinctRevisionedUUIDs, 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<Long> iter = new org.openanzo.jdbc.utils.ResultSetIterator<Long>( rs, ps, stmtProvider, transformSelectDistinctRevisionedUUIDs); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectDistinctRevisionedUUIDs", stmtProvider.getSqlString(selectDistinctRevisionedUUIDs), "", ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectDistinctRevisionedUUIDs]"+endtimer); } } /** * Transformer that transforms the rows in the result set for the selectRevisionedGraphUUIDs prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<Long> transformSelectRevisionedGraphUUIDs = 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 selectRevisionedGraphUUIDs prepared statement. * <code> * SELECT DISTINCT UUID FROM NAMEDGRAPHS WHERE ID=?; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param graphId template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<Long> selectRevisionedGraphUUIDs( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long graphId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectRevisionedGraphUUIDs, new String[] {}, connection); int argc = 1; ps.setLong(argc++, graphId); 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, transformSelectRevisionedGraphUUIDs); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectRevisionedGraphUUIDs", stmtProvider.getSqlString(selectRevisionedGraphUUIDs), "" + "graphId=" + (graphId), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectRevisionedGraphUUIDs]"+endtimer); } } /** * Transformer that transforms the rows in the result set for the selectDistinctNonRevisionedUUIDs prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<Long> transformSelectDistinctNonRevisionedUUIDs = 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 selectDistinctNonRevisionedUUIDs prepared statement. * <code> * SELECT DISTINCT UUID FROM NAMEDGRAPHS_NR; * </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<Long> selectDistinctNonRevisionedUUIDs( 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(selectDistinctNonRevisionedUUIDs, 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<Long> iter = new org.openanzo.jdbc.utils.ResultSetIterator<Long>( rs, ps, stmtProvider, transformSelectDistinctNonRevisionedUUIDs); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectDistinctNonRevisionedUUIDs", stmtProvider.getSqlString(selectDistinctNonRevisionedUUIDs), "", ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectDistinctNonRevisionedUUIDs]"+endtimer); } } /** * Transformer that transforms the rows in the result set for the selectNonRevisionedGraphUUIDs prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<Long> transformSelectNonRevisionedGraphUUIDs = 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 selectNonRevisionedGraphUUIDs prepared statement. * <code> * SELECT DISTINCT UUID FROM NAMEDGRAPHS_NR WHERE ID=?; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param graphId template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<Long> selectNonRevisionedGraphUUIDs( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long graphId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectNonRevisionedGraphUUIDs, new String[] {}, connection); int argc = 1; ps.setLong(argc++, graphId); 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, transformSelectNonRevisionedGraphUUIDs); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectNonRevisionedGraphUUIDs", stmtProvider.getSqlString(selectNonRevisionedGraphUUIDs), "" + "graphId=" + (graphId), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectNonRevisionedGraphUUIDs]"+endtimer); } } /** * Transformer that transforms the rows in the result set for the selectNamedGraphsRevisioned prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<SelectNamedGraphsRevisionedResult> transformSelectNamedGraphsRevisioned = new org.openanzo.jdbc.utils.Transformer<SelectNamedGraphsRevisionedResult>() { public SelectNamedGraphsRevisionedResult transform(java.sql.ResultSet rs) { SelectNamedGraphsRevisionedResult result = new SelectNamedGraphsRevisionedResult(); 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.metaId = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:metaId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.revision = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:revision", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.hstart = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:hstart", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.hend = rs.getLong(5); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:hend", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.lastModifiedBy = rs.getLong(6); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:lastModifiedBy", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the selectNamedGraphsRevisioned prepared statement. * <code> * SELECT ID,METAID,REVISION,HSTART,HEND,LASTMODIFIEDBY FROM NAMEDGRAPHS WHERE UUID=? ORDER BY REVISION ; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param uuid template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<SelectNamedGraphsRevisionedResult> selectNamedGraphsRevisioned( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long uuid) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectNamedGraphsRevisioned, new String[] {}, connection); int argc = 1; ps.setLong(argc++, uuid); 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<SelectNamedGraphsRevisionedResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectNamedGraphsRevisionedResult>( rs, ps, stmtProvider, transformSelectNamedGraphsRevisioned); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectNamedGraphsRevisioned", stmtProvider.getSqlString(selectNamedGraphsRevisioned), "" + "uuid=" + (uuid), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectNamedGraphsRevisioned]"+endtimer); } } /** *Default implementation of SelectNamedGraphsRevisionedResult */ public static class SelectNamedGraphsRevisionedResult { /**Value for the "id" result value*/ private long id; /**Value for the "metaId" result value*/ private long metaId; /**Value for the "revision" result value*/ private long revision; /**Value for the "hstart" result value*/ private long hstart; /**Value for the "hend" result value*/ private long hend; /**Value for the "lastModifiedBy" result value*/ private long lastModifiedBy; /** *Get Id value *@return Id value */ public long getId() { return this.id; } /** *Get MetaId value *@return MetaId value */ public long getMetaId() { return this.metaId; } /** *Get Revision value *@return Revision value */ public long getRevision() { return this.revision; } /** *Get Hstart value *@return Hstart value */ public long getHstart() { return this.hstart; } /** *Get Hend value *@return Hend value */ public long getHend() { return this.hend; } /** *Get LastModifiedBy value *@return LastModifiedBy value */ public long getLastModifiedBy() { return this.lastModifiedBy; } } /** * Runs the purgeNamedGraphRevisioned prepared statement. * <code> * DELETE FROM NAMEDGRAPHS WHERE ID=? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param ngId template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int purgeNamedGraphRevisioned( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long ngId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(purgeNamedGraphRevisioned, new String[] {}, connection); int argc = 1; ps.setLong(argc++, ngId); 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, "purgeNamedGraphRevisioned", stmtProvider.getSqlString(purgeNamedGraphRevisioned), "" + "ngId=" + (ngId), ""); } 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("[purgeNamedGraphRevisioned]"+endtimer); } } /** *Batch operation for adding parameters to the PurgeNamedGraphRevisioned prepared statement */ public static class BatchPurgeNamedGraphRevisioned extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the PurgeNamedGraphRevisioned prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchPurgeNamedGraphRevisioned(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, purgeNamedGraphRevisioned, new String[] {}); } /** * Sets the input parameters for the purgeNamedGraphRevisioned prepared statement. * *@param ngId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long ngId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, ngId); 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 purgeNamedGraphNonRevisioned prepared statement. * <code> * DELETE FROM NAMEDGRAPHS_NR WHERE ID=? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param ngId template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int purgeNamedGraphNonRevisioned( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long ngId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(purgeNamedGraphNonRevisioned, new String[] {}, connection); int argc = 1; ps.setLong(argc++, ngId); 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, "purgeNamedGraphNonRevisioned", stmtProvider.getSqlString(purgeNamedGraphNonRevisioned), "" + "ngId=" + (ngId), ""); } 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("[purgeNamedGraphNonRevisioned]"+endtimer); } } /** *Batch operation for adding parameters to the PurgeNamedGraphNonRevisioned prepared statement */ public static class BatchPurgeNamedGraphNonRevisioned extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the PurgeNamedGraphNonRevisioned prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchPurgeNamedGraphNonRevisioned(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, purgeNamedGraphNonRevisioned, new String[] {}); } /** * Sets the input parameters for the purgeNamedGraphNonRevisioned prepared statement. * *@param ngId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long ngId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, ngId); 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 purgeNamedGraphStatementsRevisioned prepared statement. * <code> * DELETE FROM STATEMENTS WHERE (NAMEDGRAPHID=? OR NAMEDGRAPHID=?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param ngId template parameter *@param metaId template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int purgeNamedGraphStatementsRevisioned( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long ngId, long metaId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(purgeNamedGraphStatementsRevisioned, new String[] {}, connection); int argc = 1; ps.setLong(argc++, ngId); ps.setLong(argc++, metaId); 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, "purgeNamedGraphStatementsRevisioned", stmtProvider.getSqlString(purgeNamedGraphStatementsRevisioned), "" + "ngId=" + (ngId) + "," + "metaId=" + (metaId), ""); } 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("[purgeNamedGraphStatementsRevisioned]"+endtimer); } } /** *Batch operation for adding parameters to the PurgeNamedGraphStatementsRevisioned prepared statement */ public static class BatchPurgeNamedGraphStatementsRevisioned extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the PurgeNamedGraphStatementsRevisioned prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchPurgeNamedGraphStatementsRevisioned(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, purgeNamedGraphStatementsRevisioned, new String[] {}); } /** * Sets the input parameters for the purgeNamedGraphStatementsRevisioned prepared statement. * *@param ngId template parameter *@param metaId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long ngId, long metaId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, ngId); ps.setLong(argc++, metaId); 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 purgeNamedGraphStatementsNonRevisioned prepared statement. * <code> * DELETE FROM STATEMENTS_NR WHERE (NAMEDGRAPHID=? OR NAMEDGRAPHID=?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param ngId template parameter *@param metaId template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int purgeNamedGraphStatementsNonRevisioned( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long ngId, long metaId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(purgeNamedGraphStatementsNonRevisioned, new String[] {}, connection); int argc = 1; ps.setLong(argc++, ngId); ps.setLong(argc++, metaId); 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, "purgeNamedGraphStatementsNonRevisioned", stmtProvider.getSqlString(purgeNamedGraphStatementsNonRevisioned), "" + "ngId=" + (ngId) + "," + "metaId=" + (metaId), ""); } 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("[purgeNamedGraphStatementsNonRevisioned]"+endtimer); } } /** *Batch operation for adding parameters to the PurgeNamedGraphStatementsNonRevisioned prepared statement */ public static class BatchPurgeNamedGraphStatementsNonRevisioned extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the PurgeNamedGraphStatementsNonRevisioned prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchPurgeNamedGraphStatementsNonRevisioned(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, purgeNamedGraphStatementsNonRevisioned, new String[] {}); } /** * Sets the input parameters for the purgeNamedGraphStatementsNonRevisioned prepared statement. * *@param ngId template parameter *@param metaId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long ngId, long metaId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, ngId); ps.setLong(argc++, metaId); 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 selectStatementsRevisioned prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<SelectStatementsRevisionedResult> transformSelectStatementsRevisioned = new org.openanzo.jdbc.utils.Transformer<SelectStatementsRevisionedResult>() { public SelectStatementsRevisionedResult transform(java.sql.ResultSet rs) { SelectStatementsRevisionedResult result = new SelectStatementsRevisionedResult(); try { result.subject = rs.getLong(1); } 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(2); } 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(3); } 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); } try { result.start = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:start", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.end = rs.getLong(5); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:end", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the selectStatementsRevisioned prepared statement. * <code> * SELECT SUBJECT,PREDICATE,OBJECT,RSTART,REND FROM STATEMENTS WHERE UUID=? AND NAMEDGRAPHID=? ORDER BY (RSTART); * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param uuid template parameter *@param ngId template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<SelectStatementsRevisionedResult> selectStatementsRevisioned( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long uuid, long ngId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectStatementsRevisioned, new String[] {}, connection); int argc = 1; ps.setLong(argc++, uuid); ps.setLong(argc++, ngId); 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<SelectStatementsRevisionedResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectStatementsRevisionedResult>( rs, ps, stmtProvider, transformSelectStatementsRevisioned); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectStatementsRevisioned", stmtProvider.getSqlString(selectStatementsRevisioned), "" + "uuid=" + (uuid) + "," + "ngId=" + (ngId), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectStatementsRevisioned]"+endtimer); } } /** *Default implementation of SelectStatementsRevisionedResult */ public static class SelectStatementsRevisionedResult { /**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; /**Value for the "start" result value*/ private long start; /**Value for the "end" result value*/ private long end; /** *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; } /** *Get Start value *@return Start value */ public long getStart() { return this.start; } /** *Get End value *@return End value */ public long getEnd() { return this.end; } } /** * Transformer that transforms the rows in the result set for the selectNamedGraphsNonRevisioned prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<SelectNamedGraphsNonRevisionedResult> transformSelectNamedGraphsNonRevisioned = new org.openanzo.jdbc.utils.Transformer<SelectNamedGraphsNonRevisionedResult>() { public SelectNamedGraphsNonRevisionedResult transform(java.sql.ResultSet rs) { SelectNamedGraphsNonRevisionedResult result = new SelectNamedGraphsNonRevisionedResult(); 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.metaId = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:metaId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.revision = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:revision", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.hstart = rs.getLong(4); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:hstart", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.lastModifiedBy = rs.getLong(5); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:lastModifiedBy", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the selectNamedGraphsNonRevisioned prepared statement. * <code> * SELECT ID,METAID,REVISION,HSTART,LASTMODIFIEDBY FROM NAMEDGRAPHS_NR WHERE UUID=? ORDER BY REVISION; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param uuid template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<SelectNamedGraphsNonRevisionedResult> selectNamedGraphsNonRevisioned( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long uuid) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectNamedGraphsNonRevisioned, new String[] {}, connection); int argc = 1; ps.setLong(argc++, uuid); 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<SelectNamedGraphsNonRevisionedResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectNamedGraphsNonRevisionedResult>( rs, ps, stmtProvider, transformSelectNamedGraphsNonRevisioned); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectNamedGraphsNonRevisioned", stmtProvider.getSqlString(selectNamedGraphsNonRevisioned), "" + "uuid=" + (uuid), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectNamedGraphsNonRevisioned]"+endtimer); } } /** *Default implementation of SelectNamedGraphsNonRevisionedResult */ public static class SelectNamedGraphsNonRevisionedResult { /**Value for the "id" result value*/ private long id; /**Value for the "metaId" result value*/ private long metaId; /**Value for the "revision" result value*/ private long revision; /**Value for the "hstart" result value*/ private long hstart; /**Value for the "lastModifiedBy" result value*/ private long lastModifiedBy; /** *Get Id value *@return Id value */ public long getId() { return this.id; } /** *Get MetaId value *@return MetaId value */ public long getMetaId() { return this.metaId; } /** *Get Revision value *@return Revision value */ public long getRevision() { return this.revision; } /** *Get Hstart value *@return Hstart value */ public long getHstart() { return this.hstart; } /** *Get LastModifiedBy value *@return LastModifiedBy value */ public long getLastModifiedBy() { return this.lastModifiedBy; } } /** * Transformer that transforms the rows in the result set for the selectStatementsNonRevisioned prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<SelectStatementsNonRevisionedResult> transformSelectStatementsNonRevisioned = new org.openanzo.jdbc.utils.Transformer<SelectStatementsNonRevisionedResult>() { public SelectStatementsNonRevisionedResult transform(java.sql.ResultSet rs) { SelectStatementsNonRevisionedResult result = new SelectStatementsNonRevisionedResult(); try { result.subject = rs.getLong(1); } 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(2); } 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(3); } 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 selectStatementsNonRevisioned prepared statement. * <code> * SELECT SUBJECT,PREDICATE,OBJECT FROM STATEMENTS_NR WHERE NAMEDGRAPHID=?; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param graphId template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<SelectStatementsNonRevisionedResult> selectStatementsNonRevisioned( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long graphId) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectStatementsNonRevisioned, new String[] {}, connection); int argc = 1; ps.setLong(argc++, graphId); 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<SelectStatementsNonRevisionedResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectStatementsNonRevisionedResult>( rs, ps, stmtProvider, transformSelectStatementsNonRevisioned); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectStatementsNonRevisioned", stmtProvider.getSqlString(selectStatementsNonRevisioned), "" + "graphId=" + (graphId), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectStatementsNonRevisioned]"+endtimer); } } /** *Default implementation of SelectStatementsNonRevisionedResult */ public static class SelectStatementsNonRevisionedResult { /**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 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; } } /** * Runs the restoreNamedGraph prepared statement. * <code> * INSERT INTO NAMEDGRAPHS (HSTART,HEND, ID, METAID,UUID,REVISION,LASTMODIFIEDBY,COMMITTED) VALUES (?,?, ?, ?,?, ?,?,0); * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param start template parameter *@param end template parameter *@param namedgraphid template parameter *@param metadataId template parameter *@param uuid template parameter *@param revision template parameter *@param lastModifiedBy template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int restoreNamedGraph(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long start, Long end, long namedgraphid, long metadataId, long uuid, long revision, long lastModifiedBy) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(restoreNamedGraph, new String[] {}, connection); int argc = 1; ps.setLong(argc++, start); if (end == null) { ps.setNull(argc++, java.sql.Types.BIGINT); } else { ps.setLong(argc++, end); } ps.setLong(argc++, namedgraphid); ps.setLong(argc++, metadataId); ps.setLong(argc++, uuid); ps.setLong(argc++, revision); ps.setLong(argc++, lastModifiedBy); 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, "restoreNamedGraph", stmtProvider.getSqlString(restoreNamedGraph), "" + "start=" + (start) + "," + "end=" + ((end != null) ? end.toString() : "null") + "," + "namedgraphid=" + (namedgraphid) + "," + "metadataId=" + (metadataId) + "," + "uuid=" + (uuid) + "," + "revision=" + (revision) + "," + "lastModifiedBy=" + (lastModifiedBy), ""); } 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("[restoreNamedGraph]"+endtimer); } } /** *Batch operation for adding parameters to the RestoreNamedGraph prepared statement */ public static class BatchRestoreNamedGraph extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the RestoreNamedGraph prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchRestoreNamedGraph(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, restoreNamedGraph, new String[] {}); } /** * Sets the input parameters for the restoreNamedGraph prepared statement. * *@param start template parameter *@param end template parameter *@param namedgraphid template parameter *@param metadataId template parameter *@param uuid template parameter *@param revision template parameter *@param lastModifiedBy template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long start, Long end, long namedgraphid, long metadataId, long uuid, long revision, long lastModifiedBy) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, start); if (end == null) { ps.setNull(argc++, java.sql.Types.BIGINT); } else { ps.setLong(argc++, end); } ps.setLong(argc++, namedgraphid); ps.setLong(argc++, metadataId); ps.setLong(argc++, uuid); ps.setLong(argc++, revision); ps.setLong(argc++, lastModifiedBy); 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 restoreNamedGraphNR prepared statement. * <code> * INSERT INTO NAMEDGRAPHS_NR (HSTART, ID, METAID,UUID, REVISION,LASTMODIFIEDBY,COMMITTED) VALUES (?, ?,?,?,?,?,0); * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param modified template parameter *@param namedgraphid template parameter *@param metadataId template parameter *@param uuid template parameter *@param revision template parameter *@param lastModifiedBy template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int restoreNamedGraphNR(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long modified, long namedgraphid, long metadataId, long uuid, long revision, long lastModifiedBy) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(restoreNamedGraphNR, new String[] {}, connection); int argc = 1; ps.setLong(argc++, modified); ps.setLong(argc++, namedgraphid); ps.setLong(argc++, metadataId); ps.setLong(argc++, uuid); ps.setLong(argc++, revision); ps.setLong(argc++, lastModifiedBy); 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, "restoreNamedGraphNR", stmtProvider.getSqlString(restoreNamedGraphNR), "" + "modified=" + (modified) + "," + "namedgraphid=" + (namedgraphid) + "," + "metadataId=" + (metadataId) + "," + "uuid=" + (uuid) + "," + "revision=" + (revision) + "," + "lastModifiedBy=" + (lastModifiedBy), ""); } 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("[restoreNamedGraphNR]"+endtimer); } } /** *Batch operation for adding parameters to the RestoreNamedGraphNR prepared statement */ public static class BatchRestoreNamedGraphNR extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the RestoreNamedGraphNR prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchRestoreNamedGraphNR(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, restoreNamedGraphNR, new String[] {}); } /** * Sets the input parameters for the restoreNamedGraphNR prepared statement. * *@param modified template parameter *@param namedgraphid template parameter *@param metadataId template parameter *@param uuid template parameter *@param revision template parameter *@param lastModifiedBy template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long modified, long namedgraphid, long metadataId, long uuid, long revision, long lastModifiedBy) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, modified); ps.setLong(argc++, namedgraphid); ps.setLong(argc++, metadataId); ps.setLong(argc++, uuid); ps.setLong(argc++, revision); ps.setLong(argc++, lastModifiedBy); 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 restoreStatement prepared statement. * <code> * INSERT INTO STATEMENTS(ID,METADATA,UUID,NAMEDGRAPHID, SUBJECT, PREDICATE, OBJECT,RSTART,REND,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 *@param rend template parameter * *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int restoreStatement(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, Long rend) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(restoreStatement, new String[] {}, connection); int argc = 1; if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "restoreStatement"); } 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); if (rend == null) { ps.setNull(argc++, java.sql.Types.BIGINT); } else { ps.setLong(argc++, rend); } 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, "restoreStatement", stmtProvider.getSqlString(restoreStatement), "" + "id=" + ((id != null) ? id.toString() : "null") + "," + "metadata=" + (metadata) + "," + "uuid=" + (uuid) + "," + "namedGraphId=" + (namedGraphId) + "," + "subject=" + (subject) + "," + "predicate=" + (predicate) + "," + "object=" + (object) + "," + "rstart=" + (rstart) + "," + "rend=" + ((rend != null) ? rend.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("[restoreStatement]"+endtimer); } } /** *Batch operation for adding parameters to the RestoreStatement prepared statement */ public static class BatchRestoreStatement extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the RestoreStatement prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchRestoreStatement(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, restoreStatement, new String[] {}); } /** * Sets the input parameters for the restoreStatement 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 *@param rend 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, Long rend) 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", "restoreStatement"); } 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); if (rend == null) { ps.setNull(argc++, java.sql.Types.BIGINT); } else { ps.setLong(argc++, rend); } 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 restoreStatementNR 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 restoreStatementNR(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(restoreStatementNR, new String[] {}, connection); int argc = 1; if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "restoreStatementNR"); } 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, "restoreStatementNR", stmtProvider.getSqlString(restoreStatementNR), "" + "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("[restoreStatementNR]"+endtimer); } } /** *Batch operation for adding parameters to the RestoreStatementNR prepared statement */ public static class BatchRestoreStatementNR extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the RestoreStatementNR prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchRestoreStatementNR(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, restoreStatementNR, new String[] {}); } /** * Sets the input parameters for the restoreStatementNR 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", "restoreStatementNR"); } 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 replaceStatement prepared statement. * <code> * UPDATE STATEMENTS SET STATEMENTS.ID=?, STATEMENTS.OBJECT=? WHERE STATEMENTS.ID=? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param newId template parameter *@param oid template parameter *@param id template parameter * * *@throws org.openanzo.jdbc.utils.RdbException */ public static void replaceStatement(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String newId, long oid, String id) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(replaceStatement, new String[] {}, connection); int argc = 1; if (newId == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "newId", "replaceStatement"); } else { ps.setString(argc++, newId); } ps.setLong(argc++, oid); if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "replaceStatement"); } else { ps.setString(argc++, id); } 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, "replaceStatement", stmtProvider.getSqlString(replaceStatement), "" + "newId=" + ((newId != null) ? newId.toString() : "null") + "," + "oid=" + (oid) + "," + "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("[replaceStatement]"+endtimer); } } /** *Batch operation for adding parameters to the ReplaceStatement prepared statement */ public static class BatchReplaceStatement extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the ReplaceStatement prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchReplaceStatement(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, replaceStatement, new String[] {}); } /** * Sets the input parameters for the replaceStatement prepared statement. * *@param newId template parameter *@param oid template parameter *@param id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(String newId, long oid, String id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; if (newId == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "newId", "replaceStatement"); } else { ps.setString(argc++, newId); } ps.setLong(argc++, oid); if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "replaceStatement"); } 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 replaceStatementNR prepared statement. * <code> * UPDATE STATEMENTS_NR SET STATEMENTS_NR.ID=?, STATEMENTS_NR.OBJECT=? WHERE STATEMENTS_NR.ID=? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param newId template parameter *@param oid template parameter *@param id template parameter * * *@throws org.openanzo.jdbc.utils.RdbException */ public static void replaceStatementNR(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String newId, long oid, String id) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(replaceStatementNR, new String[] {}, connection); int argc = 1; if (newId == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "newId", "replaceStatementNR"); } else { ps.setString(argc++, newId); } ps.setLong(argc++, oid); if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "replaceStatementNR"); } else { ps.setString(argc++, id); } 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, "replaceStatementNR", stmtProvider.getSqlString(replaceStatementNR), "" + "newId=" + ((newId != null) ? newId.toString() : "null") + "," + "oid=" + (oid) + "," + "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("[replaceStatementNR]"+endtimer); } } /** *Batch operation for adding parameters to the ReplaceStatementNR prepared statement */ public static class BatchReplaceStatementNR extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the ReplaceStatementNR prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * * @throws org.openanzo.jdbc.utils.RdbException */ public BatchReplaceStatementNR(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, replaceStatementNR, new String[] {}); } /** * Sets the input parameters for the replaceStatementNR prepared statement. * *@param newId template parameter *@param oid template parameter *@param id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(String newId, long oid, String id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; if (newId == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "newId", "replaceStatementNR"); } else { ps.setString(argc++, newId); } ps.setLong(argc++, oid); if (id == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "id", "replaceStatementNR"); } 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); } } } /** * Transformer that transforms the rows in the result set for the selectFullStatements prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<SelectFullStatementsResult> transformSelectFullStatements = new org.openanzo.jdbc.utils.Transformer<SelectFullStatementsResult>() { public SelectFullStatementsResult transform(java.sql.ResultSet rs) { SelectFullStatementsResult result = new SelectFullStatementsResult(); try { result.id = rs.getString(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.uuid = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:uuid", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.subject = rs.getLong(3); } 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(4); } 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(5); } 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); } try { result.namedGraphId = rs.getLong(6); } 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.start = rs.getLong(7); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:start", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.end = rs.getLong(8); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:end", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the selectFullStatements prepared statement. * <code> * SELECT ID,UUID,SUBJECT,PREDICATE,OBJECT,NAMEDGRAPHID,RSTART,REND FROM STATEMENTS WHERE PREDICATE=? AND METADATA=1; * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param pid template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<SelectFullStatementsResult> selectFullStatements( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long pid) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectFullStatements, new String[] {}, connection); int argc = 1; ps.setLong(argc++, pid); 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<SelectFullStatementsResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectFullStatementsResult>( rs, ps, stmtProvider, transformSelectFullStatements); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectFullStatements", stmtProvider.getSqlString(selectFullStatements), "" + "pid=" + (pid), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectFullStatements]"+endtimer); } } /** *Default implementation of SelectFullStatementsResult */ public static class SelectFullStatementsResult { /**Value for the "id" result value*/ private String id; /**Value for the "uuid" result value*/ private long uuid; /**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; /**Value for the "namedGraphId" result value*/ private long namedGraphId; /**Value for the "start" result value*/ private long start; /**Value for the "end" result value*/ private long end; /** *Get Id value *@return Id value */ public String getId() { return this.id; } /** *Get Uuid value *@return Uuid value */ public long getUuid() { return this.uuid; } /** *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; } /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } /** *Get Start value *@return Start value */ public long getStart() { return this.start; } /** *Get End value *@return End value */ public long getEnd() { return this.end; } } /** * Transformer that transforms the rows in the result set for the selectFullStatementsNR prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<SelectFullStatementsNRResult> transformSelectFullStatementsNR = new org.openanzo.jdbc.utils.Transformer<SelectFullStatementsNRResult>() { public SelectFullStatementsNRResult transform(java.sql.ResultSet rs) { SelectFullStatementsNRResult result = new SelectFullStatementsNRResult(); try { result.id = rs.getString(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.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); } try { result.namedGraphId = rs.getLong(5); } 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); } return result; } }; /** * Runs the selectFullStatementsNR prepared statement. * <code> * SELECT ID,SUBJECT,PREDICATE,OBJECT,NAMEDGRAPHID FROM STATEMENTS_NR WHERE PREDICATE=? AND METADATA=1 * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param pid template parameter * *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<SelectFullStatementsNRResult> selectFullStatementsNR( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long pid) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectFullStatementsNR, new String[] {}, connection); int argc = 1; ps.setLong(argc++, pid); 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<SelectFullStatementsNRResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectFullStatementsNRResult>( rs, ps, stmtProvider, transformSelectFullStatementsNR); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectFullStatementsNR", stmtProvider.getSqlString(selectFullStatementsNR), "" + "pid=" + (pid), ""); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectFullStatementsNR]"+endtimer); } } /** *Default implementation of SelectFullStatementsNRResult */ public static class SelectFullStatementsNRResult { /**Value for the "id" result value*/ private String id; /**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; /**Value for the "namedGraphId" result value*/ private long namedGraphId; /** *Get Id value *@return Id value */ public String getId() { return this.id; } /** *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; } /** *Get NamedGraphId value *@return NamedGraphId value */ public long getNamedGraphId() { return this.namedGraphId; } } }