public void insertDataEvents(ISqlTransaction transaction, final List<DataEvent> events) { if (events.size() > 0) { transaction.prepare(getSql("insertIntoDataEventSql")); for (DataEvent dataEvent : events) { String routerId = dataEvent.getRouterId(); transaction.addRow( dataEvent, new Object[] { dataEvent.getDataId(), dataEvent.getBatchId(), StringUtils.isBlank(routerId) ? Constants.UNKNOWN_ROUTER_ID : routerId }, new int[] { Types.NUMERIC, Types.NUMERIC, Types.VARCHAR }); } transaction.flush(); } }
public void deleteTransformTable(String transformTableId) { ISqlTransaction transaction = null; try { transaction = sqlTemplate.startSqlTransaction(); deleteTransformColumns(transaction, transformTableId); transaction.prepareAndExecute(getSql("deleteTransformTableSql"), (Object) transformTableId); transaction.commit(); refreshCache(); } 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 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); } }
transaction.execute(triggerSql); } catch (SqlException ex) { log.error("Failed to create trigger: {}", triggerSql); transaction.execute(postTriggerDml); } catch (SqlException ex) { log.error("Failed to create post trigger: {}", postTriggerDml); transaction.commit(); } catch (SqlException ex) { transaction.rollback(); throw ex; } finally { transaction.close();
public void disableSyncTriggers(ISqlTransaction transaction, String nodeId) { String contextTableName = parameterService.getTablePrefix() + "_" + CONTEXT_TABLE_NAME; transaction.prepareAndExecute(String.format(CONTEXT_TABLE_INSERT, contextTableName), new Object[] { SYNC_TRIGGERS_DISABLED_USER_VARIABLE, "1" }); if (nodeId != null) { transaction.prepareAndExecute(String.format(CONTEXT_TABLE_INSERT, contextTableName), new Object[] { SYNC_TRIGGERS_DISABLED_NODE_VARIABLE, nodeId }); } }
public void commit() { try { sqlTransaction.commit(); } finally { clearState(); } }
transaction.prepareAndExecute(getSql("deleteNodeIdentitySql")); transaction.prepareAndExecute(getSql("deleteNodeSecuritySql"), new Object[] { nodeId }); transaction.prepareAndExecute(getSql("deleteNodeHostSql"), new Object[] { nodeId }); transaction.prepareAndExecute(getSql("deleteNodeSql"), new Object[] { nodeId }); transaction.rollback(); transaction.rollback();
protected boolean sql(CsvData data) { try { statistics.get(batch).startTimer(DataWriterStatisticConstants.DATABASEMILLIS); String script = data.getParsedData(CsvData.ROW_DATA)[0]; List<String> sqlStatements = getSqlStatements(script); long count = 0; for (String sql : sqlStatements) { sql = preprocessSqlStatement(sql); transaction.prepare(sql); if (log.isDebugEnabled()) { log.debug("About to run: {}", sql); } count += transaction.prepareAndExecute(sql); if (log.isDebugEnabled()) { log.debug("{} rows updated when running: {}", count, sql); } } statistics.get(batch).increment(DataWriterStatisticConstants.SQLCOUNT); statistics.get(batch).increment(DataWriterStatisticConstants.SQLROWSAFFECTEDCOUNT, count); return true; } finally { statistics.get(batch).stopTimer(DataWriterStatisticConstants.DATABASEMILLIS); } }
public void rollback() { try { sqlTransaction.rollback(); } catch (SqlException e) { log.warn(e.getMessage(), e); } finally { clearState(); } }
public void close() { if (transaction != null) { this.transaction.close(); } }
protected Sequence get(ISqlTransaction transaction, String name) { List<Sequence> values = transaction.query(getSql("getSequenceSql"), new SequenceRowMapper(), new Object[] {name}, new int [] {Types.VARCHAR}); if (values.size() > 0) { return values.get(0); } else { return null; } }
if (column.isTimestampWithTimezone()) { String existingStr = writer.getTransaction().queryForObject(sql, String.class, objectValues); } else { existingTs = writer.getTransaction().queryForObject(sql, Timestamp.class, objectValues);
log.debug("Preparing dml: " + this.currentDmlStatement.getSql()); transaction.prepare(this.currentDmlStatement.getSql());
protected int execute(CsvData data, String[] values) { Object[] objectValues = platform.getObjectValues(batch.getBinaryEncoding(), values, currentDmlStatement.getMetaData()); if (log.isDebugEnabled()) { log.debug("Submitting data {} with types {}", Arrays.toString(objectValues), Arrays.toString(this.currentDmlStatement.getTypes())); } return transaction.addRow(data, objectValues, this.currentDmlStatement.getTypes()); }
public void end(Table table) { String quote = getPlatform().getDatabaseInfo().getDelimiterToken(); this.transaction.allowInsertIntoAutoIncrementColumns(false, this.targetTable, quote); }
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); } }
protected void deleteTransformColumns(ISqlTransaction transaction, String transformTableId) { transaction.prepareAndExecute(getSql("deleteTransformColumnsSql"), (Object) transformTableId); }
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 rollback() { if (transaction != null) { try { statistics.get(batch).startTimer(DataWriterStatisticConstants.DATABASEMILLIS); this.transaction.rollback(); notifyFiltersBatchRolledback(); } finally { statistics.get(batch).stopTimer(DataWriterStatisticConstants.DATABASEMILLIS); } } uncommittedCount = 0; }