public void commit() { try { sqlTransaction.commit(); } finally { clearState(); } }
public void cleanup() { try { this.sqlTransaction.commit(); } catch (Exception ex) { log.warn(ex.getMessage(), ex); } finally { this.sqlTransaction.close(); } }
private void callReloadListeners(boolean before, Node targetNode, boolean transactional, ISqlTransaction transaction) { if (reloadListeners != null) { for (IReloadListener listener : reloadListeners) { if (before) { listener.beforeReload(transaction, targetNode); } else { listener.afterReload(transaction, targetNode); } if (!transactional) { transaction.commit(); } } } }
protected void commit(boolean earlyCommit) { if (transaction != null) { try { statistics.get(batch).startTimer(DataWriterStatisticConstants.DATABASEMILLIS); this.transaction.commit(); if (!earlyCommit) { notifyFiltersBatchCommitted(); } else { notifyFiltersEarlyCommit(); } } finally { statistics.get(batch).stopTimer(DataWriterStatisticConstants.DATABASEMILLIS); } } uncommittedCount = 0; }
public boolean setInitialLoadEnabled(String nodeId, boolean initialLoadEnabled, boolean syncChange, long loadId, String createBy) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); boolean updated = setInitialLoadEnabled(transaction, nodeId, initialLoadEnabled, syncChange, loadId, createBy); transaction.commit(); return updated; } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public void insertOutgoingBatch(final OutgoingBatch outgoingBatch) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); insertOutgoingBatch(transaction, outgoingBatch); transaction.commit(); } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
private void insertCreateBatchesForReload(Node targetNode, long loadId, String createBy, List<TriggerHistory> triggerHistories, Map<Integer, List<TriggerRouter>> triggerRoutersByHistoryId, boolean transactional, ISqlTransaction transaction) { if (parameterService.is(ParameterConstants.INITIAL_LOAD_CREATE_SCHEMA_BEFORE_RELOAD)) { for (TriggerHistory triggerHistory : triggerHistories) { List<TriggerRouter> triggerRouters = triggerRoutersByHistoryId.get(triggerHistory .getTriggerHistoryId()); for (TriggerRouter triggerRouter : triggerRouters) { if (triggerRouter.getInitialLoadOrder() >= 0 && engine.getGroupletService().isTargetEnabled(triggerRouter, targetNode)) { String xml = symmetricDialect.getCreateTableXML(triggerHistory, triggerRouter); insertCreateEvent(transaction, targetNode, triggerHistory, xml, true, loadId, createBy); if (!transactional) { transaction.commit(); } } } } } }
public void updateOutgoingBatch(OutgoingBatch outgoingBatch) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); updateOutgoingBatch(transaction, outgoingBatch); transaction.commit(); } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public void insertIncomingBatch(IncomingBatch batch) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); insertIncomingBatch(transaction, batch); transaction.commit(); } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public long currVal(String name) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); long val = currVal(transaction, name); transaction.commit(); return val; } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public void insertCreateEvent(final Node targetNode, TriggerHistory triggerHistory, String xml, boolean isLoad, long loadId, String createBy) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); insertCreateEvent(transaction, targetNode, triggerHistory, xml, isLoad, loadId, createBy); transaction.commit(); } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public boolean setReverseInitialLoadEnabled(String nodeId, boolean initialLoadEnabled, boolean syncChange, long loadId, String createBy) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); boolean updated = setReverseInitialLoadEnabled(transaction, nodeId, initialLoadEnabled, syncChange, loadId, createBy); transaction.commit(); return updated; } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public boolean updateNodeSecurity(NodeSecurity security) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); boolean updated = updateNodeSecurity(transaction, security); transaction.commit(); return updated; } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public void insertIncomingError(IncomingError incomingError) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); insertIncomingError(transaction, incomingError); transaction.commit(); } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public long insertData(Data data) { ISqlTransaction transaction = null; long dataId = -1; try { transaction = sqlTemplate.startSqlTransaction(); dataId = insertData(transaction, data); transaction.commit(); return dataId; } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public Data createData(String catalogName, String schemaName, String tableName, String whereClause) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); Data data = createData(transaction, catalogName, schemaName, tableName, whereClause); transaction.commit(); return data; } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public long nextVal(String name) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); long val = nextVal(transaction, name); transaction.commit(); return val; } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public int updateIncomingBatch(IncomingBatch batch) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); int count = updateIncomingBatch(transaction, batch); transaction.commit(); return count; } catch (Error ex) { if (transaction != null) { transaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (transaction != null) { transaction.rollback(); } throw ex; } finally { close(transaction); } }
public void save(List<FileSnapshot> changes) { if (changes != null) { ISqlTransaction sqlTransaction = null; try { sqlTransaction = sqlTemplate.startSqlTransaction(); for (FileSnapshot fileSnapshot : changes) { save(sqlTransaction, fileSnapshot); } sqlTransaction.commit(); } catch (Error ex) { if (sqlTransaction != null) { sqlTransaction.rollback(); } throw ex; } catch (RuntimeException ex) { if (sqlTransaction != null) { sqlTransaction.rollback(); } throw ex; } finally { close(sqlTransaction); } } }
private void insertFileSyncBatchForReload(Node targetNode, long loadId, String createBy, boolean transactional, ISqlTransaction transaction) { if (parameterService.is(ParameterConstants.FILE_SYNC_ENABLE) && !Constants.DEPLOYMENT_TYPE_REST.equals(targetNode.getDeploymentType())) { ITriggerRouterService triggerRouterService = engine.getTriggerRouterService(); TriggerHistory fileSyncSnapshotHistory = triggerRouterService.findTriggerHistory(null, null, TableConstants.getTableName(tablePrefix, TableConstants.SYM_FILE_SNAPSHOT)); String routerid = triggerRouterService.buildSymmetricTableRouterId( fileSyncSnapshotHistory.getTriggerId(), parameterService.getNodeGroupId(), targetNode.getNodeGroupId()); TriggerRouter fileSyncSnapshotTriggerRouter = triggerRouterService .getTriggerRouterForCurrentNode(fileSyncSnapshotHistory.getTriggerId(), routerid, true); // file sync reload event needs to be on the file sync channel to be // processed insertReloadEvent(transaction, targetNode, fileSyncSnapshotTriggerRouter, fileSyncSnapshotHistory, null, true, loadId, createBy, Status.NE); if (!transactional) { transaction.commit(); } } }