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.jdbc.container.sql; // allow for all types that can be returned from a resultset /** * NodeSQL provides wrappers around SQL queries and transforms ResultSets into java objects * * @author Generated Source from org.openanzo.jdbc.utils.opgen.jet */ public class NodeSQL { private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(NodeSQL.class); static final long CUTOFF = 5; /** *Constant "getAllLiterals" used to reference prepared statement node.getAllLiterals * * <code> * SELECT ID,MODIFIER_ID,VALUE FROM {0} {1} * </code> */ public static final String getAllLiterals = "node.getAllLiterals"; /** *Constant "findNodeID" used to reference prepared statement node.findNodeID * * <code> * SELECT ID FROM {0} WHERE (MODIFIER_ID=0 OR MODIFIER_ID=?) AND VALUE LIKE ? {1} * </code> */ public static final String findNodeID = "node.findNodeID"; /** *Constant "fetchNodeID" used to reference prepared statement node.fetchNodeID * * <code> * SELECT ID FROM {0} WHERE VALUE = ? {1} * </code> */ public static final String fetchNodeID = "node.fetchNodeID"; /** *Constant "fetchNodeValue" used to reference prepared statement node.fetchNodeValue * * <code> * SELECT VALUE FROM {0} WHERE ID = ? {1} * </code> */ public static final String fetchNodeValue = "node.fetchNodeValue"; /** *Constant "fetchLongNodeID" used to reference prepared statement node.fetchLongNodeID * * <code> * SELECT ID,VALUE FROM {0} WHERE HASH = ? * </code> */ public static final String fetchLongNodeID = "node.fetchLongNodeID"; /** *Constant "fetchLiteralNodeValue" used to reference prepared statement node.fetchLiteralNodeValue * * <code> * SELECT VALUE, MODIFIER_ID FROM {0} WHERE ID = ? {1} * </code> */ public static final String fetchLiteralNodeValue = "node.fetchLiteralNodeValue"; /** *Constant "fetchLiteralNodeID" used to reference prepared statement node.fetchLiteralNodeID * * <code> * SELECT ID FROM {0} WHERE VALUE = ? AND MODIFIER_ID = ? {1} * </code> */ public static final String fetchLiteralNodeID = "node.fetchLiteralNodeID"; /** *Constant "fetchLongLiteralNodeID" used to reference prepared statement node.fetchLongLiteralNodeID * * <code> * SELECT ID,VALUE FROM {0} WHERE HASH = ? AND MODIFIER_ID = ? * </code> */ public static final String fetchLongLiteralNodeID = "node.fetchLongLiteralNodeID"; /** *Constant "insertCommonValue" used to reference prepared statement node.insertCommonValue * * <code> * INSERT INTO {0} (ID, VALUE) VALUES(?, ?) * </code> */ public static final String insertCommonValue = "node.insertCommonValue"; /** *Constant "insertCommonValueWithIdentity" used to reference prepared statement node.insertCommonValueWithIdentity * * <code> * INSERT INTO {0} ( VALUE) VALUES( ?) * </code> */ public static final String insertCommonValueWithIdentity = "node.insertCommonValueWithIdentity"; /** *Constant "fetchCommonValueID" used to reference prepared statement node.fetchCommonValueID * * <code> * SELECT ID FROM {0} WHERE VALUE = ? {1} * </code> */ public static final String fetchCommonValueID = "node.fetchCommonValueID"; /** *Constant "fetchCommonValue" used to reference prepared statement node.fetchCommonValue * * <code> * SELECT VALUE FROM {0} WHERE ID = ? {1} * </code> */ public static final String fetchCommonValue = "node.fetchCommonValue"; /** *Constant "fetchAllCommonValues" used to reference prepared statement node.fetchAllCommonValues * * <code> * SELECT ID, VALUE FROM {0} * </code> */ public static final String fetchAllCommonValues = "node.fetchAllCommonValues"; /** *Constant "storeBulkNode" used to reference prepared statement node.storeBulkNode * * <code> * INSERT INTO {0}{1} (ID, VALUE) VALUES(?, ?) * </code> */ public static final String storeBulkNode = "node.storeBulkNode"; /** *Constant "storeBulkLongNode" used to reference prepared statement node.storeBulkLongNode * * <code> * INSERT INTO {0}{1} (ID, HASH, VALUE) VALUES(?, ?, ?) * </code> */ public static final String storeBulkLongNode = "node.storeBulkLongNode"; /** *Constant "storeBulkLiteral" used to reference prepared statement node.storeBulkLiteral * * <code> * INSERT INTO {0}{1} (ID, VALUE, MODIFIER_ID) VALUES(?, ?, ?) * </code> */ public static final String storeBulkLiteral = "node.storeBulkLiteral"; /** *Constant "storeBulkLongLiteral" used to reference prepared statement node.storeBulkLongLiteral * * <code> * INSERT INTO {0}{1} (ID, VALUE, HASH, MODIFIER_ID) VALUES(?, ?, ?, ?) * </code> */ public static final String storeBulkLongLiteral = "node.storeBulkLongLiteral"; /** *Constant "countTempTable" used to reference prepared statement node.countTempTable * * <code> * SELECT COUNT(1) FROM {0}{1} * </code> */ public static final String countTempTable = "node.countTempTable"; /** *Constant "storeResolveId" used to reference prepared statement node.storeResolveId * * <code> * INSERT INTO {0}{1} (ID) VALUES(?) * </code> */ public static final String storeResolveId = "node.storeResolveId"; /** *Constant "storeResolveNode" used to reference prepared statement node.storeResolveNode * * <code> * INSERT INTO {0}{1} (ENTRYID,VALUE) VALUES(?,?) * </code> */ public static final String storeResolveNode = "node.storeResolveNode"; /** *Constant "storeResolveNodeLong" used to reference prepared statement node.storeResolveNodeLong * * <code> * INSERT INTO {0}{1} (VALUE,HASH) VALUES(?,?) * </code> */ public static final String storeResolveNodeLong = "node.storeResolveNodeLong"; /** *Constant "storeResolveLiteral" used to reference prepared statement node.storeResolveLiteral * * <code> * INSERT INTO {0}{1} (ENTRYID,VALUE,MODIFIER_ID) VALUES(?,?,?) * </code> */ public static final String storeResolveLiteral = "node.storeResolveLiteral"; /** *Constant "storeResolveLiteralLong" used to reference prepared statement node.storeResolveLiteralLong * * <code> * INSERT INTO {0}{1} (VALUE,HASH,MODIFIER_ID) VALUES(?,?,?) * </code> */ public static final String storeResolveLiteralLong = "node.storeResolveLiteralLong"; /** *Constant "resolveNodes" used to reference prepared statement node.resolveNodes * * <code> * SELECT {2}.ID,{2}.VALUE FROM {2},{0}{1} WHERE {2}.VALUE={0}{1}.VALUE * </code> */ public static final String resolveNodes = "node.resolveNodes"; /** *Constant "resolveLiterals" used to reference prepared statement node.resolveLiterals * * <code> * SELECT {2}.ID,{2}.VALUE,{2}.MODIFIER_ID FROM {2},{0}{1} WHERE {2}.VALUE={0}{1}.VALUE AND {2}.MODIFIER_ID = {0}{1}.MODIFIER_ID * </code> */ public static final String resolveLiterals = "node.resolveLiterals"; /** *Constant "resolveIdsUri" used to reference prepared statement node.resolveIdsUri * * <code> * SELECT {2}.ID,{2}.VALUE FROM {2},{0}{1} WHERE {2}.ID={0}{1}.ID AND {0}{1}.ID>=? AND {0}{1}.ID < ? * </code> */ public static final String resolveIdsUri = "node.resolveIdsUri"; /** *Constant "resolveTransactedIdsUri" used to reference prepared statement node.resolveTransactedIdsUri * * <code> * SELECT {2}.ID,{2}.VALUE FROM {2},{0}{1} WHERE {0}{1}.TRANSACTIONID=? AND {2}.ID={0}{1}.ID AND {0}{1}.ID>=? AND {0}{1}.ID < ? * </code> */ public static final String resolveTransactedIdsUri = "node.resolveTransactedIdsUri"; /** *Constant "updateResolvedUris" used to reference prepared statement node.updateResolvedUris * * <code> * UPDATE {0}{1} AS A SET TYPE=2,ID=(SELECT {2}.ID FROM {2} WHERE {2}.VALUE=A.VALUE AND {2}.REF=0) WHERE EXISTS (SELECT {2}.ID FROM {2} WHERE {2}.VALUE=A.VALUE AND {2}.REF=0) * </code> */ public static final String updateResolvedUris = "node.updateResolvedUris"; /** *Constant "resolveExistingUris" used to reference prepared statement node.resolveExistingUris * * <code> * INSERT INTO {0}{2} (ENTRYID,ID,TYPE) SELECT T.ENTRYID,N.ID,2 FROM {0}{1} T,{3} N WHERE N.VALUE=T.VALUE AND N.REF=0 * </code> */ public static final String resolveExistingUris = "node.resolveExistingUris"; /** *Constant "updateExistingUrisReferenceCount" used to reference prepared statement node.updateExistingUrisReferenceCount * * <code> * UPDATE {2} SET REF=REF+1 WHERE REF>0 AND VALUE IN (SELECT {0}{1}.VALUE FROM {0}{1}) * </code> */ public static final String updateExistingUrisReferenceCount = "node.updateExistingUrisReferenceCount"; /** *Constant "resolveExistingUncommittedUris" used to reference prepared statement node.resolveExistingUncommittedUris * * <code> * INSERT INTO {0}{2} (ENTRYID,ID,TYPE) SELECT T.ENTRYID,N.ID,3 FROM {0}{1} T,{3} N WHERE N.VALUE=T.VALUE AND N.REF>0 * </code> */ public static final String resolveExistingUncommittedUris = "node.resolveExistingUncommittedUris"; /** *Constant "purgeResolvedUris" used to reference prepared statement node.purgeResolvedUris * * <code> * DELETE FROM {0}{1} WHERE ENTRYID IN (SELECT {0}{2}.ENTRYID FROM {0}{2}) * </code> */ public static final String purgeResolvedUris = "node.purgeResolvedUris"; /** *Constant "insertUnresolvedUris" used to reference prepared statement node.insertUnresolvedUris * * <code> * * </code> */ public static final String insertUnresolvedUris = "node.insertUnresolvedUris"; /** *Constant "resolveExistingLiterals" used to reference prepared statement node.resolveExistingLiterals * * <code> * INSERT INTO {0}{2} (ENTRYID,ID,TYPE) SELECT T.ENTRYID,N.ID,2 FROM {0}{1} T,{3} N WHERE N.VALUE=T.VALUE AND N.MODIFIER_ID=T.MODIFIER_ID AND N.REF=0 * </code> */ public static final String resolveExistingLiterals = "node.resolveExistingLiterals"; /** *Constant "updateExistingLiteralsReferenceCount" used to reference prepared statement node.updateExistingLiteralsReferenceCount * * <code> * UPDATE {2} SET REF=REF+1 WHERE REF>0 AND EXISTS (SELECT {0}{1}.VALUE FROM {0}{1} WHERE {0}{1}.VALUE={2}.VALUE AND {0}{1}.MODIFIER_ID={2}.MODIFIER_ID) * </code> */ public static final String updateExistingLiteralsReferenceCount = "node.updateExistingLiteralsReferenceCount"; /** *Constant "resolveExistingUncommittedLiterals" used to reference prepared statement node.resolveExistingUncommittedLiterals * * <code> * INSERT INTO {0}{2} (ENTRYID,ID,TYPE) SELECT T.ENTRYID,N.ID,3 FROM {0}{1} T,{3} N WHERE N.VALUE=T.VALUE AND N.MODIFIER_ID=T.MODIFIER_ID AND N.REF>0 * </code> */ public static final String resolveExistingUncommittedLiterals = "node.resolveExistingUncommittedLiterals"; /** *Constant "purgeResolvedLiterals" used to reference prepared statement node.purgeResolvedLiterals * * <code> * DELETE FROM {0}{1} WHERE ENTRYID IN (SELECT {0}{2}.ENTRYID FROM {0}{2}) * </code> */ public static final String purgeResolvedLiterals = "node.purgeResolvedLiterals"; /** *Constant "insertUnresolvedLiterals" used to reference prepared statement node.insertUnresolvedLiterals * * <code> * * </code> */ public static final String insertUnresolvedLiterals = "node.insertUnresolvedLiterals"; /** *Constant "insertUncommittedReferences" used to reference prepared statement node.insertUncommittedReferences * * <code> * INSERT INTO {2} (ID,TRANSACTIONID) SELECT {0}{1}.ID,{3} FROM {0}{1} WHERE {0}{1}.TYPE IN (1,3) * </code> */ public static final String insertUncommittedReferences = "node.insertUncommittedReferences"; /** *Constant "insertLockedId" used to reference prepared statement node.insertLockedId * * <code> * INSERT INTO {0} (ID,TRANSACTIONID) VALUES(?,?) * </code> */ public static final String insertLockedId = "node.insertLockedId"; /** *Constant "commitUncommittedReferences" used to reference prepared statement node.commitUncommittedReferences * * <code> * UPDATE {1} SET REF=0 WHERE EXISTS (SELECT {0}.ID FROM {0} WHERE {0}.TRANSACTIONID=? AND {1}.ID={0}.ID) AND REF>0 * </code> */ public static final String commitUncommittedReferences = "node.commitUncommittedReferences"; /** *Constant "deleteUncommittedReferences" used to reference prepared statement node.deleteUncommittedReferences * * <code> * DELETE FROM {1} WHERE REF=1 AND EXISTS (SELECT {0}.ID FROM {0} WHERE {0}.TRANSACTIONID=? AND {1}.ID={0}.ID) * </code> */ public static final String deleteUncommittedReferences = "node.deleteUncommittedReferences"; /** *Constant "decrementUncommittedReferences" used to reference prepared statement node.decrementUncommittedReferences * * <code> * UPDATE {1} SET REF=REF-1 WHERE REF>1 AND EXISTS (SELECT {0}.ID FROM {0} WHERE {0}.TRANSACTIONID=? AND {1}.ID={0}.ID) * </code> */ public static final String decrementUncommittedReferences = "node.decrementUncommittedReferences"; /** *Constant "selectAllResolvedIds" used to reference prepared statement node.selectAllResolvedIds * * <code> * SELECT {0}{1}.ENTRYID,{0}{1}.ID FROM {0}{1} * </code> */ public static final String selectAllResolvedIds = "node.selectAllResolvedIds"; /** *Constant "purge" used to reference prepared statement node.purge * * <code> * DELETE FROM {0} WHERE TRANSACTIONID=? * </code> */ public static final String purge = "node.purge"; /** *Constant "resolveIdsLiteral" used to reference prepared statement node.resolveIdsLiteral * * <code> * SELECT {2}.ID,{2}.VALUE,{2}.MODIFIER_ID FROM {2},{0}{1} WHERE {2}.ID ={0}{1}.ID AND {0}{1}.ID>=? AND {0}{1}.ID < ? * </code> */ public static final String resolveIdsLiteral = "node.resolveIdsLiteral"; /** *Constant "resolveTransactedIdsLiteral" used to reference prepared statement node.resolveTransactedIdsLiteral * * <code> * SELECT {2}.ID,{2}.VALUE,{2}.MODIFIER_ID FROM {2},{0}{1} WHERE {0}{1}.TRANSACTIONID=? AND {2}.ID ={0}{1}.ID AND {0}{1}.ID>=? AND {0}{1}.ID < ? * </code> */ public static final String resolveTransactedIdsLiteral = "node.resolveTransactedIdsLiteral"; /** * Transformer that transforms the rows in the result set for the getAllLiterals prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<GetAllLiteralsResult> transformGetAllLiterals = new org.openanzo.jdbc.utils.Transformer<GetAllLiteralsResult>() { public GetAllLiteralsResult transform(java.sql.ResultSet rs) { GetAllLiteralsResult result = new GetAllLiteralsResult(); 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.modifierId = rs.getLong(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:modifierId", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.value = rs.getString(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the getAllLiterals prepared statement. * <code> * SELECT ID,MODIFIER_ID,VALUE FROM {0} {1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param nodeTableName template parameter *@param optimization template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<GetAllLiteralsResult> getAllLiterals( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String nodeTableName, String optimization) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(getAllLiterals, new String[] { nodeTableName, optimization }, 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<GetAllLiteralsResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<GetAllLiteralsResult>( rs, ps, stmtProvider, transformGetAllLiterals); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "getAllLiterals", stmtProvider.getSqlString(getAllLiterals), "", "" + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null") + "," + "optimization=" + ((optimization != null) ? optimization.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[getAllLiterals]"+endtimer); } } /** *Default implementation of GetAllLiteralsResult */ public static class GetAllLiteralsResult { /**Value for the "id" result value*/ private Long id; /**Value for the "modifierId" result value*/ private Long modifierId; /**Value for the "value" result value*/ private String value; /** *Get Id value *@return Id value */ public Long getId() { return this.id; } /** *Get ModifierId value *@return ModifierId value */ public Long getModifierId() { return this.modifierId; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } } /** * Transformer that transforms the rows in the result set for the findNodeID prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<Long> transformFindNodeID = 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 findNodeID prepared statement. * <code> * SELECT ID FROM {0} WHERE (MODIFIER_ID=0 OR MODIFIER_ID=?) AND VALUE LIKE ? {1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param modifierId template parameter *@param value template parameter * *@param nodeTableName template parameter *@param optimization template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<Long> findNodeID( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long modifierId, String value, String nodeTableName, String optimization) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(findNodeID, new String[] { nodeTableName, optimization }, connection); int argc = 1; ps.setLong(argc++, modifierId); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "findNodeID"); } else { ps.setString(argc++, value); } 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, transformFindNodeID); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "findNodeID", stmtProvider.getSqlString(findNodeID), "" + "modifierId=" + (modifierId) + "," + "value=" + ((value != null) ? value.toString() : "null"), "" + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null") + "," + "optimization=" + ((optimization != null) ? optimization.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[findNodeID]"+endtimer); } } /** * Runs the fetchNodeID prepared statement. * <code> * SELECT ID FROM {0} WHERE VALUE = ? {1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param value template parameter * *@param nodeTableName template parameter *@param optimization template parameter *@return Long *@throws org.openanzo.jdbc.utils.RdbException */ public static Long fetchNodeID(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String value, String nodeTableName, String optimization) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchNodeID, new String[] { nodeTableName, optimization }, connection); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "fetchNodeID"); } else { ps.setString(argc++, value); } java.sql.ResultSet rs = null; try { try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } if (!rs.next()) return null; Long val = rs.getLong(1); return val; } finally { if (rs != null) { try { rs.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing result set", sqle); } } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "fetchNodeID", stmtProvider.getSqlString(fetchNodeID), "" + "value=" + ((value != null) ? value.toString() : "null"), "" + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null") + "," + "optimization=" + ((optimization != null) ? optimization.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("[fetchNodeID]"+endtimer); } } /** * Runs the fetchNodeValue prepared statement. * <code> * SELECT VALUE FROM {0} WHERE ID = ? {1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter * *@param nodeTableName template parameter *@param optimization template parameter *@return String *@throws org.openanzo.jdbc.utils.RdbException */ public static String fetchNodeValue(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, String nodeTableName, String optimization) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchNodeValue, new String[] { nodeTableName, optimization }, connection); int argc = 1; ps.setLong(argc++, id); 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; String val = rs.getString(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, "fetchNodeValue", stmtProvider.getSqlString(fetchNodeValue), "" + "id=" + (id), "" + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null") + "," + "optimization=" + ((optimization != null) ? optimization.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("[fetchNodeValue]"+endtimer); } } /** * Transformer that transforms the rows in the result set for the fetchLongNodeID prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FetchLongNodeIDResult> transformFetchLongNodeID = new org.openanzo.jdbc.utils.Transformer<FetchLongNodeIDResult>() { public FetchLongNodeIDResult transform(java.sql.ResultSet rs) { FetchLongNodeIDResult result = new FetchLongNodeIDResult(); 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.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the fetchLongNodeID prepared statement. * <code> * SELECT ID,VALUE FROM {0} WHERE HASH = ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param hash template parameter * *@param nodeTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FetchLongNodeIDResult> fetchLongNodeID( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long hash, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchLongNodeID, new String[] { nodeTableName }, connection); int argc = 1; ps.setLong(argc++, hash); 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<FetchLongNodeIDResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FetchLongNodeIDResult>( rs, ps, stmtProvider, transformFetchLongNodeID); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "fetchLongNodeID", stmtProvider.getSqlString(fetchLongNodeID), "" + "hash=" + (hash), "" + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[fetchLongNodeID]"+endtimer); } } /** *Default implementation of FetchLongNodeIDResult */ public static class FetchLongNodeIDResult { /**Value for the "id" result value*/ private Long id; /**Value for the "value" result value*/ private String value; /** *Get Id value *@return Id value */ public Long getId() { return this.id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } } /** * Runs the fetchLiteralNodeValue prepared statement. * <code> * SELECT VALUE, MODIFIER_ID FROM {0} WHERE ID = ? {1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter * *@param literalNodeTableName template parameter *@param optimization template parameter *@return FetchLiteralNodeValueResult *@throws org.openanzo.jdbc.utils.RdbException */ public static FetchLiteralNodeValueResult fetchLiteralNodeValue( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, String literalNodeTableName, String optimization) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchLiteralNodeValue, new String[] { literalNodeTableName, optimization }, connection); int argc = 1; ps.setLong(argc++, id); 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; FetchLiteralNodeValueResult result = new FetchLiteralNodeValueResult(); result.value = rs.getString(1); result.modifier_id = 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, "fetchLiteralNodeValue", stmtProvider.getSqlString(fetchLiteralNodeValue), "" + "id=" + (id), "" + "literalNodeTableName=" + ((literalNodeTableName != null) ? literalNodeTableName.toString() : "null") + "," + "optimization=" + ((optimization != null) ? optimization.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("[fetchLiteralNodeValue]"+endtimer); } } /** *Default implementation of FetchLiteralNodeValueResult */ public static class FetchLiteralNodeValueResult { /**Value for the "value" result value*/ private String value; /**Value for the "modifier_id" result value*/ private Long modifier_id; /** *Get Value value *@return Value value */ public String getValue() { return this.value; } /** *Get Modifier_id value *@return Modifier_id value */ public Long getModifier_id() { return this.modifier_id; } } /** * Runs the fetchLiteralNodeID prepared statement. * <code> * SELECT ID FROM {0} WHERE VALUE = ? AND MODIFIER_ID = ? {1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param value template parameter *@param modifier_id template parameter * *@param literalNodeTableName template parameter *@param optimization template parameter *@return Long *@throws org.openanzo.jdbc.utils.RdbException */ public static Long fetchLiteralNodeID(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String value, long modifier_id, String literalNodeTableName, String optimization) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchLiteralNodeID, new String[] { literalNodeTableName, optimization }, connection); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "fetchLiteralNodeID"); } else { ps.setString(argc++, value); } ps.setLong(argc++, modifier_id); java.sql.ResultSet rs = null; try { try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } if (!rs.next()) return null; Long val = rs.getLong(1); return val; } finally { if (rs != null) { try { rs.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing result set", sqle); } } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "fetchLiteralNodeID", stmtProvider.getSqlString(fetchLiteralNodeID), "" + "value=" + ((value != null) ? value.toString() : "null") + "," + "modifier_id=" + (modifier_id), "" + "literalNodeTableName=" + ((literalNodeTableName != null) ? literalNodeTableName.toString() : "null") + "," + "optimization=" + ((optimization != null) ? optimization.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("[fetchLiteralNodeID]"+endtimer); } } /** * Transformer that transforms the rows in the result set for the fetchLongLiteralNodeID prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FetchLongLiteralNodeIDResult> transformFetchLongLiteralNodeID = new org.openanzo.jdbc.utils.Transformer<FetchLongLiteralNodeIDResult>() { public FetchLongLiteralNodeIDResult transform(java.sql.ResultSet rs) { FetchLongLiteralNodeIDResult result = new FetchLongLiteralNodeIDResult(); 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.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the fetchLongLiteralNodeID prepared statement. * <code> * SELECT ID,VALUE FROM {0} WHERE HASH = ? AND MODIFIER_ID = ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param hash template parameter *@param modifier_id template parameter * *@param longLiteralNodeTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FetchLongLiteralNodeIDResult> fetchLongLiteralNodeID( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long hash, long modifier_id, String longLiteralNodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchLongLiteralNodeID, new String[] { longLiteralNodeTableName }, connection); int argc = 1; ps.setLong(argc++, hash); ps.setLong(argc++, modifier_id); 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<FetchLongLiteralNodeIDResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FetchLongLiteralNodeIDResult>( rs, ps, stmtProvider, transformFetchLongLiteralNodeID); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "fetchLongLiteralNodeID", stmtProvider.getSqlString(fetchLongLiteralNodeID), "" + "hash=" + (hash) + "," + "modifier_id=" + (modifier_id), "" + "longLiteralNodeTableName=" + ((longLiteralNodeTableName != null) ? longLiteralNodeTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[fetchLongLiteralNodeID]"+endtimer); } } /** *Default implementation of FetchLongLiteralNodeIDResult */ public static class FetchLongLiteralNodeIDResult { /**Value for the "id" result value*/ private Long id; /**Value for the "value" result value*/ private String value; /** *Get Id value *@return Id value */ public Long getId() { return this.id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } } /** * Runs the insertCommonValue prepared statement. * <code> * INSERT INTO {0} (ID, VALUE) VALUES(?, ?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter *@param value template parameter * *@param commonValuesTable template parameter * *@throws org.openanzo.jdbc.utils.RdbException */ public static void insertCommonValue(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, String value, String commonValuesTable) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(insertCommonValue, new String[] { commonValuesTable }, connection); int argc = 1; ps.setLong(argc++, id); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "insertCommonValue"); } else { ps.setString(argc++, value); } 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, "insertCommonValue", stmtProvider.getSqlString(insertCommonValue), "" + "id=" + (id) + "," + "value=" + ((value != null) ? value.toString() : "null"), "" + "commonValuesTable=" + ((commonValuesTable != null) ? commonValuesTable.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("[insertCommonValue]"+endtimer); } } /** *Batch operation for adding parameters to the InsertCommonValue prepared statement */ public static class BatchInsertCommonValue extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the InsertCommonValue prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param commonValuesTable template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchInsertCommonValue(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String commonValuesTable) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, insertCommonValue, new String[] { commonValuesTable }); } /** * Sets the input parameters for the insertCommonValue prepared statement. * *@param id template parameter *@param value template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long id, String value) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, id); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "insertCommonValue"); } else { ps.setString(argc++, value); } 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 insertCommonValueWithIdentity prepared statement. * <code> * INSERT INTO {0} ( VALUE) VALUES( ?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param value template parameter * *@param commonValuesTable template parameter *@return Long *@throws org.openanzo.jdbc.utils.RdbException */ public static Long insertCommonValueWithIdentity( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String value, String commonValuesTable) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatementWithGeneratedIDS(insertCommonValueWithIdentity, new String[] { commonValuesTable }, connection); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "insertCommonValueWithIdentity"); } else { ps.setString(argc++, value); } java.sql.ResultSet rs = null; try { if (ps.execute()) { rs = ps.getResultSet(); } else { rs = ps.getGeneratedKeys(); } if (rs != null && rs.next()) { return rs.getLong(1); } else { return null; } } 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, "insertCommonValueWithIdentity", stmtProvider.getSqlString(insertCommonValueWithIdentity), "" + "value=" + ((value != null) ? value.toString() : "null"), "" + "commonValuesTable=" + ((commonValuesTable != null) ? commonValuesTable.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("[insertCommonValueWithIdentity]"+endtimer); } } /** *Batch operation for adding parameters to the InsertCommonValueWithIdentity prepared statement */ public static class BatchInsertCommonValueWithIdentity extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the InsertCommonValueWithIdentity prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param commonValuesTable template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchInsertCommonValueWithIdentity(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String commonValuesTable) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, insertCommonValueWithIdentity, new String[] { commonValuesTable }); } /** * Sets the input parameters for the insertCommonValueWithIdentity prepared statement. * *@param value template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(String value) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "insertCommonValueWithIdentity"); } else { ps.setString(argc++, value); } 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 fetchCommonValueID prepared statement. * <code> * SELECT ID FROM {0} WHERE VALUE = ? {1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param value template parameter * *@param commonValuesTable template parameter *@param optimization template parameter *@return Long *@throws org.openanzo.jdbc.utils.RdbException */ public static Long fetchCommonValueID(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String value, String commonValuesTable, String optimization) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchCommonValueID, new String[] { commonValuesTable, optimization }, connection); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "fetchCommonValueID"); } else { ps.setString(argc++, value); } java.sql.ResultSet rs = null; try { try { rs = ps.executeQuery(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { rs = ps.executeQuery(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } if (!rs.next()) return null; Long val = rs.getLong(1); return val; } finally { if (rs != null) { try { rs.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing result set", sqle); } } } } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "fetchCommonValueID", stmtProvider.getSqlString(fetchCommonValueID), "" + "value=" + ((value != null) ? value.toString() : "null"), "" + "commonValuesTable=" + ((commonValuesTable != null) ? commonValuesTable.toString() : "null") + "," + "optimization=" + ((optimization != null) ? optimization.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("[fetchCommonValueID]"+endtimer); } } /** * Runs the fetchCommonValue prepared statement. * <code> * SELECT VALUE FROM {0} WHERE ID = ? {1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter * *@param commonValuesTable template parameter *@param optimization template parameter *@return String *@throws org.openanzo.jdbc.utils.RdbException */ public static String fetchCommonValue(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, String commonValuesTable, String optimization) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchCommonValue, new String[] { commonValuesTable, optimization }, connection); int argc = 1; ps.setLong(argc++, id); 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; String val = rs.getString(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, "fetchCommonValue", stmtProvider.getSqlString(fetchCommonValue), "" + "id=" + (id), "" + "commonValuesTable=" + ((commonValuesTable != null) ? commonValuesTable.toString() : "null") + "," + "optimization=" + ((optimization != null) ? optimization.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("[fetchCommonValue]"+endtimer); } } /** * Transformer that transforms the rows in the result set for the fetchAllCommonValues prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<FetchAllCommonValuesResult> transformFetchAllCommonValues = new org.openanzo.jdbc.utils.Transformer<FetchAllCommonValuesResult>() { public FetchAllCommonValuesResult transform(java.sql.ResultSet rs) { FetchAllCommonValuesResult result = new FetchAllCommonValuesResult(); 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.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the fetchAllCommonValues prepared statement. * <code> * SELECT ID, VALUE FROM {0} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param commonValuesTable template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<FetchAllCommonValuesResult> fetchAllCommonValues( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String commonValuesTable) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(fetchAllCommonValues, new String[] { commonValuesTable }, 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<FetchAllCommonValuesResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<FetchAllCommonValuesResult>( rs, ps, stmtProvider, transformFetchAllCommonValues); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "fetchAllCommonValues", stmtProvider.getSqlString(fetchAllCommonValues), "", "" + "commonValuesTable=" + ((commonValuesTable != null) ? commonValuesTable.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[fetchAllCommonValues]"+endtimer); } } /** *Default implementation of FetchAllCommonValuesResult */ public static class FetchAllCommonValuesResult { /**Value for the "id" result value*/ private Long id; /**Value for the "value" result value*/ private String value; /** *Get Id value *@return Id value */ public Long getId() { return this.id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } } /** * Runs the storeBulkNode prepared statement. * <code> * INSERT INTO {0}{1} (ID, VALUE) VALUES(?, ?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter *@param value template parameter * *@param sessionPrefix template parameter *@param bulkNodeTableName template parameter * *@throws org.openanzo.jdbc.utils.RdbException */ public static void storeBulkNode(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, String value, String sessionPrefix, String bulkNodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeBulkNode, new String[] { sessionPrefix, bulkNodeTableName }, connection); int argc = 1; ps.setLong(argc++, id); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeBulkNode"); } else { ps.setString(argc++, value); } 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, "storeBulkNode", stmtProvider.getSqlString(storeBulkNode), "" + "id=" + (id) + "," + "value=" + ((value != null) ? value.toString() : "null"), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkNodeTableName=" + ((bulkNodeTableName != null) ? bulkNodeTableName.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("[storeBulkNode]"+endtimer); } } /** *Batch operation for adding parameters to the StoreBulkNode prepared statement */ public static class BatchStoreBulkNode extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreBulkNode prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkNodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreBulkNode(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkNodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeBulkNode, new String[] { sessionPrefix, bulkNodeTableName }); } /** * Sets the input parameters for the storeBulkNode prepared statement. * *@param id template parameter *@param value template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long id, String value) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, id); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeBulkNode"); } else { ps.setString(argc++, value); } 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 storeBulkLongNode prepared statement. * <code> * INSERT INTO {0}{1} (ID, HASH, VALUE) VALUES(?, ?, ?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter *@param hash template parameter *@param value template parameter * *@param sessionPrefix template parameter *@param bulkNodeTableName template parameter * *@throws org.openanzo.jdbc.utils.RdbException */ public static void storeBulkLongNode(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, long hash, String value, String sessionPrefix, String bulkNodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeBulkLongNode, new String[] { sessionPrefix, bulkNodeTableName }, connection); int argc = 1; ps.setLong(argc++, id); ps.setLong(argc++, hash); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeBulkLongNode"); } else { ps.setString(argc++, value); } 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, "storeBulkLongNode", stmtProvider.getSqlString(storeBulkLongNode), "" + "id=" + (id) + "," + "hash=" + (hash) + "," + "value=" + ((value != null) ? value.toString() : "null"), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkNodeTableName=" + ((bulkNodeTableName != null) ? bulkNodeTableName.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("[storeBulkLongNode]"+endtimer); } } /** *Batch operation for adding parameters to the StoreBulkLongNode prepared statement */ public static class BatchStoreBulkLongNode extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreBulkLongNode prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkNodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreBulkLongNode(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkNodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeBulkLongNode, new String[] { sessionPrefix, bulkNodeTableName }); } /** * Sets the input parameters for the storeBulkLongNode prepared statement. * *@param id template parameter *@param hash template parameter *@param value template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long id, long hash, String value) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, id); ps.setLong(argc++, hash); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeBulkLongNode"); } else { ps.setString(argc++, value); } 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 storeBulkLiteral prepared statement. * <code> * INSERT INTO {0}{1} (ID, VALUE, MODIFIER_ID) VALUES(?, ?, ?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter *@param value template parameter *@param modifier_id template parameter * *@param sessionPrefix template parameter *@param bulkLiteralTableName template parameter * *@throws org.openanzo.jdbc.utils.RdbException */ public static void storeBulkLiteral(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, String value, long modifier_id, String sessionPrefix, String bulkLiteralTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeBulkLiteral, new String[] { sessionPrefix, bulkLiteralTableName }, connection); int argc = 1; ps.setLong(argc++, id); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeBulkLiteral"); } else { ps.setString(argc++, value); } ps.setLong(argc++, modifier_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, "storeBulkLiteral", stmtProvider.getSqlString(storeBulkLiteral), "" + "id=" + (id) + "," + "value=" + ((value != null) ? value.toString() : "null") + "," + "modifier_id=" + (modifier_id), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkLiteralTableName=" + ((bulkLiteralTableName != null) ? bulkLiteralTableName.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("[storeBulkLiteral]"+endtimer); } } /** *Batch operation for adding parameters to the StoreBulkLiteral prepared statement */ public static class BatchStoreBulkLiteral extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreBulkLiteral prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkLiteralTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreBulkLiteral(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkLiteralTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeBulkLiteral, new String[] { sessionPrefix, bulkLiteralTableName }); } /** * Sets the input parameters for the storeBulkLiteral prepared statement. * *@param id template parameter *@param value template parameter *@param modifier_id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long id, String value, long modifier_id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, id); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeBulkLiteral"); } else { ps.setString(argc++, value); } ps.setLong(argc++, modifier_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 storeBulkLongLiteral prepared statement. * <code> * INSERT INTO {0}{1} (ID, VALUE, HASH, MODIFIER_ID) VALUES(?, ?, ?, ?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter *@param value template parameter *@param hash template parameter *@param modifier_id template parameter * *@param sessionPrefix template parameter *@param bulkLiteralTableName template parameter * *@throws org.openanzo.jdbc.utils.RdbException */ public static void storeBulkLongLiteral(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, String value, long hash, long modifier_id, String sessionPrefix, String bulkLiteralTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeBulkLongLiteral, new String[] { sessionPrefix, bulkLiteralTableName }, connection); int argc = 1; ps.setLong(argc++, id); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeBulkLongLiteral"); } else { ps.setString(argc++, value); } ps.setLong(argc++, hash); ps.setLong(argc++, modifier_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, "storeBulkLongLiteral", stmtProvider.getSqlString(storeBulkLongLiteral), "" + "id=" + (id) + "," + "value=" + ((value != null) ? value.toString() : "null") + "," + "hash=" + (hash) + "," + "modifier_id=" + (modifier_id), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkLiteralTableName=" + ((bulkLiteralTableName != null) ? bulkLiteralTableName.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("[storeBulkLongLiteral]"+endtimer); } } /** *Batch operation for adding parameters to the StoreBulkLongLiteral prepared statement */ public static class BatchStoreBulkLongLiteral extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreBulkLongLiteral prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkLiteralTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreBulkLongLiteral(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkLiteralTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeBulkLongLiteral, new String[] { sessionPrefix, bulkLiteralTableName }); } /** * Sets the input parameters for the storeBulkLongLiteral prepared statement. * *@param id template parameter *@param value template parameter *@param hash template parameter *@param modifier_id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long id, String value, long hash, long modifier_id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, id); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeBulkLongLiteral"); } else { ps.setString(argc++, value); } ps.setLong(argc++, hash); ps.setLong(argc++, modifier_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 countTempTable prepared statement. * <code> * SELECT COUNT(1) FROM {0}{1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkLiteralTableName template parameter *@return long *@throws org.openanzo.jdbc.utils.RdbException */ public static long countTempTable(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkLiteralTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(countTempTable, new String[] { sessionPrefix, bulkLiteralTableName }, 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, "countTempTable", stmtProvider.getSqlString(countTempTable), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkLiteralTableName=" + ((bulkLiteralTableName != null) ? bulkLiteralTableName.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("[countTempTable]"+endtimer); } } /** * Runs the storeResolveId prepared statement. * <code> * INSERT INTO {0}{1} (ID) VALUES(?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter * *@throws org.openanzo.jdbc.utils.RdbException */ public static void storeResolveId(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeResolveId, new String[] { sessionPrefix, bulkResolutionTableName }, connection); int argc = 1; ps.setLong(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, "storeResolveId", stmtProvider.getSqlString(storeResolveId), "" + "id=" + (id), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.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("[storeResolveId]"+endtimer); } } /** *Batch operation for adding parameters to the StoreResolveId prepared statement */ public static class BatchStoreResolveId extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreResolveId prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreResolveId(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeResolveId, new String[] { sessionPrefix, bulkResolutionTableName }); } /** * Sets the input parameters for the storeResolveId prepared statement. * *@param id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, id); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the storeResolveNode prepared statement. * <code> * INSERT INTO {0}{1} (ENTRYID,VALUE) VALUES(?,?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param rowId template parameter *@param value template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int storeResolveNode(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, int rowId, String value, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeResolveNode, new String[] { sessionPrefix, bulkResolutionTableName }, connection); int argc = 1; ps.setInt(argc++, rowId); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeResolveNode"); } else { ps.setString(argc++, value); } 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, "storeResolveNode", stmtProvider.getSqlString(storeResolveNode), "" + "rowId=" + (rowId) + "," + "value=" + ((value != null) ? value.toString() : "null"), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.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("[storeResolveNode]"+endtimer); } } /** *Batch operation for adding parameters to the StoreResolveNode prepared statement */ public static class BatchStoreResolveNode extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreResolveNode prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreResolveNode(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeResolveNode, new String[] { sessionPrefix, bulkResolutionTableName }); } /** * Sets the input parameters for the storeResolveNode prepared statement. * *@param rowId template parameter *@param value template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(int rowId, String value) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setInt(argc++, rowId); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeResolveNode"); } else { ps.setString(argc++, value); } 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 storeResolveNodeLong prepared statement. * <code> * INSERT INTO {0}{1} (VALUE,HASH) VALUES(?,?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param value template parameter *@param hash template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int storeResolveNodeLong(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String value, long hash, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeResolveNodeLong, new String[] { sessionPrefix, bulkResolutionTableName }, connection); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeResolveNodeLong"); } else { ps.setString(argc++, value); } ps.setLong(argc++, hash); 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, "storeResolveNodeLong", stmtProvider.getSqlString(storeResolveNodeLong), "" + "value=" + ((value != null) ? value.toString() : "null") + "," + "hash=" + (hash), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.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("[storeResolveNodeLong]"+endtimer); } } /** *Batch operation for adding parameters to the StoreResolveNodeLong prepared statement */ public static class BatchStoreResolveNodeLong extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreResolveNodeLong prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreResolveNodeLong(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeResolveNodeLong, new String[] { sessionPrefix, bulkResolutionTableName }); } /** * Sets the input parameters for the storeResolveNodeLong prepared statement. * *@param value template parameter *@param hash template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(String value, long hash) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeResolveNodeLong"); } else { ps.setString(argc++, value); } ps.setLong(argc++, hash); 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 storeResolveLiteral prepared statement. * <code> * INSERT INTO {0}{1} (ENTRYID,VALUE,MODIFIER_ID) VALUES(?,?,?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param rowId template parameter *@param value template parameter *@param modifier_id template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int storeResolveLiteral(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, int rowId, String value, long modifier_id, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeResolveLiteral, new String[] { sessionPrefix, bulkResolutionTableName }, connection); int argc = 1; ps.setInt(argc++, rowId); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeResolveLiteral"); } else { ps.setString(argc++, value); } ps.setLong(argc++, modifier_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, "storeResolveLiteral", stmtProvider.getSqlString(storeResolveLiteral), "" + "rowId=" + (rowId) + "," + "value=" + ((value != null) ? value.toString() : "null") + "," + "modifier_id=" + (modifier_id), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.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("[storeResolveLiteral]"+endtimer); } } /** *Batch operation for adding parameters to the StoreResolveLiteral prepared statement */ public static class BatchStoreResolveLiteral extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreResolveLiteral prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreResolveLiteral(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeResolveLiteral, new String[] { sessionPrefix, bulkResolutionTableName }); } /** * Sets the input parameters for the storeResolveLiteral prepared statement. * *@param rowId template parameter *@param value template parameter *@param modifier_id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(int rowId, String value, long modifier_id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setInt(argc++, rowId); if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeResolveLiteral"); } else { ps.setString(argc++, value); } ps.setLong(argc++, modifier_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 storeResolveLiteralLong prepared statement. * <code> * INSERT INTO {0}{1} (VALUE,HASH,MODIFIER_ID) VALUES(?,?,?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param value template parameter *@param hash template parameter *@param modifier_id template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int storeResolveLiteralLong(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String value, long hash, long modifier_id, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(storeResolveLiteralLong, new String[] { sessionPrefix, bulkResolutionTableName }, connection); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeResolveLiteralLong"); } else { ps.setString(argc++, value); } ps.setLong(argc++, hash); ps.setLong(argc++, modifier_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, "storeResolveLiteralLong", stmtProvider.getSqlString(storeResolveLiteralLong), "" + "value=" + ((value != null) ? value.toString() : "null") + "," + "hash=" + (hash) + "," + "modifier_id=" + (modifier_id), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.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("[storeResolveLiteralLong]"+endtimer); } } /** *Batch operation for adding parameters to the StoreResolveLiteralLong prepared statement */ public static class BatchStoreResolveLiteralLong extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the StoreResolveLiteralLong prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchStoreResolveLiteralLong(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, storeResolveLiteralLong, new String[] { sessionPrefix, bulkResolutionTableName }); } /** * Sets the input parameters for the storeResolveLiteralLong prepared statement. * *@param value template parameter *@param hash template parameter *@param modifier_id template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(String value, long hash, long modifier_id) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; if (value == null) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.NULL_PARAMETER, "value", "storeResolveLiteralLong"); } else { ps.setString(argc++, value); } ps.setLong(argc++, hash); ps.setLong(argc++, modifier_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 resolveNodes prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<ResolveNodesResult> transformResolveNodes = new org.openanzo.jdbc.utils.Transformer<ResolveNodesResult>() { public ResolveNodesResult transform(java.sql.ResultSet rs) { ResolveNodesResult result = new ResolveNodesResult(); try { result.node_id = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:node_id", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the resolveNodes prepared statement. * <code> * SELECT {2}.ID,{2}.VALUE FROM {2},{0}{1} WHERE {2}.VALUE={0}{1}.VALUE * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<ResolveNodesResult> resolveNodes( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveNodes, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, 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<ResolveNodesResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveNodesResult>( rs, ps, stmtProvider, transformResolveNodes); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveNodes", stmtProvider.getSqlString(resolveNodes), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[resolveNodes]"+endtimer); } } /** *Default implementation of ResolveNodesResult */ public static class ResolveNodesResult { /**Value for the "node_id" result value*/ private Long node_id; /**Value for the "value" result value*/ private String value; /** *Get Node_id value *@return Node_id value */ public Long getNode_id() { return this.node_id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } } /** * Transformer that transforms the rows in the result set for the resolveLiterals prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<ResolveLiteralsResult> transformResolveLiterals = new org.openanzo.jdbc.utils.Transformer<ResolveLiteralsResult>() { public ResolveLiteralsResult transform(java.sql.ResultSet rs) { ResolveLiteralsResult result = new ResolveLiteralsResult(); try { result.node_id = rs.getLong(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:node_id", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.modifier_id = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:modifier_id", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the resolveLiterals prepared statement. * <code> * SELECT {2}.ID,{2}.VALUE,{2}.MODIFIER_ID FROM {2},{0}{1} WHERE {2}.VALUE={0}{1}.VALUE AND {2}.MODIFIER_ID = {0}{1}.MODIFIER_ID * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<ResolveLiteralsResult> resolveLiterals( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveLiterals, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, 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<ResolveLiteralsResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveLiteralsResult>( rs, ps, stmtProvider, transformResolveLiterals); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveLiterals", stmtProvider.getSqlString(resolveLiterals), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[resolveLiterals]"+endtimer); } } /** *Default implementation of ResolveLiteralsResult */ public static class ResolveLiteralsResult { /**Value for the "node_id" result value*/ private Long node_id; /**Value for the "value" result value*/ private String value; /**Value for the "modifier_id" result value*/ private Long modifier_id; /** *Get Node_id value *@return Node_id value */ public Long getNode_id() { return this.node_id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } /** *Get Modifier_id value *@return Modifier_id value */ public Long getModifier_id() { return this.modifier_id; } } /** * Transformer that transforms the rows in the result set for the resolveIdsUri prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<ResolveIdsUriResult> transformResolveIdsUri = new org.openanzo.jdbc.utils.Transformer<ResolveIdsUriResult>() { public ResolveIdsUriResult transform(java.sql.ResultSet rs) { ResolveIdsUriResult result = new ResolveIdsUriResult(); 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.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the resolveIdsUri prepared statement. * <code> * SELECT {2}.ID,{2}.VALUE FROM {2},{0}{1} WHERE {2}.ID={0}{1}.ID AND {0}{1}.ID>=? AND {0}{1}.ID < ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param startId template parameter *@param endId template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<ResolveIdsUriResult> resolveIdsUri( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long startId, long endId, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveIdsUri, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, connection); int argc = 1; ps.setLong(argc++, startId); ps.setLong(argc++, endId); 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<ResolveIdsUriResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveIdsUriResult>( rs, ps, stmtProvider, transformResolveIdsUri); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveIdsUri", stmtProvider.getSqlString(resolveIdsUri), "" + "startId=" + (startId) + "," + "endId=" + (endId), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[resolveIdsUri]"+endtimer); } } /** *Default implementation of ResolveIdsUriResult */ public static class ResolveIdsUriResult { /**Value for the "id" result value*/ private Long id; /**Value for the "value" result value*/ private String value; /** *Get Id value *@return Id value */ public Long getId() { return this.id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } } /** * Transformer that transforms the rows in the result set for the resolveTransactedIdsUri prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<ResolveTransactedIdsUriResult> transformResolveTransactedIdsUri = new org.openanzo.jdbc.utils.Transformer<ResolveTransactedIdsUriResult>() { public ResolveTransactedIdsUriResult transform(java.sql.ResultSet rs) { ResolveTransactedIdsUriResult result = new ResolveTransactedIdsUriResult(); 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.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the resolveTransactedIdsUri prepared statement. * <code> * SELECT {2}.ID,{2}.VALUE FROM {2},{0}{1} WHERE {0}{1}.TRANSACTIONID=? AND {2}.ID={0}{1}.ID AND {0}{1}.ID>=? AND {0}{1}.ID < ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param transactionId template parameter *@param startId template parameter *@param endId template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<ResolveTransactedIdsUriResult> resolveTransactedIdsUri( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long transactionId, long startId, long endId, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveTransactedIdsUri, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, connection); int argc = 1; ps.setLong(argc++, transactionId); ps.setLong(argc++, startId); ps.setLong(argc++, endId); 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<ResolveTransactedIdsUriResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveTransactedIdsUriResult>( rs, ps, stmtProvider, transformResolveTransactedIdsUri); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveTransactedIdsUri", stmtProvider.getSqlString(resolveTransactedIdsUri), "" + "transactionId=" + (transactionId) + "," + "startId=" + (startId) + "," + "endId=" + (endId), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[resolveTransactedIdsUri]"+endtimer); } } /** *Default implementation of ResolveTransactedIdsUriResult */ public static class ResolveTransactedIdsUriResult { /**Value for the "id" result value*/ private Long id; /**Value for the "value" result value*/ private String value; /** *Get Id value *@return Id value */ public Long getId() { return this.id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } } /** * Runs the updateResolvedUris prepared statement. * <code> * UPDATE {0}{1} AS A SET TYPE=2,ID=(SELECT {2}.ID FROM {2} WHERE {2}.VALUE=A.VALUE AND {2}.REF=0) WHERE EXISTS (SELECT {2}.ID FROM {2} WHERE {2}.VALUE=A.VALUE AND {2}.REF=0) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int updateResolvedUris(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(updateResolvedUris, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "updateResolvedUris", stmtProvider.getSqlString(updateResolvedUris), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[updateResolvedUris]"+endtimer); } } /** *Batch operation for adding parameters to the UpdateResolvedUris prepared statement */ public static class BatchUpdateResolvedUris extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the UpdateResolvedUris prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchUpdateResolvedUris(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, updateResolvedUris, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }); } /** * Sets the input parameters for the updateResolvedUris prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the resolveExistingUris prepared statement. * <code> * INSERT INTO {0}{2} (ENTRYID,ID,TYPE) SELECT T.ENTRYID,N.ID,2 FROM {0}{1} T,{3} N WHERE N.VALUE=T.VALUE AND N.REF=0 * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int resolveExistingUris(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveExistingUris, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName, nodeTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveExistingUris", stmtProvider.getSqlString(resolveExistingUris), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "resolvedTableName=" + ((resolvedTableName != null) ? resolvedTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[resolveExistingUris]"+endtimer); } } /** *Batch operation for adding parameters to the ResolveExistingUris prepared statement */ public static class BatchResolveExistingUris extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the ResolveExistingUris prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchResolveExistingUris(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, resolveExistingUris, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName, nodeTableName }); } /** * Sets the input parameters for the resolveExistingUris prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the updateExistingUrisReferenceCount prepared statement. * <code> * UPDATE {2} SET REF=REF+1 WHERE REF>0 AND VALUE IN (SELECT {0}{1}.VALUE FROM {0}{1}) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int updateExistingUrisReferenceCount( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(updateExistingUrisReferenceCount, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "updateExistingUrisReferenceCount", stmtProvider.getSqlString(updateExistingUrisReferenceCount), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[updateExistingUrisReferenceCount]"+endtimer); } } /** *Batch operation for adding parameters to the UpdateExistingUrisReferenceCount prepared statement */ public static class BatchUpdateExistingUrisReferenceCount extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the UpdateExistingUrisReferenceCount prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchUpdateExistingUrisReferenceCount(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, updateExistingUrisReferenceCount, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }); } /** * Sets the input parameters for the updateExistingUrisReferenceCount prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the resolveExistingUncommittedUris prepared statement. * <code> * INSERT INTO {0}{2} (ENTRYID,ID,TYPE) SELECT T.ENTRYID,N.ID,3 FROM {0}{1} T,{3} N WHERE N.VALUE=T.VALUE AND N.REF>0 * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int resolveExistingUncommittedUris( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveExistingUncommittedUris, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName, nodeTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveExistingUncommittedUris", stmtProvider.getSqlString(resolveExistingUncommittedUris), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "resolvedTableName=" + ((resolvedTableName != null) ? resolvedTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[resolveExistingUncommittedUris]"+endtimer); } } /** *Batch operation for adding parameters to the ResolveExistingUncommittedUris prepared statement */ public static class BatchResolveExistingUncommittedUris extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the ResolveExistingUncommittedUris prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchResolveExistingUncommittedUris(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, resolveExistingUncommittedUris, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName, nodeTableName }); } /** * Sets the input parameters for the resolveExistingUncommittedUris prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the purgeResolvedUris prepared statement. * <code> * DELETE FROM {0}{1} WHERE ENTRYID IN (SELECT {0}{2}.ENTRYID FROM {0}{2}) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int purgeResolvedUris(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(purgeResolvedUris, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "purgeResolvedUris", stmtProvider.getSqlString(purgeResolvedUris), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "resolvedTableName=" + ((resolvedTableName != null) ? resolvedTableName.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("[purgeResolvedUris]"+endtimer); } } /** *Batch operation for adding parameters to the PurgeResolvedUris prepared statement */ public static class BatchPurgeResolvedUris extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the PurgeResolvedUris prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchPurgeResolvedUris(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, purgeResolvedUris, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName }); } /** * Sets the input parameters for the purgeResolvedUris prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the insertUnresolvedUris prepared statement. * <code> * * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@param sequenceName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int insertUnresolvedUris(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String nodeTableName, String sequenceName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(insertUnresolvedUris, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName, sequenceName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "insertUnresolvedUris", stmtProvider.getSqlString(insertUnresolvedUris), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null") + "," + "sequenceName=" + ((sequenceName != null) ? sequenceName.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("[insertUnresolvedUris]"+endtimer); } } /** *Batch operation for adding parameters to the InsertUnresolvedUris prepared statement */ public static class BatchInsertUnresolvedUris extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the InsertUnresolvedUris prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@param sequenceName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchInsertUnresolvedUris(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String nodeTableName, String sequenceName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, insertUnresolvedUris, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName, sequenceName }); } /** * Sets the input parameters for the insertUnresolvedUris prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the resolveExistingLiterals prepared statement. * <code> * INSERT INTO {0}{2} (ENTRYID,ID,TYPE) SELECT T.ENTRYID,N.ID,2 FROM {0}{1} T,{3} N WHERE N.VALUE=T.VALUE AND N.MODIFIER_ID=T.MODIFIER_ID AND N.REF=0 * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int resolveExistingLiterals(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveExistingLiterals, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName, nodeTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveExistingLiterals", stmtProvider.getSqlString(resolveExistingLiterals), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "resolvedTableName=" + ((resolvedTableName != null) ? resolvedTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[resolveExistingLiterals]"+endtimer); } } /** *Batch operation for adding parameters to the ResolveExistingLiterals prepared statement */ public static class BatchResolveExistingLiterals extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the ResolveExistingLiterals prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchResolveExistingLiterals(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, resolveExistingLiterals, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName, nodeTableName }); } /** * Sets the input parameters for the resolveExistingLiterals prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the updateExistingLiteralsReferenceCount prepared statement. * <code> * UPDATE {2} SET REF=REF+1 WHERE REF>0 AND EXISTS (SELECT {0}{1}.VALUE FROM {0}{1} WHERE {0}{1}.VALUE={2}.VALUE AND {0}{1}.MODIFIER_ID={2}.MODIFIER_ID) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int updateExistingLiteralsReferenceCount( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(updateExistingLiteralsReferenceCount, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "updateExistingLiteralsReferenceCount", stmtProvider.getSqlString(updateExistingLiteralsReferenceCount), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[updateExistingLiteralsReferenceCount]"+endtimer); } } /** *Batch operation for adding parameters to the UpdateExistingLiteralsReferenceCount prepared statement */ public static class BatchUpdateExistingLiteralsReferenceCount extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the UpdateExistingLiteralsReferenceCount prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchUpdateExistingLiteralsReferenceCount(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, updateExistingLiteralsReferenceCount, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }); } /** * Sets the input parameters for the updateExistingLiteralsReferenceCount prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the resolveExistingUncommittedLiterals prepared statement. * <code> * INSERT INTO {0}{2} (ENTRYID,ID,TYPE) SELECT T.ENTRYID,N.ID,3 FROM {0}{1} T,{3} N WHERE N.VALUE=T.VALUE AND N.MODIFIER_ID=T.MODIFIER_ID AND N.REF>0 * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int resolveExistingUncommittedLiterals( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveExistingUncommittedLiterals, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName, nodeTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveExistingUncommittedLiterals", stmtProvider.getSqlString(resolveExistingUncommittedLiterals), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "resolvedTableName=" + ((resolvedTableName != null) ? resolvedTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[resolveExistingUncommittedLiterals]"+endtimer); } } /** *Batch operation for adding parameters to the ResolveExistingUncommittedLiterals prepared statement */ public static class BatchResolveExistingUncommittedLiterals extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the ResolveExistingUncommittedLiterals prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchResolveExistingUncommittedLiterals(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, resolveExistingUncommittedLiterals, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName, nodeTableName }); } /** * Sets the input parameters for the resolveExistingUncommittedLiterals prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the purgeResolvedLiterals prepared statement. * <code> * DELETE FROM {0}{1} WHERE ENTRYID IN (SELECT {0}{2}.ENTRYID FROM {0}{2}) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int purgeResolvedLiterals(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(purgeResolvedLiterals, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "purgeResolvedLiterals", stmtProvider.getSqlString(purgeResolvedLiterals), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "resolvedTableName=" + ((resolvedTableName != null) ? resolvedTableName.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("[purgeResolvedLiterals]"+endtimer); } } /** *Batch operation for adding parameters to the PurgeResolvedLiterals prepared statement */ public static class BatchPurgeResolvedLiterals extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the PurgeResolvedLiterals prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param resolvedTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchPurgeResolvedLiterals(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String resolvedTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, purgeResolvedLiterals, new String[] { sessionPrefix, bulkResolutionTableName, resolvedTableName }); } /** * Sets the input parameters for the purgeResolvedLiterals prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the insertUnresolvedLiterals prepared statement. * <code> * * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@param sequenceName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int insertUnresolvedLiterals(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String nodeTableName, String sequenceName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(insertUnresolvedLiterals, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName, sequenceName }, connection); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "insertUnresolvedLiterals", stmtProvider.getSqlString(insertUnresolvedLiterals), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null") + "," + "sequenceName=" + ((sequenceName != null) ? sequenceName.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("[insertUnresolvedLiterals]"+endtimer); } } /** *Batch operation for adding parameters to the InsertUnresolvedLiterals prepared statement */ public static class BatchInsertUnresolvedLiterals extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the InsertUnresolvedLiterals prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@param sequenceName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchInsertUnresolvedLiterals(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String nodeTableName, String sequenceName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, insertUnresolvedLiterals, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName, sequenceName }); } /** * Sets the input parameters for the insertUnresolvedLiterals prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the insertUncommittedReferences prepared statement. * <code> * INSERT INTO {2} (ID,TRANSACTIONID) SELECT {0}{1}.ID,{3} FROM {0}{1} WHERE {0}{1}.TYPE IN (1,3) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param lockedIdsTable template parameter *@param transactionId template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int insertUncommittedReferences( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName, String lockedIdsTable, String transactionId) throws org.openanzo.jdbc.utils.RdbException { java.sql.Statement stmt = null; //long startTimer=System.currentTimeMillis(); try { String sql = stmtProvider.getSQL(insertUncommittedReferences, new String[] { sessionPrefix, bulkResolutionTableName, lockedIdsTable, transactionId }); stmt = connection.createStatement(); int counter = 0; try { counter = stmt.executeUpdate(sql); } 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 = stmt.executeUpdate(sql); 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, "insertUncommittedReferences", stmtProvider.getSqlString(insertUncommittedReferences), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "lockedIdsTable=" + ((lockedIdsTable != null) ? lockedIdsTable.toString() : "null") + "," + "transactionId=" + ((transactionId != null) ? transactionId.toString() : "null")); } finally { if (stmt != null) { try { stmt.close(); } catch (java.sql.SQLException sqle) { if (log.isDebugEnabled()) log.debug(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error closing statement", sqle); } } //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[insertUncommittedReferences]"+endtimer); } } /** *Batch operation for adding parameters to the InsertUncommittedReferences prepared statement */ public static class BatchInsertUncommittedReferences extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the InsertUncommittedReferences prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param lockedIdsTable template parameter *@param transactionId template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchInsertUncommittedReferences(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String sessionPrefix, String bulkResolutionTableName, String lockedIdsTable, String transactionId) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, insertUncommittedReferences, new String[] { sessionPrefix, bulkResolutionTableName, lockedIdsTable, transactionId }); } /** * Sets the input parameters for the insertUncommittedReferences prepared statement. * *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry() throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the insertLockedId prepared statement. * <code> * INSERT INTO {0} (ID,TRANSACTIONID) VALUES(?,?) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param id template parameter *@param transactionId template parameter * *@param lockedIdsTable template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int insertLockedId(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long id, long transactionId, String lockedIdsTable) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(insertLockedId, new String[] { lockedIdsTable }, connection); int argc = 1; ps.setLong(argc++, id); ps.setLong(argc++, transactionId); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "insertLockedId", stmtProvider.getSqlString(insertLockedId), "" + "id=" + (id) + "," + "transactionId=" + (transactionId), "" + "lockedIdsTable=" + ((lockedIdsTable != null) ? lockedIdsTable.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("[insertLockedId]"+endtimer); } } /** *Batch operation for adding parameters to the InsertLockedId prepared statement */ public static class BatchInsertLockedId extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the InsertLockedId prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param lockedIdsTable template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchInsertLockedId(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String lockedIdsTable) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, insertLockedId, new String[] { lockedIdsTable }); } /** * Sets the input parameters for the insertLockedId prepared statement. * *@param id template parameter *@param transactionId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long id, long transactionId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, id); ps.setLong(argc++, transactionId); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the commitUncommittedReferences prepared statement. * <code> * UPDATE {1} SET REF=0 WHERE EXISTS (SELECT {0}.ID FROM {0} WHERE {0}.TRANSACTIONID=? AND {1}.ID={0}.ID) AND REF>0 * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param transactionId template parameter * *@param lockedIdsTable template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int commitUncommittedReferences( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long transactionId, String lockedIdsTable, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(commitUncommittedReferences, new String[] { lockedIdsTable, nodeTableName }, connection); int argc = 1; ps.setLong(argc++, transactionId); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "commitUncommittedReferences", stmtProvider.getSqlString(commitUncommittedReferences), "" + "transactionId=" + (transactionId), "" + "lockedIdsTable=" + ((lockedIdsTable != null) ? lockedIdsTable.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[commitUncommittedReferences]"+endtimer); } } /** *Batch operation for adding parameters to the CommitUncommittedReferences prepared statement */ public static class BatchCommitUncommittedReferences extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the CommitUncommittedReferences prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param lockedIdsTable template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchCommitUncommittedReferences(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String lockedIdsTable, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, commitUncommittedReferences, new String[] { lockedIdsTable, nodeTableName }); } /** * Sets the input parameters for the commitUncommittedReferences prepared statement. * *@param transactionId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long transactionId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, transactionId); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the deleteUncommittedReferences prepared statement. * <code> * DELETE FROM {1} WHERE REF=1 AND EXISTS (SELECT {0}.ID FROM {0} WHERE {0}.TRANSACTIONID=? AND {1}.ID={0}.ID) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param transactionId template parameter * *@param lockedIdsTable template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int deleteUncommittedReferences( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long transactionId, String lockedIdsTable, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(deleteUncommittedReferences, new String[] { lockedIdsTable, nodeTableName }, connection); int argc = 1; ps.setLong(argc++, transactionId); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "deleteUncommittedReferences", stmtProvider.getSqlString(deleteUncommittedReferences), "" + "transactionId=" + (transactionId), "" + "lockedIdsTable=" + ((lockedIdsTable != null) ? lockedIdsTable.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[deleteUncommittedReferences]"+endtimer); } } /** *Batch operation for adding parameters to the DeleteUncommittedReferences prepared statement */ public static class BatchDeleteUncommittedReferences extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the DeleteUncommittedReferences prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param lockedIdsTable template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchDeleteUncommittedReferences(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String lockedIdsTable, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, deleteUncommittedReferences, new String[] { lockedIdsTable, nodeTableName }); } /** * Sets the input parameters for the deleteUncommittedReferences prepared statement. * *@param transactionId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long transactionId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, transactionId); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Runs the decrementUncommittedReferences prepared statement. * <code> * UPDATE {1} SET REF=REF-1 WHERE REF>1 AND EXISTS (SELECT {0}.ID FROM {0} WHERE {0}.TRANSACTIONID=? AND {1}.ID={0}.ID) * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param transactionId template parameter * *@param lockedIdsTable template parameter *@param nodeTableName template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int decrementUncommittedReferences( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long transactionId, String lockedIdsTable, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(decrementUncommittedReferences, new String[] { lockedIdsTable, nodeTableName }, connection); int argc = 1; ps.setLong(argc++, transactionId); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "decrementUncommittedReferences", stmtProvider.getSqlString(decrementUncommittedReferences), "" + "transactionId=" + (transactionId), "" + "lockedIdsTable=" + ((lockedIdsTable != null) ? lockedIdsTable.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.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("[decrementUncommittedReferences]"+endtimer); } } /** *Batch operation for adding parameters to the DecrementUncommittedReferences prepared statement */ public static class BatchDecrementUncommittedReferences extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the DecrementUncommittedReferences prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param lockedIdsTable template parameter *@param nodeTableName template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchDecrementUncommittedReferences(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String lockedIdsTable, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, decrementUncommittedReferences, new String[] { lockedIdsTable, nodeTableName }); } /** * Sets the input parameters for the decrementUncommittedReferences prepared statement. * *@param transactionId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long transactionId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, transactionId); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Transformer that transforms the rows in the result set for the selectAllResolvedIds prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<SelectAllResolvedIdsResult> transformSelectAllResolvedIds = new org.openanzo.jdbc.utils.Transformer<SelectAllResolvedIdsResult>() { public SelectAllResolvedIdsResult transform(java.sql.ResultSet rs) { SelectAllResolvedIdsResult result = new SelectAllResolvedIdsResult(); try { result.rowid = rs.getInt(1); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:rowid", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.id = rs.getLong(2); } 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); } return result; } }; /** * Runs the selectAllResolvedIds prepared statement. * <code> * SELECT {0}{1}.ENTRYID,{0}{1}.ID FROM {0}{1} * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<SelectAllResolvedIdsResult> selectAllResolvedIds( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, String sessionPrefix, String bulkResolutionTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(selectAllResolvedIds, new String[] { sessionPrefix, bulkResolutionTableName }, 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<SelectAllResolvedIdsResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<SelectAllResolvedIdsResult>( rs, ps, stmtProvider, transformSelectAllResolvedIds); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "selectAllResolvedIds", stmtProvider.getSqlString(selectAllResolvedIds), "", "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[selectAllResolvedIds]"+endtimer); } } /** *Default implementation of SelectAllResolvedIdsResult */ public static class SelectAllResolvedIdsResult { /**Value for the "rowid" result value*/ private Integer rowid; /**Value for the "id" result value*/ private Long id; /** *Get Rowid value *@return Rowid value */ public Integer getRowid() { return this.rowid; } /** *Get Id value *@return Id value */ public Long getId() { return this.id; } } /** * Runs the purge prepared statement. * <code> * DELETE FROM {0} WHERE TRANSACTIONID=? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param transactionId template parameter * *@param lockIdTable template parameter *@return int *@throws org.openanzo.jdbc.utils.RdbException */ public static int purge(final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long transactionId, String lockIdTable) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(purge, new String[] { lockIdTable }, connection); int argc = 1; ps.setLong(argc++, transactionId); int counter = 0; try { counter = ps.executeUpdate(); } catch (java.sql.SQLException sqle) { if (sqle.getErrorCode() == 1205) { int retries = 0; while (retries < 5) { try { Thread.sleep(5000); } catch (InterruptedException ie) { throw sqle; } try { counter = ps.executeUpdate(); break; } catch (java.sql.SQLException sqleInner) { if (sqleInner.getErrorCode() == 1205) { retries++; } else { throw sqleInner; } } } if (retries >= 5) { throw sqle; } } else { throw sqle; } } return counter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "purge", stmtProvider.getSqlString(purge), "" + "transactionId=" + (transactionId), "" + "lockIdTable=" + ((lockIdTable != null) ? lockIdTable.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("[purge]"+endtimer); } } /** *Batch operation for adding parameters to the Purge prepared statement */ public static class BatchPurge extends org.openanzo.jdbc.utils.PreparedStatementExecutor { /** * Batch operation for adding parameters to the Purge prepared statement * @param connection Connection to execute * @param provider Prepared statement provider * *@param lockIdTable template parameter * @throws org.openanzo.jdbc.utils.RdbException */ public BatchPurge(java.sql.Connection connection, org.openanzo.jdbc.utils.PreparedStatementProvider provider, String lockIdTable) throws org.openanzo.jdbc.utils.RdbException { super(connection, provider, purge, new String[] { lockIdTable }); } /** * Sets the input parameters for the purge prepared statement. * *@param transactionId template parameter *@throws org.openanzo.jdbc.utils.RdbException */ public void addEntry(long transactionId) throws org.openanzo.jdbc.utils.RdbException { try { ps.clearParameters(); int argc = 1; ps.setLong(argc++, transactionId); ps.addBatch(); } catch (java.sql.SQLException sqle) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_PREPARING_STATEMENT, sqle); } } } /** * Transformer that transforms the rows in the result set for the resolveIdsLiteral prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<ResolveIdsLiteralResult> transformResolveIdsLiteral = new org.openanzo.jdbc.utils.Transformer<ResolveIdsLiteralResult>() { public ResolveIdsLiteralResult transform(java.sql.ResultSet rs) { ResolveIdsLiteralResult result = new ResolveIdsLiteralResult(); 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.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.modifierId = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:modifierId", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the resolveIdsLiteral prepared statement. * <code> * SELECT {2}.ID,{2}.VALUE,{2}.MODIFIER_ID FROM {2},{0}{1} WHERE {2}.ID ={0}{1}.ID AND {0}{1}.ID>=? AND {0}{1}.ID < ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param startId template parameter *@param endId template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<ResolveIdsLiteralResult> resolveIdsLiteral( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long startId, long endId, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveIdsLiteral, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, connection); int argc = 1; ps.setLong(argc++, startId); ps.setLong(argc++, endId); 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<ResolveIdsLiteralResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveIdsLiteralResult>( rs, ps, stmtProvider, transformResolveIdsLiteral); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveIdsLiteral", stmtProvider.getSqlString(resolveIdsLiteral), "" + "startId=" + (startId) + "," + "endId=" + (endId), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[resolveIdsLiteral]"+endtimer); } } /** *Default implementation of ResolveIdsLiteralResult */ public static class ResolveIdsLiteralResult { /**Value for the "id" result value*/ private Long id; /**Value for the "value" result value*/ private String value; /**Value for the "modifierId" result value*/ private long modifierId; /** *Get Id value *@return Id value */ public Long getId() { return this.id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } /** *Get ModifierId value *@return ModifierId value */ public long getModifierId() { return this.modifierId; } } /** * Transformer that transforms the rows in the result set for the resolveTransactedIdsLiteral prepared statement. */ static final org.openanzo.jdbc.utils.Transformer<ResolveTransactedIdsLiteralResult> transformResolveTransactedIdsLiteral = new org.openanzo.jdbc.utils.Transformer<ResolveTransactedIdsLiteralResult>() { public ResolveTransactedIdsLiteralResult transform(java.sql.ResultSet rs) { ResolveTransactedIdsLiteralResult result = new ResolveTransactedIdsLiteralResult(); 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.value = rs.getString(2); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:value", e); throw new org.apache.commons.collections.FunctorException(e); } try { result.modifierId = rs.getLong(3); } catch (java.sql.SQLException e) { log.error(org.openanzo.exceptions.LogUtils.RDB_MARKER, "Error transforming result set param:modifierId", e); throw new org.apache.commons.collections.FunctorException(e); } return result; } }; /** * Runs the resolveTransactedIdsLiteral prepared statement. * <code> * SELECT {2}.ID,{2}.VALUE,{2}.MODIFIER_ID FROM {2},{0}{1} WHERE {0}{1}.TRANSACTIONID=? AND {2}.ID ={0}{1}.ID AND {0}{1}.ID>=? AND {0}{1}.ID < ? * </code> * *@param stmtProvider * factory and cache of PreparedStatments *@param connection * connection to underlying database * *@param transactionId template parameter *@param startId template parameter *@param endId template parameter * *@param sessionPrefix template parameter *@param bulkResolutionTableName template parameter *@param nodeTableName template parameter *@return org.openanzo.jdbc.utils.ClosableIterator *@throws org.openanzo.jdbc.utils.RdbException */ public static org.openanzo.jdbc.utils.ClosableIterator<ResolveTransactedIdsLiteralResult> resolveTransactedIdsLiteral( final org.openanzo.jdbc.utils.PreparedStatementProvider stmtProvider, final java.sql.Connection connection, long transactionId, long startId, long endId, String sessionPrefix, String bulkResolutionTableName, String nodeTableName) throws org.openanzo.jdbc.utils.RdbException { java.sql.PreparedStatement ps = null; //long startTimer=System.currentTimeMillis(); try { ps = stmtProvider.getPreparedSQLStatement(resolveTransactedIdsLiteral, new String[] { sessionPrefix, bulkResolutionTableName, nodeTableName }, connection); int argc = 1; ps.setLong(argc++, transactionId); ps.setLong(argc++, startId); ps.setLong(argc++, endId); 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<ResolveTransactedIdsLiteralResult> iter = new org.openanzo.jdbc.utils.ResultSetIterator<ResolveTransactedIdsLiteralResult>( rs, ps, stmtProvider, transformResolveTransactedIdsLiteral); return iter; } catch (java.sql.SQLException e) { throw new org.openanzo.jdbc.utils.RdbException( org.openanzo.exceptions.ExceptionConstants.RDB.FAILED_EXECUTING_SQL, e, "resolveTransactedIdsLiteral", stmtProvider.getSqlString(resolveTransactedIdsLiteral), "" + "transactionId=" + (transactionId) + "," + "startId=" + (startId) + "," + "endId=" + (endId), "" + "sessionPrefix=" + ((sessionPrefix != null) ? sessionPrefix.toString() : "null") + "," + "bulkResolutionTableName=" + ((bulkResolutionTableName != null) ? bulkResolutionTableName.toString() : "null") + "," + "nodeTableName=" + ((nodeTableName != null) ? nodeTableName.toString() : "null")); } finally { //long endtimer=(System.currentTimeMillis()-startTimer); //if(endtimer>CUTOFF)System.out.println("[resolveTransactedIdsLiteral]"+endtimer); } } /** *Default implementation of ResolveTransactedIdsLiteralResult */ public static class ResolveTransactedIdsLiteralResult { /**Value for the "id" result value*/ private Long id; /**Value for the "value" result value*/ private String value; /**Value for the "modifierId" result value*/ private Long modifierId; /** *Get Id value *@return Id value */ public Long getId() { return this.id; } /** *Get Value value *@return Value value */ public String getValue() { return this.value; } /** *Get ModifierId value *@return ModifierId value */ public Long getModifierId() { return this.modifierId; } } }