core/sql/refresh/RuMultiTxnRefreshTaskExecutor.h - trafodion - Git at Google

 /**********************************************************************
 // @@@ START COPYRIGHT @@@
 //
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 //
 // @@@ END COPYRIGHT @@@
 //
 **********************************************************************/
 #ifndef _RU_MULTI_TXN_REFRESH_TASK_EXECUTOR_H_
 #define _RU_MULTI_TXN_REFRESH_TASK_EXECUTOR_H_

 /* -
 *-C++-*-
 ******************************************************************************
 *
 * File:         RuMultiTxnRefreshTaskExecutor.h
 * Description:  Definition of class CRUMultiTxnRefreshTaskExecutor.
 *
 * Created:      08/14/2000
 * Language:     C++
 *
 *
 ******************************************************************************
 */

 //--------------------------------------------------------------------------//
 // This class handle the refresh of a multi transaction audited mv.
 // The class implements a finite state machine where some states may be
 // executed in a different process.
 //
 // The executor is handled to recover from multiple failures (process crash).
 // For each such failure we keep a "water mark" that signs the maximal
 // clustering index (CLI) of that table that we have already read (This is
 // done by the internal refresh in a special mode ,see Internal refresh
 // design document)
 //
 // The process of recovering from a multiple failure is done by executing
 // intrenal refresh on a boundaries that are set by those water marks.After
 // such execution we can join the two "water marks" to a single water mark.
 // We keep on going until there is a single water mark ,so we can just
 // continue from that CLI and process the rest of the table.
 //
 // The executor must also keeps track on the refresh progress for knowing how
 // to  activate the internal refresh command after a failure.
 // Therefore the executor will read the context log in the begining of every
 // execution. In the next stages the executor will imitate the IR context
 // updates in the memory using the class RuMultiTxnContext.
 // In this way, the context will have an exact representation of the rows in
 // the context table.
 //
 // The class has the following states :
 //
 //	1.EX_PROLOGUE	 - Starts a transaction,Reads the context
 //			   from the umd table and insert a new context row
 //	2.EX_NO_BOUNDS	 - Execute an internal refresh command with no bounds
 //	3.EX_LOWER_BOUND - Execute an internal refresh command with a minimal CLI
 //	4.EX_UPPER_BOUND - Execute an internal refresh command with a maximal CLI
 //	5.EX_BOTH_BOUND	 - Execute an internal refresh command between two CLI's
 //	6.EX_REMOTE_END	 - Unlocks any used tables if needed
 //	7.EX_EPILOGUE	 - Update the metadata , delete all context rows from
 //			   the umd table and commits the transaction
 //
 //--------------------------------------------------------------------------//

 #include "RuRefreshTaskExecutor.h"
 #include "RuSQLDynamicStatementContainer.h"
 #include "RuMultiTxnContext.h"

 class CRUTbl;
 class CDSStringList;
 class CRUEmpCheck;
 class CRUEmpCheckVector;

 class REFRESH_LIB_CLASS CRUMultiTxnRefreshTaskExecutor :
 		public CRURefreshTaskExecutor {

 private:
 	typedef CRURefreshTaskExecutor inherited;

 	//----------------------------------//
 	//	Public Members
 	//----------------------------------//
 public:
 	CRUMultiTxnRefreshTaskExecutor(CRURefreshTask *pParentTask = NULL);
 	virtual ~CRUMultiTxnRefreshTaskExecutor();

 public:
 	//-- Implementation of pure virtuals
 	virtual void Work();

 	virtual void Init();

 public:
 	// These functions serialize/de-serialize the executor's context
 	// for the message communication with the remote server process

 	// Used in the main process side
 	virtual void StoreRequest(CUOFsIpcMessageTranslator &translator);
 	virtual void LoadReply(CUOFsIpcMessageTranslator &translator);

 	// Used in the remote process side
 	virtual void LoadRequest(CUOFsIpcMessageTranslator &translator);
 	virtual void StoreReply(CUOFsIpcMessageTranslator &translator);


 	//----------------------------------//
 	//	Protected Members
 	//----------------------------------//

 protected:
 	virtual void LogOpeningMessage();

 	virtual void LogClosureMessage();


 	//-- Refinement of a pure virtual
 	virtual void FinalMetadataUpdate()
 	{
 		inherited::FinalMetadataUpdate();
 	}

 	// We override this function for the purpose of counting
 	// the number of Txns that we have already completed
 	virtual void CommitTransaction(BOOL countIt=TRUE)
 	{
 		inherited::CommitTransaction();
 		if (countIt)
 		{
 		      txnCounter_++;
 		}
 	}

 	// Update the MULTI_TXN_TARGET_COLUMN in MVS_UMD table
 	void UpdateTargetEpoch(TInt32 epoch);

 	//----------------------------------//
 	//	Private Members
 	//----------------------------------//

 private:

 	enum SQL_STATEMENT {  NO_BOUNDS_REFRESH =0,   // PHASE 0
 			      LOWER_BOUND_REFRESH ,   // PHASE 1
 			      UPPER_BOUND_REFRESH ,   // PHASE 0 CATCHUP
 			      BOTH_BOUND_REFRESH  ,   // PHASE 1 CATCHUP
 			      READ_CONTEXT_LOG,	      // read context log table
 			      CQS_PHASE1,	      // a CQS statment for IR phase 1
 			      NUM_OF_SQL_STMT	      // should always be last
 	};

 	enum SQL_STATIC_STATMENTS { UPDATE_CTX = 0 // update target epoch in MVS_UMD
 	};

 	enum PHASES {	PHASE_0 = 0,
 			PHASE_1 = 1,
 			NEED_CATCHUP = TRUE,
 			DONT_NEED_CATCHUP = FALSE
 		    };
 	// error code recieved from Internal Refresh when no more TXN are needed
 	enum { NO_MORE_TXN_CODE_ERROR = -12316};

 private:

 	// Init()  callee function
 	void ComposeMySql();

 private:

 	// Work() callee functions
 	void Start();
 	void Prologue();
 	void Epilogue();
 	void NoBounds();
 	void LowerBound();
 	void UpperBound();
 	void BothBounds();
 	void RemoteEnd();

 private:

 	// Compile the refresh statement returns TRUE when the refresh ends
 	CDMPreparedStatement * CompileRefresh(SQL_STATEMENT type,
 					      TInt32 beginEpoch ,
 					      TInt32 endEpoch   ,
 					      TInt32 catchupEpoch=0);

 	// Execute internal refresh until
 	// a no more txn needed error is thrown
 	// This function is called by BothBounds() and LowerBound()
 	void DoIRefreshUntilIDone(SQL_STATEMENT type);

 	// This function verifies that the only error that occured is
 	// NO_MORE_TXN_CODE_ERROR otherwise it ReThrow the exception
 	void VerifyMultiTxnError(CDSException &ex);

 	enum MoreTxnStatus {
 		NO_MORE_TXN_NEEDED = FALSE,
 		MORE_TXN_NEEDED = TRUE
 	};

 	// overriding CRURefreshTaskExecutor::ApplyCQSForInternalRefresh()
 	void ApplyCQSForInternalRefresh();


 private:

 	enum	STATES {
 		// Local States
 		EX_EPILOGUE = MAIN_STATES_START ,
 		// Remote States
 		EX_PROLOGUE = REMOTE_STATES_START ,
 		EX_NO_BOUNDS,
 		EX_LOWER_BOUND,
 		EX_UPPER_BOUND,
 		EX_BOTH_BOUND,
 		EX_REMOTE_END
 	};

 private:

 	//-- Prevent copying
 	CRUMultiTxnRefreshTaskExecutor(const CRUMultiTxnRefreshTaskExecutor &other);
 	CRUMultiTxnRefreshTaskExecutor &
 						operator = (const CRUMultiTxnRefreshTaskExecutor &other);

 private:

 	CRUSQLDynamicStatementContainer multiTxnRefreshTEDynamicContainer_;

 	// The following data is common for all Work() states

 	TInt32							endEpoch_;
 	TInt32							beginEpoch_;
 	TInt32							catchupEpoch_;
 	// If we are in a catchup mode , multiTxnTargetEpoch_ will not be zero
 	TInt32							multiTxnTargetEpoch_;

 	// The number of transactions we already completed
 	short							txnCounter_;

 	// Stack with context lines from the UMD table
 	CRUMultiTxnContext				context_;
 	// Emptiness check is done for completing the lock protocol
 };

 #endif
	/**********************************************************************
	// @@@ START COPYRIGHT @@@
	//
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.
	//
	// @@@ END COPYRIGHT @@@
	//
	**********************************************************************/
	#ifndef _RU_MULTI_TXN_REFRESH_TASK_EXECUTOR_H_
	#define _RU_MULTI_TXN_REFRESH_TASK_EXECUTOR_H_

	/* -
	-C++--
	******************************************************************************
	*
	* File: RuMultiTxnRefreshTaskExecutor.h
	* Description: Definition of class CRUMultiTxnRefreshTaskExecutor.
	*
	* Created: 08/14/2000
	* Language: C++
	*
	*
	******************************************************************************
	*/

	//--------------------------------------------------------------------------//
	// This class handle the refresh of a multi transaction audited mv.
	// The class implements a finite state machine where some states may be
	// executed in a different process.
	//
	// The executor is handled to recover from multiple failures (process crash).
	// For each such failure we keep a "water mark" that signs the maximal
	// clustering index (CLI) of that table that we have already read (This is
	// done by the internal refresh in a special mode ,see Internal refresh
	// design document)
	//
	// The process of recovering from a multiple failure is done by executing
	// intrenal refresh on a boundaries that are set by those water marks.After
	// such execution we can join the two "water marks" to a single water mark.
	// We keep on going until there is a single water mark ,so we can just
	// continue from that CLI and process the rest of the table.
	//
	// The executor must also keeps track on the refresh progress for knowing how
	// to activate the internal refresh command after a failure.
	// Therefore the executor will read the context log in the begining of every
	// execution. In the next stages the executor will imitate the IR context
	// updates in the memory using the class RuMultiTxnContext.
	// In this way, the context will have an exact representation of the rows in
	// the context table.
	//
	// The class has the following states :
	//
	// 1.EX_PROLOGUE - Starts a transaction,Reads the context
	// from the umd table and insert a new context row
	// 2.EX_NO_BOUNDS - Execute an internal refresh command with no bounds
	// 3.EX_LOWER_BOUND - Execute an internal refresh command with a minimal CLI
	// 4.EX_UPPER_BOUND - Execute an internal refresh command with a maximal CLI
	// 5.EX_BOTH_BOUND - Execute an internal refresh command between two CLI's
	// 6.EX_REMOTE_END - Unlocks any used tables if needed
	// 7.EX_EPILOGUE - Update the metadata , delete all context rows from
	// the umd table and commits the transaction
	//
	//--------------------------------------------------------------------------//

	#include "RuRefreshTaskExecutor.h"
	#include "RuSQLDynamicStatementContainer.h"
	#include "RuMultiTxnContext.h"

	class CRUTbl;
	class CDSStringList;
	class CRUEmpCheck;
	class CRUEmpCheckVector;

	class REFRESH_LIB_CLASS CRUMultiTxnRefreshTaskExecutor :
	public CRURefreshTaskExecutor {

	private:
	typedef CRURefreshTaskExecutor inherited;

	//----------------------------------//
	// Public Members
	//----------------------------------//
	public:
	CRUMultiTxnRefreshTaskExecutor(CRURefreshTask *pParentTask = NULL);
	virtual ~CRUMultiTxnRefreshTaskExecutor();

	public:
	//-- Implementation of pure virtuals
	virtual void Work();

	virtual void Init();

	public:
	// These functions serialize/de-serialize the executor's context
	// for the message communication with the remote server process

	// Used in the main process side
	virtual void StoreRequest(CUOFsIpcMessageTranslator &translator);
	virtual void LoadReply(CUOFsIpcMessageTranslator &translator);

	// Used in the remote process side
	virtual void LoadRequest(CUOFsIpcMessageTranslator &translator);
	virtual void StoreReply(CUOFsIpcMessageTranslator &translator);


	//----------------------------------//
	// Protected Members
	//----------------------------------//

	protected:
	virtual void LogOpeningMessage();

	virtual void LogClosureMessage();


	//-- Refinement of a pure virtual
	virtual void FinalMetadataUpdate()
	{
	inherited::FinalMetadataUpdate();
	}

	// We override this function for the purpose of counting
	// the number of Txns that we have already completed
	virtual void CommitTransaction(BOOL countIt=TRUE)
	{
	inherited::CommitTransaction();
	if (countIt)
	{
	txnCounter_++;
	}
	}

	// Update the MULTI_TXN_TARGET_COLUMN in MVS_UMD table
	void UpdateTargetEpoch(TInt32 epoch);

	//----------------------------------//
	// Private Members
	//----------------------------------//

	private:

	enum SQL_STATEMENT { NO_BOUNDS_REFRESH =0, // PHASE 0
	LOWER_BOUND_REFRESH , // PHASE 1
	UPPER_BOUND_REFRESH , // PHASE 0 CATCHUP
	BOTH_BOUND_REFRESH , // PHASE 1 CATCHUP
	READ_CONTEXT_LOG, // read context log table
	CQS_PHASE1, // a CQS statment for IR phase 1
	NUM_OF_SQL_STMT // should always be last
	};

	enum SQL_STATIC_STATMENTS { UPDATE_CTX = 0 // update target epoch in MVS_UMD
	};

	enum PHASES { PHASE_0 = 0,
	PHASE_1 = 1,
	NEED_CATCHUP = TRUE,
	DONT_NEED_CATCHUP = FALSE
	};
	// error code recieved from Internal Refresh when no more TXN are needed
	enum { NO_MORE_TXN_CODE_ERROR = -12316};

	private:

	// Init() callee function
	void ComposeMySql();

	private:

	// Work() callee functions
	void Start();
	void Prologue();
	void Epilogue();
	void NoBounds();
	void LowerBound();
	void UpperBound();
	void BothBounds();
	void RemoteEnd();

	private:

	// Compile the refresh statement returns TRUE when the refresh ends
	CDMPreparedStatement * CompileRefresh(SQL_STATEMENT type,
	TInt32 beginEpoch ,
	TInt32 endEpoch ,
	TInt32 catchupEpoch=0);

	// Execute internal refresh until
	// a no more txn needed error is thrown
	// This function is called by BothBounds() and LowerBound()
	void DoIRefreshUntilIDone(SQL_STATEMENT type);

	// This function verifies that the only error that occured is
	// NO_MORE_TXN_CODE_ERROR otherwise it ReThrow the exception
	void VerifyMultiTxnError(CDSException &ex);

	enum MoreTxnStatus {
	NO_MORE_TXN_NEEDED = FALSE,
	MORE_TXN_NEEDED = TRUE
	};

	// overriding CRURefreshTaskExecutor::ApplyCQSForInternalRefresh()
	void ApplyCQSForInternalRefresh();


	private:

	enum STATES {
	// Local States
	EX_EPILOGUE = MAIN_STATES_START ,
	// Remote States
	EX_PROLOGUE = REMOTE_STATES_START ,
	EX_NO_BOUNDS,
	EX_LOWER_BOUND,
	EX_UPPER_BOUND,
	EX_BOTH_BOUND,
	EX_REMOTE_END
	};

	private:

	//-- Prevent copying
	CRUMultiTxnRefreshTaskExecutor(const CRUMultiTxnRefreshTaskExecutor &other);
	CRUMultiTxnRefreshTaskExecutor &
	operator = (const CRUMultiTxnRefreshTaskExecutor &other);

	private:

	CRUSQLDynamicStatementContainer multiTxnRefreshTEDynamicContainer_;

	// The following data is common for all Work() states

	TInt32 endEpoch_;
	TInt32 beginEpoch_;
	TInt32 catchupEpoch_;
	// If we are in a catchup mode , multiTxnTargetEpoch_ will not be zero
	TInt32 multiTxnTargetEpoch_;

	// The number of transactions we already completed
	short txnCounter_;

	// Stack with context lines from the UMD table
	CRUMultiTxnContext context_;
	// Emptiness check is done for completing the lock protocol
	};

	#endif