自学教程：C++ BeginTransaction函数代码示例

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 */ boolWheelTransaction::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;}

/**  * @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);	}	}

voidClientLayerManager::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();}

voidClientLayerManager::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_IMETHODIMPnsTransactionManager::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_IMETHODIMPnsTransactionManager::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 CRUEmpCheckTaskExecutor::PerformEmptinessCheck(){	pEmpCheck_->PrepareSQL();	BeginTransaction();	pEmpCheck_->PerformCheck();			CommitTransaction(); // Although no write operations were performed...}

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();}