void CRUUnAuditRefreshTaskExecutor::Recompute() { // ????? // Temporary - Should be removed when read commited from unaudited table is implemented if (FALSE == IsTransactionOpen()) { BeginTransaction(); } CDMPreparedStatement *pStat = PrepareRecomputeMV(); // ????? // Temporary - Should be removed when read commited from unaudited table is implemented CommitTransaction(); BeginTransaction(); ExecuteRecomputeMV(pStat); // ????? // Temporary - Should be removed when read commited from unaudited table is implemented CommitTransaction(); TESTPOINT2(CRUGlobals::TESTPOINT104, GetRootMVName()); if (TRUE == isPopindex_) { SetState(EX_POPINDEX); } else { SetState(EX_EPILOGUE); } }
void CRUAuditRefreshTaskExecutor::Recompute() { // TEMPORARY: Commented out until the privilege-skipping lock // is implemented // LockMV(); if (FALSE == IsTransactionOpen()) { BeginTransaction(); } // Decouple prepare and execute to separate transactions. CDMPreparedStatement *pStat = PrepareRecomputeMV(); CommitTransaction(); BeginTransaction(); ExecuteRecomputeMV(pStat); if (TRUE == isDeleteMultiTxnContext_) { // Delete all rows from the context log table auditRefreshTEDynamicContainer_. DirectExecStatement(DELETE_MULT_TXN_CTX_TBL); } if (TRUE == isPopindex_) { CommitTransaction(); SetState(EX_POPINDEX); } else { SetState(EX_REMOTE_END); } }
/* static */ bool WheelTransaction::WillHandleDefaultAction(WidgetWheelEvent* aWheelEvent, nsWeakFrame& aTargetWeakFrame) { nsIFrame* lastTargetFrame = GetTargetFrame(); if (!lastTargetFrame) { BeginTransaction(aTargetWeakFrame.GetFrame(), aWheelEvent); } else if (lastTargetFrame != aTargetWeakFrame.GetFrame()) { EndTransaction(); BeginTransaction(aTargetWeakFrame.GetFrame(), aWheelEvent); } else { UpdateTransaction(aWheelEvent); } // When the wheel event will not be handled with any frames, // UpdateTransaction() fires MozMouseScrollFailed event which is for // automated testing. In the event handler, the target frame might be // destroyed. Then, the caller shouldn't try to handle the default action. if (!aTargetWeakFrame.IsAlive()) { EndTransaction(); return false; } return true; }
void CRUUnAuditRefreshTaskExecutor::Refresh() { try { // ????? // Temporary - Should be removed when read commited from unaudited table is implemented BeginTransaction(); ApplyIRCompilerDefaults(); if(TRUE == IsSingleDeltaRefresh()) { CDMPreparedStatement *pStat = PrepareSingleDeltaRefresh(); // ????? // Temporary - Should be removed when read commited from unaudited table is implemented CommitTransaction(); BeginTransaction(); ExecuteSingleDeltaRefresh(pStat); } else { StmtList *stmts = PrepareMultiDeltasRefresh(); // ????? // Temporary - Should be removed when read commited from unaudited table is implemented CommitTransaction(); BeginTransaction(); ExecuteMultiDeltasRefresh(stmts); } ResetIRCompilerDefaults(); ExecuteShowExplain(); // ????? // Temporary - Should be removed when read commited from unaudited table is implemented CommitTransaction(); TESTPOINT2(CRUGlobals::TESTPOINT106, GetRootMVName()); SetState(EX_EPILOGUE); } catch (CRUSimpleRefreshTaskExecutor::NeedRecomputeException) { SetState(EX_RECOMPUTE); SetRecompute(TRUE); } }
/** * @brief Lock the line of the Handle table with inode & devid defined in p_info * * @param p_conn * Database connection * @param p_info * Information about the file * * @return ERR_FSAL_POSIXDB_NOERR if no error, * another error code else. */ fsal_posixdb_status_t fsal_posixdb_lockHandleForUpdate(fsal_posixdb_conn * p_conn, /* IN */ fsal_posixdb_fileinfo_t * p_info /* IN */ ) { PGresult *p_res; char devid_str[MAX_DEVICEIDSTR_SIZE]; char inode_str[MAX_INODESTR_SIZE]; const char *paramValues[2]; CheckConn(p_conn); BeginTransaction(p_conn, p_res); snprintf(devid_str, MAX_DEVICEIDSTR_SIZE, "%lli", (long long int)p_info->devid); snprintf(inode_str, MAX_INODESTR_SIZE, "%lli", (long long int)p_info->inode); paramValues[0] = devid_str; paramValues[1] = inode_str; p_res = PQexecPrepared(p_conn, "lookupHandleByInodeFU", 2, paramValues, NULL, NULL, 0); CheckResult(p_res); PQclear(p_res); /* Do not end the transaction, because it will be closed by the next call to a posixdb function */ ReturnCodeDB(ERR_FSAL_POSIXDB_NOERR, 0); }
void CRUUnAuditRefreshTaskExecutor::Epilogue() { EndTimer(); BeginTransaction(); if (TRUE == GetRefreshTask()->NeedToExecuteInternalRefresh()) { if (CDDObject::eON_STATEMENT == GetRootMVType()) { EpilogueHandleOnStatementMV(); } // Set the MV(s)/indexes back available ResetObjectsAvailable(); } FinalMetadataUpdate(); CommitTransaction(); TESTPOINT2(CRUGlobals::TESTPOINT107, GetRootMVName()); LogClosureMessage(); SetState(EX_COMPLETE); }
void CRUUnAuditRefreshTaskExecutor::PopulateIndexes() { RUASSERT(TRUE == isPopindex_); if (0 == numOfIndexes_) { return; } // ????? // Temporary - Should be removed when read commited from unaudited table is implemented BeginTransaction(); #ifdef _DEBUG CDSString msg( "\nPopulating the secondary indexes of materialized view " + GetRootMVName() + "...\n"); CRUGlobals::GetInstance()-> LogDebugMessage(CRUGlobals::DUMP_POPINDEX,"",msg); #endif ExecuteIndexStatmenents(*pUnAuditPopIndexdynamicContainer_, IDS_RU_POPINDEX_FAILED); // ????? // Temporary - Should be removed when read commited from unaudited table is implemented CommitTransaction(); TESTPOINT2(CRUGlobals::TESTPOINT105, GetRootMVName()); SetState(EX_EPILOGUE); }
void CRUUnAuditRefreshTaskExecutor::Prologue() { TESTPOINT2(CRUGlobals::TESTPOINT101, GetRootMVName()); BeginTransaction(); if (CDDObject::eON_STATEMENT == GetRootMVType()) { PrologueHandleOnStatementMV(); } // Set the MV non-available etc ... SetObjectsUnavailable(); CommitTransaction(); TESTPOINT2(CRUGlobals::TESTPOINT102, GetRootMVName()); if (TRUE == isPurgedata_) { SetState(EX_PURGE_DATA); } else if (TRUE == IsRecompute()) { SetState(EX_RECOMPUTE); } else { SetState(EX_REFRESH); } }
void CRULogCleanupTaskExecutor::CleanLogFirstN(SQL_STATEMENT statement) { // Compilation Stage CDMPreparedStatement *pStat = logCleanupTEDynamicContainer_.GetPreparedStatement(statement); while (TRUE) { BeginTransaction(); ExecuteStatement(*pStat, IDS_RU_LOG_CLEANUP_FAILED, NULL, /* error argument */ TRUE /* Obtain row count */); CommitTransaction(); TESTPOINT(CRUGlobals::TESTPOINT160); if (pStat->GetRowsAffected() < CRULogCleanupSQLComposer::MAX_ROW_TO_DELETE_IN_SINGLE_TXN) { break; } } }
void CRUTableSyncTaskExecutor::Epilogue() { CRUTableSyncTask *pParentTask = (CRUTableSyncTask *)GetParentTask(); RUASSERT(NULL != pParentTask); CRUTbl &tbl = pParentTask->GetTable(); if (TRUE == tbl.IsIncEpochNeeded()) { if (TRUE == tbl.IsLongLockNeeded()) { BeginTransaction(); tbl.ExecuteReadProtectedOpen(); CommitTransaction(); } if (TRUE == tbl.IsLogRPOpenPending()) { // The above condition is false only in case of // a non involved incremental mv.We do not need to lock the logs // because we rely on the ddl locks tbl.ReleaseLogReadProtectedOpen(); } } SetState(EX_COMPLETE); }
void CRUAuditRefreshTaskExecutor::Prologue() { RUASSERT(FALSE == IsTransactionOpen()); BeginTransaction(); if (CDDObject::eON_STATEMENT == GetRootMVType()) { PrologueHandleOnStatementMV(); } SetObjectsUnavailable(); CommitTransaction(); TESTPOINT2(CRUGlobals::TESTPOINT102, GetRootMVName()); if (TRUE == isPurgedata_) { // purgedata is done in main process SetState(EX_PURGE_DATA); } else { // refresh, recompute, and popindex done in remote process SetState(EX_REMOTE_START); } }
void ClientLayerManager::EndTransaction(DrawPaintedLayerCallback aCallback, void* aCallbackData, EndTransactionFlags aFlags) { if (!mForwarder->IPCOpen()) { mInTransaction = false; return; } if (mWidget) { mWidget->PrepareWindowEffects(); } EndTransactionInternal(aCallback, aCallbackData, aFlags); ForwardTransaction(!(aFlags & END_NO_REMOTE_COMPOSITE)); if (mRepeatTransaction) { mRepeatTransaction = false; mIsRepeatTransaction = true; if (BeginTransaction()) { ClientLayerManager::EndTransaction(aCallback, aCallbackData, aFlags); } mIsRepeatTransaction = false; } else { MakeSnapshotIfRequired(); } mInTransaction = false; mTransactionStart = TimeStamp(); }
void ClientLayerManager::EndTransaction(DrawPaintedLayerCallback aCallback, void* aCallbackData, EndTransactionFlags aFlags) { if (mWidget) { mWidget->PrepareWindowEffects(); } EndTransactionInternal(aCallback, aCallbackData, aFlags); ForwardTransaction(!(aFlags & END_NO_REMOTE_COMPOSITE)); if (mRepeatTransaction) { mRepeatTransaction = false; mIsRepeatTransaction = true; BeginTransaction(); ClientLayerManager::EndTransaction(aCallback, aCallbackData, aFlags); mIsRepeatTransaction = false; } else { MakeSnapshotIfRequired(); } for (size_t i = 0; i < mTexturePools.Length(); i++) { mTexturePools[i]->ReturnDeferredClients(); } mInTransaction = false; mTransactionStart = TimeStamp(); }
NS_IMETHODIMP nsTransactionManager::BeginBatch() { nsresult result; // We can batch independent transactions together by simply pushing // a dummy transaction item on the do stack. This dummy transaction item // will be popped off the do stack, and then pushed on the undo stack // in EndBatch(). bool doInterrupt = false; result = WillBeginBatchNotify(&doInterrupt); if (NS_FAILED(result)) { return result; } if (doInterrupt) { return NS_OK; } result = BeginTransaction(0); nsresult result2 = DidBeginBatchNotify(result); if (NS_SUCCEEDED(result)) result = result2; return result; }
NS_IMETHODIMP nsTransactionManager::DoTransaction(nsITransaction *aTransaction) { nsresult result; NS_ENSURE_TRUE(aTransaction, NS_ERROR_NULL_POINTER); bool doInterrupt = false; result = WillDoNotify(aTransaction, &doInterrupt); if (NS_FAILED(result)) { return result; } if (doInterrupt) { return NS_OK; } result = BeginTransaction(aTransaction); if (NS_FAILED(result)) { DidDoNotify(aTransaction, result); return result; } result = EndTransaction(); nsresult result2 = DidDoNotify(aTransaction, result); if (NS_SUCCEEDED(result)) result = result2; return result; }
fsal_posixdb_status_t fsal_posixdb_delete(fsal_posixdb_conn * p_conn, /* IN */ posixfsal_handle_t * p_parent_directory_handle, /* IN */ fsal_name_t * p_filename, /* IN */ fsal_posixdb_fileinfo_t * p_object_info /* IN */ ) { result_handle_t res; fsal_posixdb_status_t st; char query[2048]; /******************* * 1/ sanity check * *******************/ if(!p_conn || !p_parent_directory_handle || !p_filename) ReturnCodeDB(ERR_FSAL_POSIXDB_FAULT, 0); BeginTransaction(p_conn); /******************************* * 2/ we check the file exists * *******************************/ snprintf(query, 2048, "SELECT Parent.handleid, Parent.handlets, " "Handle.deviceid, Handle.inode, Handle.nlink, Handle.ctime, Handle.ftype " "FROM Parent INNER JOIN Handle ON Parent.handleid = Handle.handleid " "AND Parent.handlets=Handle.handlets " "WHERE handleidparent=%llu AND handletsparent=%u AND name='%s' " "FOR UPDATE", p_parent_directory_handle->data.id, p_parent_directory_handle->data.ts, p_filename->name); st = db_exec_sql(p_conn, query, &res); if(FSAL_POSIXDB_IS_ERROR(st)) goto rollback; if(mysql_num_rows(res) != 1) { /* parent entry not found */ mysql_free_result(res); RollbackTransaction(p_conn); ReturnCodeDB(ERR_FSAL_POSIXDB_NOENT, 0); } mysql_free_result(res); /*********************************************** * 3/ Get information about the file to delete * ***********************************************/ st = fsal_posixdb_internal_delete(p_conn, p_parent_directory_handle->data.id, p_parent_directory_handle->data.ts, p_filename->name, p_object_info); if(FSAL_POSIXDB_IS_ERROR(st)) goto rollback; return EndTransaction(p_conn); rollback: RollbackTransaction(p_conn); return st; }
/** * @brief Lock the line of the Handle table with inode & devid defined in p_info * * @param p_conn * Database connection * @param p_info * Information about the file * * @return ERR_FSAL_POSIXDB_NOERR if no error, * another error code else. */ fsal_posixdb_status_t fsal_posixdb_lockHandleForUpdate(fsal_posixdb_conn * p_conn, /* IN */ fsal_posixdb_fileinfo_t * p_info /* IN */ ) { result_handle_t res; fsal_posixdb_status_t st; char query[2048]; BeginTransaction(p_conn); snprintf(query, 2048, "SELECT handleid, handlets, nlink, ctime, ftype " "FROM Handle WHERE deviceid=%llu AND inode=%llu " "FOR UPDATE", (unsigned long long)p_info->devid, (unsigned long long)p_info->inode); st = db_exec_sql(p_conn, query, &res); if(FSAL_POSIXDB_IS_ERROR(st)) { RollbackTransaction(p_conn); return st; } mysql_free_result(res); /* Do not end the transaction, because it will be closed by the next call to a posixdb function */ ReturnCodeDB(ERR_FSAL_POSIXDB_NOERR, 0); }
void CRUAuditRefreshTaskExecutor::Epilogue() { RUASSERT(FALSE == IsTransactionOpen()); EndTimer(); BeginTransaction(); // if this is the first refresh, the MV status can be // changed to initialized if( TRUE == GetRefreshTask()->NeedToExecuteInternalRefresh() ) { if (CDDObject::eON_STATEMENT == GetRootMVType()) { EpilogueHandleOnStatementMV(); } ResetObjectsAvailable(); } FinalMetadataUpdate(); CommitTransaction(); TESTPOINT2(CRUGlobals::TESTPOINT131, GetRootMVName()); LogClosureMessage(); SetState(EX_COMPLETE); }
CAutoTrans::CAutoTrans(CDB_Connection& connection) : m_Abort(true) , m_Conn(connection) , m_TranCount(0) { BeginTransaction(); m_TranCount = GetTranCount(); }
void CRUEmpCheckTaskExecutor:: PerformEmptinessCheck() { pEmpCheck_->PrepareSQL(); BeginTransaction(); pEmpCheck_->PerformCheck(); CommitTransaction(); // Although no write operations were performed... }
void CRUAuditRefreshTaskExecutor::Refresh() { RUASSERT(TRUE == IsTransactionOpen()); // Simulate a system error at this point! TESTPOINT_SEVERE(CRUGlobals::SEVERE_REFRESH_CRASH); try { ApplyIRCompilerDefaults(); if(TRUE == IsSingleDeltaRefresh()) { CDMPreparedStatement *pStat = PrepareSingleDeltaRefresh(); CommitTransaction(); BeginTransaction(); ExecuteSingleDeltaRefresh(pStat); } else { StmtList *stmts = PrepareMultiDeltasRefresh(); CommitTransaction(); BeginTransaction(); ExecuteMultiDeltasRefresh(stmts); } ResetIRCompilerDefaults(); ExecuteShowExplain(); SetState(EX_REMOTE_END); } catch (CRUSimpleRefreshTaskExecutor::NeedRecomputeException) { // If a min/max value was deleted an exception will be thrown and // then we need to recompute the mv SetState(EX_RECOMPUTE); SetRecompute(TRUE); } }
void CRUAuditRefreshTaskExecutor::PopulateIndexes() { RUASSERT(TRUE == isPopindex_); if (0 == numOfIndexes_) { return; } // toggle audit flag OFF for indices to do the // side tree insert BeginTransaction(); ToggleIndicesAudit(FALSE); CommitTransaction(); // ????? // Temporary - Should be removed when read commited from unaudited table is implemented BeginTransaction(); #ifdef _DEBUG CDSString msg( "\nPopulating the secondary indexes of materialized view " + GetRootMVName() + "...\n"); CRUGlobals::GetInstance()-> LogDebugMessage(CRUGlobals::DUMP_POPINDEX,"",msg); #endif ExecuteIndexStatmenents(*pAuditPopIndexdynamicContainer_, IDS_RU_POPINDEX_FAILED); CommitTransaction(); TESTPOINT2(CRUGlobals::TESTPOINT105, GetRootMVName()); // toggle the audit flag for the indices back on BeginTransaction(); ToggleIndicesAudit(TRUE); // transaction gets committed in EX_REMOTE_END... SetState(EX_REMOTE_END); }
bool MySqlConnection::ExecuteTransaction(MySqlTransaction* transaction) { std::list<SQLElementData> const& queries = transaction->m_queries; if (queries.empty()) { TRACE_LOG("MySqlConnection::ExecuteTransaction:quries is empty\n"); return true; } if (!BeginTransaction()) { TRACE_LOG("MySqlConnection::ExecuteTransaction:BeginTransaction\n"); return false; } std::list<SQLElementData>::const_iterator itr; for (itr = queries.begin(); itr != queries.end(); ++itr) { SQLElementData const& data = *itr; switch (itr->type) { case SQL_ELEMENT_PREPARED: { PreparedStmt* stmt = data.element.stmt; if (!Execute(stmt)) { WARNING_LOG("Transaction aborted. %u queries not executed.\n", static_cast<uint32>(queries.size())); RollbackTransaction(); return false; } } break; case SQL_ELEMENT_RAW: { const char* sql = data.element.query; if (!Execute(sql)) { WARNING_LOG("Transaction aborted. %u queries not executed.\n", static_cast<uint32>(queries.size())); RollbackTransaction(); return false; } } break; } } // we might encounter errors during certain queries, and depending on the kind of error // we might want to restart the transaction. So to prevent data loss, we only clean up when it's all done. // This is done in calling functions DatabaseWorkerPool<T>::DirectCommitTransaction and TransactionTask::Execute, // and not while iterating over every element. CommitTransaction(); return true; }
void FResizeSection::OnBeginDrag(const FVector2D& LocalMousePos, TSharedPtr<FTrackNode> SequencerNode) { if( Section.IsValid() ) { BeginTransaction( *Section, NSLOCTEXT("Sequencer", "DragSectionEdgeTransaction", "Resize section") ); DraggedKeyHandles.Empty(); Section->GetKeyHandles(DraggedKeyHandles); } }
void FSCSEditorViewportClient::TrackingStarted( const struct FInputEventState& InInputState, bool bIsDraggingWidget, bool bNudge ) { if( !bIsManipulating && bIsDraggingWidget ) { // Suspend component modification during each delta step to avoid recording unnecessary overhead into the transaction buffer GEditor->DisableDeltaModification(true); // Begin transaction BeginTransaction( NSLOCTEXT("UnrealEd", "ModifyComponents", "Modify Component(s)") ); bIsManipulating = true; } }
FReply FCanvasSlotExtension::HandleAnchorBeginDrag(const FGeometry& Geometry, const FPointerEvent& Event, EAnchorWidget::Type AnchorType) { BeginTransaction(LOCTEXT("MoveAnchor", "Move Anchor")); bMovingAnchor = true; MouseDownPosition = Event.GetScreenSpacePosition(); UCanvasPanelSlot* PreviewCanvasSlot = Cast<UCanvasPanelSlot>(SelectionCache[0].GetPreview()->Slot); BeginAnchors = PreviewCanvasSlot->LayoutData.Anchors; return FReply::Handled().CaptureMouse(AnchorWidgets[(int32)AnchorType].ToSharedRef()); }
void FSingleTileEditorViewportClient::TrackingStarted(const struct FInputEventState& InInputState, bool bIsDragging, bool bNudge) { //@TODO: Should push this into FEditorViewportClient // Begin transacting. Give the current editor mode an opportunity to do the transacting. const bool bTrackingHandledExternally = ModeTools->StartTracking(this, Viewport); if (!bManipulating && bIsDragging && !bTrackingHandledExternally) { BeginTransaction(LOCTEXT("ModificationInViewport", "Modification in Viewport")); bManipulating = true; bManipulationDirtiedSomething = false; } }
int MySQLConnection::ExecuteTransaction(SQLTransaction& transaction) { std::list<SQLElementData> const& queries = transaction->m_queries; if (queries.empty()) return -1; BeginTransaction(); std::list<SQLElementData>::const_iterator itr; for (itr = queries.begin(); itr != queries.end(); ++itr) { SQLElementData const& data = *itr; switch (itr->type) { case SQL_ELEMENT_PREPARED: { PreparedStatement* stmt = data.element.stmt; ASSERT(stmt); if (!Execute(stmt)) { TC_LOG_WARN("sql.sql", "Transaction aborted. %u queries not executed.", (uint32)queries.size()); int errorCode = GetLastError(); RollbackTransaction(); return errorCode; } } break; case SQL_ELEMENT_RAW: { const char* sql = data.element.query; ASSERT(sql); if (!Execute(sql)) { TC_LOG_WARN("sql.sql", "Transaction aborted. %u queries not executed.", (uint32)queries.size()); int errorCode = GetLastError(); RollbackTransaction(); return errorCode; } } break; } } // we might encounter errors during certain queries, and depending on the kind of error // we might want to restart the transaction. So to prevent data loss, we only clean up when it's all done. // This is done in calling functions DatabaseWorkerPool<T>::DirectCommitTransaction and TransactionTask::Execute, // and not while iterating over every element. CommitTransaction(); return 0; }
void MySqlFactoryDal::CleanupOldRecords(nlib::DateTime olderThanDate, nlib::DateTime olderThanAlertDate) { nlib::DateTime currTime = nlib::CurrentUniversalTime(); const char *pszQry[] ={ "DELETE FROM CommandParameters WHERE CommandID IN (SELECT C.CommandID from Commands C WHERE C.TimePosted < \"%s\");", // +24*7 "DELETE FROM Commands WHERE TimePosted < \"%s\";", // +24*7 "DELETE FROM CommandParameters WHERE CommandID IN (SELECT C.CommandID from Commands C WHERE C.TimePosted < \"%s\" AND (C.CommandStatus = 2 OR C.CommandStatus = 3));", "DELETE FROM Commands WHERE TimePosted < \"%s\" AND (CommandStatus = 2 OR CommandStatus = 3);", "DELETE FROM DeviceReadingsHistory WHERE ReadingTime < \"%s\";", //there is other approach //"DELETE FROM DeviceHistory WHERE Timestamp < \"%s\";", "DELETE FROM DeviceHealthHistory WHERE Timestamp < \"%s\";", "DELETE FROM NeighborHealthHistory WHERE Timestamp < \"%s\";", "DELETE FROM AlertNotifications WHERE AlertTime < \"%s\";", "DELETE FROM DeviceChannelsHistory WHERE Timestamp < \"%s\";", "DELETE FROM ISACSConfirmDataBuffer WHERE Timestamp < \"%s\";", "DELETE FROM Firmwares WHERE UploadStatus = 5 AND UploadDate < \"%s\";" }; LOG("DEBUG CleanupOldRecords START [%s] [%s]", nlib::ToString(olderThanDate).c_str(), nlib::ToString(currTime - nlib::util::hours(24*7)).c_str()); for( int i = 0; i< sizeof(pszQry) / sizeof(pszQry[0]); ++i) { char szQry[ 1024 ]; snprintf( szQry, sizeof(szQry), pszQry[i], (i>=2) ? nlib::ToString(olderThanDate).c_str() : (nlib::ToString(currTime - nlib::util::hours(24*7)).c_str()) ); szQry[ sizeof(szQry)-1 ] = 0; std::string obQry( szQry ); MySQLCommand command(connection, obQry); try { BeginTransaction(); command.ExecuteNonQuery(); CommitTransaction(); } catch(std::exception& ex) { LOG_ERROR("CATCH(exception): CleanupOldRecords failed at step=" << i << " error=" << ex.what()); RollbackTransaction(); } catch(...) { LOG_ERROR("CATCH(...): CleanupOldRecords failed at step=" << i ); RollbackTransaction(); } } LOG_STR("DEBUG CleanupOldRecords END"); }
FReply FGridSlotExtension::HandleShiftColumn(int32 ShiftAmount) { BeginTransaction(LOCTEXT("MoveWidget", "Move Widget")); for ( FWidgetReference& Selection : SelectionCache ) { ShiftColumn(Selection.GetPreview(), ShiftAmount); ShiftColumn(Selection.GetTemplate(), ShiftAmount); } EndTransaction(); FBlueprintEditorUtils::MarkBlueprintAsModified(Blueprint); return FReply::Handled(); }