//--------------------------------------------------------------------------// // CRURefreshTaskExecutor::ComposeMDAMStatements() // //--------------------------------------------------------------------------// void CRURefreshTaskExecutor::ComposeMDAMStatements() { BOOL hasActiveCQS = FALSE; CRURefreshSQLComposer myComposer(GetRefreshTask()); CRUMV &rootMV = GetRefreshTask()->GetRootMV(); const CRUMVForceOptions* pForceOption = rootMV.GetMVForceOption(); // Even if there are no force options, we still force mdam for tables // with more than two columns. ComposeControlTableStmtForUsedTables(); // MV base tables force options // LCOV_EXCL_START :rfi if (NULL != pForceOption && CRUForceOptions::MDAM_NO_FORCE != pForceOption->GetMDAMoption()) { // Compose CONTROL TABLE mv_name MDAM option myComposer.ComposeCntrlTableMDAMText(pForceOption->GetMDAMoption(), &rootMV.GetFullName()); pRefreshTEDynamicContainer_->SetStatementText(MV_MDAM_STAT, myComposer.GetSQL()); forceFlags_ |= FORCE_MV_MDAM; } // Compose reset MDAMs if (forceFlags_ & FORCE_MV_MDAM || forceFlags_ & FORCE_TABLE_MDAM) { // Compose CONTROL TABLE * MDAM 'RESET' myComposer.ComposeResetCntrlTableMDAMText(); pRefreshTEDynamicContainer_->SetStatementText(RESET_MDAM_STAT, myComposer.GetSQL()); } // LCOV_EXCL_STOP }
void CRUSimpleRefreshSQLComposer::AddDeltaDefListClause() { RUASSERT(GetRefreshTask().GetDeltaDefList().GetCount() > 0); sql_ += "\n FROM "; sql_ += (TRUE == GetRefreshTask().IsSingleDeltaRefresh()) ? "SINGLEDELTA " : "MULTIDELTA "; DSListPosition pos = GetRefreshTask().GetDeltaDefList().GetHeadPosition(); for (;;) { CRUDeltaDef *pDdef = GetRefreshTask().GetDeltaDefList().GetNext(pos); CDSString fromEpoch(TInt32ToStr(pDdef->fromEpoch_)) ; CDSString toEpoch(TInt32ToStr(pDdef->toEpoch_)); AddDeltaDefClause(pDdef,fromEpoch,toEpoch); if (NULL == pos) { break; // The last clause } else { sql_ += ", "; } } if (FALSE == GetRefreshTask().IsSingleDeltaRefresh()) { AddPhaseParam(); } }
//--------------------------------------------------------------------------// // CRURefreshTaskExecutor::VerifyForceTblListCorrectness() // // Check that the user did not refered to a un-existing base table //--------------------------------------------------------------------------// void CRURefreshTaskExecutor::VerifyForceTblListCorrectness() { const CRUMVForceOptions &forceOption = *GetRefreshTask()->GetRootMV().GetMVForceOption(); const CRUTableForceOptionsList &tblList = forceOption.GetTableForceList(); DSListPosition pos = tblList.GetHeadPosition(); while (NULL != pos) { CRUTableForceOptions* forceOpt = tblList.GetNext(pos); CRUTbl *pTbl = GetRefreshTask()->GetRootMV().GetUsedTableByName(forceOpt->GetFullName()); if(NULL == pTbl) { CRUException ex; ex.SetError(IDS_RU_FORCE_FILE_TABLE_NOT_EXISTS); ex.AddArgument(GetRefreshTask()->GetRootMV().GetFullName()); ex.AddArgument(forceOpt->GetFullName()); throw ex; } } }
void CRURefreshTaskExecutor::GenClosureMessage(CDSString &msg) { CRURefreshTask &task = *GetRefreshTask(); if (task.GetMVList().GetCount() > 1) { if (FALSE == GetRefreshTask()->NeedToExecuteInternalRefresh()) { msg += RefreshDiags[2]; task.DumpNamesOfAllMVs(msg); msg += RefreshDiags[6]; } else { msg += RefreshDiags[2]; task.DumpNamesOfAllMVs(msg); msg += RefreshDiags[7]; } } else { if (FALSE == GetRefreshTask()->NeedToExecuteInternalRefresh()) { msg += RefreshDiags[3]; task.DumpNamesOfAllMVs(msg); msg += RefreshDiags[8]; } else { msg += RefreshDiags[3]; task.DumpNamesOfAllMVs(msg); msg += RefreshDiags[9]; } } }
void CRURefreshTaskExecutor::ComposeMySql() { CRURefreshSQLComposer myComposer(GetRefreshTask()); CRUMV &rootMV = GetRefreshTask()->GetRootMV(); numOfStmtInContainer_ = rootMV.GetTablesUsedByMe().GetCount() + FIRST_TBL_STAT; pRefreshTEDynamicContainer_ = #pragma nowarn(1506) // warning elimination new CRUSQLDynamicStatementContainer(numOfStmtInContainer_); #pragma warn(1506) // warning elimination ComposeForceStatements(); }
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); }
//--------------------------------------------------------------------------// // CRURefreshTaskExecutor::ComposeControlTableStmtForUsedTables() // // Compose the Control MDAM option for all base tables for forced tables //--------------------------------------------------------------------------// // LCOV_EXCL_START :rfi void CRURefreshTaskExecutor::ComposeControlTableStmtForUsedTables() { CRUMV &rootMV = GetRefreshTask()->GetRootMV(); const CRUMVForceOptions* pForceOption = rootMV.GetMVForceOption(); CRUForceOptions::MdamOptions mdamOpt = CRUForceOptions::MDAM_NO_FORCE; Int32 stmtIndex = FIRST_TBL_STAT; if (NULL != pForceOption) { VerifyForceTblListCorrectness(); if (pForceOption->IsTableStarUsed()) { mdamOpt = pForceOption->GetTableStarOption(); } } CRUTblList &tblList = rootMV.GetTablesUsedByMe(); DSListPosition pos = tblList.GetHeadPosition(); while (NULL != pos) { CRUTbl *pTbl = tblList.GetNext(pos); RUASSERT(NULL != pTbl); ComposeControlTableStmtForUsedTable(*pTbl,stmtIndex,mdamOpt); } }
CRUTableForceOptions* CRURefreshTaskExecutor::GetForceOptionForTable(const CDSString &name) { CRUMV &rootMV = GetRefreshTask()->GetRootMV(); const CRUMVForceOptions* pForceOption = rootMV.GetMVForceOption(); if (NULL == pForceOption) { return NULL; } const CRUTableForceOptionsList &tblList = pForceOption->GetTableForceList(); DSListPosition pos = tblList.GetHeadPosition(); while (NULL != pos) { CRUTableForceOptions* forceOpt = tblList.GetNext(pos); if (name == forceOpt->GetFullName()) { return forceOpt; } } return NULL; }
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 CRURefreshSQLComposer::AddPipeLineClause() { CRUMVList &mvList = GetRefreshTask().GetMVList(); RUASSERT(mvList.GetCount() > 1); DSListPosition pos = mvList.GetHeadPosition(); mvList.GetNext(pos); // Skip the root MV // Generate root clause CRUMV *pTopMV = mvList.GetNext(pos); sql_ += " PIPELINE " ; sql_ += "(" + pTopMV->GetFullName() + ")"; // Continue with the upper mv's while (NULL != pos) { sql_ += pTopMV->GetFullName(); // Retrieve the next MV from the list pTopMV = mvList.GetNext(pos); sql_ += " PIPELINE " ; sql_ += "(" + pTopMV->GetFullName() + ")"; if (NULL != pos) { sql_ += ","; } else { return; } } }
void CRUAuditRefreshTaskExecutor::ResetObjectsAvailable() { CRUMVList &mvList = GetRefreshTask()->GetMVList(); DSListPosition pos = mvList.GetHeadPosition(); while (NULL != pos) { CRUMV *pMV = mvList.GetNext(pos); BOOL mvUpdated = FALSE; // if hasn't been set to initialized, initialize it if( CDDObject::eINITIALIZED != pMV->GetMVStatus() ) { pMV->SetMVStatus(CDDObject::eINITIALIZED); mvUpdated = TRUE; } if (mvUpdated) { pMV->SaveMetadata(); } } if (TRUE == isPopindex_ && 0 < numOfIndexes_) { // Turn all indexes to available state ExecuteIndexStatmenents(*pAuditAvailableIndeXdynamicContainer_, IDS_RU_INDEXSTATUS_FAILED); } }
void CRURefreshTaskExecutor::UpdateRootMVStatistics(TInt32 currDuration) { CRURefreshTask &task = *GetRefreshTask(); if (FALSE == task.NeedToExecuteInternalRefresh()) { return; } CRUDeltaDefList &deltaDefList = task.GetDeltaDefList(); TInt32 prevDuration, nextDuration; CRUMV &rootMV = GetRootMV(); if (TRUE == IsRecompute()) { prevDuration = rootMV.GetRecomputeDurationEstimate(); nextDuration = EvaluateHeuristic(currDuration, prevDuration); rootMV.SetRecomputeDurationEstimate(nextDuration); return; } switch(deltaDefList.GetCount()) { case 0: { // This cannot happen // (NeedToExecuteInternalRefresh() must have returned FALSE). RUASSERT(FALSE); } case 1: { CRUDeltaDef *pDdef = deltaDefList.GetAt(0); // A special case: update the refresh duration, // and (optionally) the delta size. UpdateSingleDeltaStatistics(pDdef, currDuration); break; } case 2: { prevDuration = rootMV.GetRefreshDurationEstimateWith_2_Deltas(); nextDuration = EvaluateHeuristic(currDuration, prevDuration); rootMV.SetRefreshDurationEstimateWith_2_Deltas(nextDuration); break; } case 3: { prevDuration = rootMV.GetRefreshDurationEstimateWith_3_Deltas(); nextDuration = EvaluateHeuristic(currDuration, prevDuration); rootMV.SetRefreshDurationEstimateWith_3_Deltas(nextDuration); break; } default: { prevDuration = rootMV.GetRefreshDurationEstimateWith_N_Deltas(); nextDuration = EvaluateHeuristic(currDuration, prevDuration); rootMV.SetRefreshDurationEstimateWith_N_Deltas(nextDuration); break; } } }
void CRURefreshTaskExecutor::ComposeControlTableStmtForUsedTable(CRUTbl &tbl, Int32 &stmtIndex, CRUForceOptions::MdamOptions mdamOpt) { CRURefreshSQLComposer myComposer(GetRefreshTask()); if (CRUForceOptions::MDAM_NO_FORCE == mdamOpt) { CRUTableForceOptions *forceOpt = GetForceOptionForTable(tbl.GetFullName()); if (NULL == forceOpt) { mdamOpt = GetDefaultMdamOptForTable(tbl); } else { mdamOpt = forceOpt->GetMdamOptions(); } } if (CRUForceOptions::MDAM_NO_FORCE != mdamOpt) { // Compose CONTROL TABLE table_name MDAM option myComposer.ComposeCntrlTableMDAMText(mdamOpt, &(tbl.GetFullName())); pRefreshTEDynamicContainer_->SetStatementText #pragma nowarn(1506) // warning elimination (stmtIndex++, myComposer.GetSQL()); #pragma warn(1506) // warning elimination forceFlags_ |= FORCE_TABLE_MDAM; } }
void CRURefreshTaskExecutor::FinalMetadataUpdate() { CRURefreshTask *pParentTask = GetRefreshTask(); RUASSERT (NULL != pParentTask); TInt32 currDuration = 0; TInt64 ts = CalculateTimeStamp(); if (TRUE == pParentTask->NeedToExecuteInternalRefresh()) { currDuration = GetTimerDuration(); } CRUMV *pPrevMV, *pCurrMV = NULL; CRUMVList &mvList = pParentTask->GetMVList(); DSListPosition pos = mvList.GetHeadPosition(); while (NULL != pos) { pPrevMV = pCurrMV; pCurrMV = mvList.GetNext(pos); // Update the MV's REFRESHED_AT timestamp pCurrMV->SetTimestamp(ts); // publish the refresh event to the PUBLISH table NABoolean isRecomputePublish = (IsRecompute() == TRUE); pCurrMV->PublishMVRefresh(isRecomputePublish); if (CDDObject::eON_STATEMENT != pCurrMV->GetRefreshType()) { if (NULL == pPrevMV) { // This is the Root MV (the first in the list) if (CDDObject::eON_REQUEST == pCurrMV->GetRefreshType()) { // For every table T used by MV, // set MV.EPOCH[T]<--T.CURRENT_EPOCH. UpdateRootMVCurrentEpochVector(); } UpdateRootMVStatistics(currDuration); } else { UpdateNonRootMVStatistics(pCurrMV, pPrevMV, currDuration); } } pCurrMV->SaveMetadata(); } if (CDDObject::eON_STATEMENT != GetRootMV().GetRefreshType()) { IncrementTopMvCurrentEpoch(); } }
//--------------------------------------------------------------------------// // CRURefreshTaskExecutor::ComposeCQSStatements() // //--------------------------------------------------------------------------// void CRURefreshTaskExecutor::ComposeCQSStatements() { BOOL hasActiveCQS = FALSE; CRURefreshSQLComposer myComposer(GetRefreshTask()); CRUMV &rootMV = GetRefreshTask()->GetRootMV(); const CRUMVForceOptions* pForceOption = rootMV.GetMVForceOption(); if (NULL == pForceOption) { return; } // MV force options // LCOV_EXCL_START :rfi if ((CRUForceOptions::GB_NO_FORCE != pForceOption->GetGroupByoption() || CRUForceOptions::JOIN_NO_FORCE != pForceOption->GetJoinoption())) { // Compose Control query shape for internal refresh stmt myComposer.ComposeControlQueryShape(); pRefreshTEDynamicContainer_->SetStatementText(CQS_STAT, myComposer.GetSQL()); forceFlags_ = forceFlags_ | FORCE_CQS; hasActiveCQS = TRUE; } // Deal with a specific user CQS if (FALSE == pForceOption->GetCQSStatment().IsEmpty()) { pRefreshTEDynamicContainer_->SetStatementText (USER_CQS_FORCE, pForceOption->GetCQSStatment()); forceFlags_ = forceFlags_ | FORCE_USER_CQS; hasActiveCQS = TRUE; } if (TRUE == hasActiveCQS) { myComposer.ComposeControlQueryShapeCut(); pRefreshTEDynamicContainer_->SetStatementText(CQS_CUT_STAT, myComposer.GetSQL()); } // LCOV_EXCL_STOP }
void CRUSimpleRefreshSQLComposer::ComposeRefresh() { StartInternalRefresh(); AddDeltaDefListClause(); if (GetRefreshTask().GetMVList().GetCount() > 1) { AddPipeLineClause(); } }
void CRURefreshTaskExecutor::ComposeForceStatements() { CRUMV &rootMV = GetRefreshTask()->GetRootMV(); const CRUMVForceOptions* pForceOption = rootMV.GetMVForceOption(); CRURefreshSQLComposer myComposer(GetRefreshTask()); // Deal with explain data // LCOV_EXCL_START :rfi if (NULL != pForceOption && CRUForceOptions::EXPLAIN_ON == pForceOption->GetExplainOption()) { forceFlags_ = forceFlags_ | FORCE_SHOW_EXPLAIN; myComposer.ComposeShowExplain(); pRefreshTEDynamicContainer_->SetStatementText(SHOW_EXPLAIN, myComposer.GetSQL()); } // LCOV_EXCL_STOP ComposeCQSStatements(); ComposeMDAMStatements(); }
void CRURefreshTaskExecutor::IncrementTopMvCurrentEpoch() { CRUMV &mv = GetRefreshTask()->GetTopMV(); if (TRUE == mv.IsInvolvedTbl()) { CRUTbl *pTbl = mv.GetTblInterface(); pTbl->IncrementCurrentEpoch(TRUE /* through DDOL */); pTbl->SaveMetadata(); pTbl->SetTimestamp(mv.GetTimestamp()); } }
void CRUUnAuditRefreshTaskExecutor::ComposeMySql() { CRURefreshTask *pTask = GetRefreshTask(); CRUMV &mv = pTask->GetRootMV(); CRUSimpleRefreshSQLComposer myComposer(pTask); // UNLOCK TABLE statement myComposer.ComposeUnLock(GetRootMVName()); unAuditRefreshTEDynamicContainer_.SetStatementText (RU_UNLOCK_TABLE, myComposer.GetSQL()); // POPINDEX CatApi request if (TRUE == isPopindex_) { numOfIndexes_ = mv.GetIndexList().GetCount(); if (0 < numOfIndexes_) { ComposeIndexesSql(); } } // Compose the LOCK TABLE sql statements for locking all tables // in the on statement MV initialization if (CDDObject::eON_STATEMENT == GetRootMVType()) { CRUTblList &tblList = mv.GetTablesUsedByMe(); DSListPosition pos = tblList.GetHeadPosition(); pLockTablesTEDynamicContainer_ = new CRUSQLDynamicStatementContainer((short)tblList.GetCount()); Int32 i=0; while (NULL != pos) { CRUTbl *pTbl = tblList.GetNext(pos); myComposer.ComposeLock(pTbl->GetFullName(), FALSE /*shared*/); pLockTablesTEDynamicContainer_->SetStatementText #pragma nowarn(1506) // warning elimination (i,myComposer.GetSQL()); #pragma warn(1506) // warning elimination i++; } } }
void CRUUnAuditRefreshTaskExecutor::Start() { LogOpeningMessage(); StartTimer(); if (FALSE == GetRefreshTask()->NeedToExecuteInternalRefresh()) { SetState(EX_EPILOGUE); } else { SetState(EX_PROLOGUE); } }
void CRUAuditRefreshTaskExecutor::Init() { inherited::Init(); RUASSERT(TRUE == HasWork()); if (FALSE == GetRefreshTask()->NeedToExecuteInternalRefresh()) { return; } Lng32 refreshPattern = GetRootMV().GetRefreshPatternMap(); isPurgedata_ = (0 != (refreshPattern & CRUMV::PURGEDATA)); isPopindex_ = (0 != (refreshPattern & CRUMV::POPINDEX)); CRUMV &mv = GetRootMV(); if (mv.GetCommitNRows() != 0 && TRUE == GetRootMV().IsMultiTxnContext()) { RUASSERT(TRUE == GetRefreshTask()->IsRecompute()); // We need to drop multi-txn context table // becuase we are recomputing a multi-txn mv isDeleteMultiTxnContext_ = TRUE; } // We must synchronize between the table and the mv, so we need to // lock the table partitions // Here we copy the partitions file names in order to allow access to // the files in the remote process when DDOL is not built tableLockProtocol_ = new CRUTableLockProtocol(); tableLockProtocol_->Init(mv.GetTablesUsedByMe(), GetRefreshTask()->GetDeltaDefList()); ComposeMySql(); }
void CRUAuditRefreshTaskExecutor::ComposeMySql() { CRUSimpleRefreshSQLComposer myComposer(GetRefreshTask()); CRUMV &rootMV = GetRootMV(); if (TRUE == isDeleteMultiTxnContext_) { myComposer.ComposeDeleteContextLogTable(); auditRefreshTEDynamicContainer_.SetStatementText (DELETE_MULT_TXN_CTX_TBL,myComposer.GetSQL()); } // POPINDEX CatApi request if (TRUE == isPopindex_) { numOfIndexes_ = rootMV.GetIndexList().GetCount(); if (0 < numOfIndexes_) { ComposeIndexesSql(); } } // Compose the LOCK TABLE sql statements for locking all tables // in the on statement MV initialization if (CDDObject::eON_STATEMENT == GetRootMVType()) { CRUTblList &tblList = rootMV.GetTablesUsedByMe(); DSListPosition pos = tblList.GetHeadPosition(); pLockTablesTEDynamicContainer_ = new CRUSQLDynamicStatementContainer((short)tblList.GetCount()); Int32 i=0; while (NULL != pos) { CRUTbl *pTbl = tblList.GetNext(pos); myComposer.ComposeLock(pTbl->GetFullName(), FALSE /*shared*/); pLockTablesTEDynamicContainer_->SetStatementText (i,myComposer.GetSQL()); i++; } } }
void CRUUnAuditRefreshTaskExecutor::SetObjectsUnavailable() { if (TRUE == isPopindex_ && 0 < numOfIndexes_) { // Turn all indexes to unavailable state ExecuteIndexStatmenents(*pUnAuditUnavailableIndeXdynamicContainer_, IDS_RU_INDEXSTATUS_FAILED); } CRUMVList &mvList = GetRefreshTask()->GetMVList(); DSListPosition pos = mvList.GetHeadPosition(); while (NULL != pos) { CRUMV *pMV = mvList.GetNext(pos); if (CDDObject::eNO_AUDIT_ON_REFRESH == pMV->GetAuditType() // || // CDDObject::eAUDIT == pMV->GetAuditType() // DO NOT TURN THE AUDITED MV'S TABLE TO NON-AUDITED // UNTIL THE BUG WITH TURNING THE AUDIT ATTRIBUTE IS FIXED !!! // Right now, we assume that the MV's table is initially // non-audited if this task executor is picked up. ) { // Alter table audit uses "ALTER TABLE" syntax // and it cannot be performed if there is a DDL lock. // Due to the transaction protection , for any other transaction // the ddl locks will preserve continuity. pMV->ReleaseDDLLock(); pMV->SetMVTableAudit(FALSE); pMV->SaveMetadata(); pMV->CreateDDLLock(); } pMV->SetMVStatus(CDDObject::eUNAVAILABLE); pMV->SaveMetadata(); } // Since the mv ddl lock was released and recreated, the popindex // sql statements need to be recomposed if( TRUE == isPopindex_ && 0 < numOfIndexes_ ) { ComposeIndexesSql(); } }
void CRURefreshTaskExecutor::GenOpeningMessage(CDSString &msg) { CRURefreshTask &task = *GetRefreshTask(); if (task.GetMVList().GetCount() > 1) { msg += RefreshDiags[2]; task.DumpNamesOfAllMVs(msg); msg += RefreshDiags[4]; } else { msg += RefreshDiags[3]; task.DumpNamesOfAllMVs(msg); msg += RefreshDiags[5]; } }
void CRUAuditRefreshTaskExecutor::Start() { RUASSERT(FALSE == IsTransactionOpen()); LogOpeningMessage(); StartTimer(); TESTPOINT2(CRUGlobals::TESTPOINT130, GetRootMVName()) if (FALSE == GetRefreshTask()->NeedToExecuteInternalRefresh()) { // There is no delta , we only need to update the metadata SetState(EX_EPILOGUE); } else { SetState(EX_PROLOGUE); } }
void CRUUnAuditRefreshTaskExecutor::Init() { inherited::Init(); RUASSERT(TRUE == HasWork()); if (FALSE == GetRefreshTask()->NeedToExecuteInternalRefresh()) { return; } Lng32 refreshPattern = GetRootMV().GetRefreshPatternMap(); isPurgedata_ = (0 != (refreshPattern & CRUMV::PURGEDATA)); isPopindex_ = (0 != (refreshPattern & CRUMV::POPINDEX)); // Compose the INTERNAL REFRESH // + (optionally) the PopIndex CatApi request statements // + (optionally) the LOCK TABLE statements for ON STATEMENT MV ComposeMySql(); }
void CRUAuditRefreshTaskExecutor::SetObjectsUnavailable() { if (TRUE == isPopindex_ && 0 < numOfIndexes_) { // Turn all indexes to unavailable state ExecuteIndexStatmenents(*pAuditUnavailableIndeXdynamicContainer_, IDS_RU_INDEXSTATUS_FAILED); } // first turn the audit flag ON for the MV table // and set the MV to unavailable CRUMVList &mvList = GetRefreshTask()->GetMVList(); DSListPosition pos = mvList.GetHeadPosition(); while (NULL != pos) { CRUMV *pMV = mvList.GetNext(pos); // Alter table audit uses "ALTER TABLE" syntax // and it cannot be performed if there is a DDL lock. // Due to the transaction protection , for any other transaction // the ddl locks will preserve continuity. pMV->ReleaseDDLLock(); pMV->SetMVTableAudit(TRUE); pMV->SaveMetadata(); pMV->CreateDDLLock(); // if hasn't been set to initialized, initialize it if( CDDObject::eINITIALIZED != pMV->GetMVStatus() ) { pMV->SetMVStatus(CDDObject::eUNAVAILABLE); pMV->SaveMetadata(); } } // Since the mv ddl lock was released and recreated, the popindex // sql statements need to be recomposed if( TRUE == isPopindex_ && 0 < numOfIndexes_ ) { ComposeIndexesSql(); } }
void CRURefreshTaskExecutor:: UpdateNonRootMVStatistics(CRUMV *pCurrMV, CRUMV *pPrevMV, TInt32 currDuration) { if (FALSE == GetRefreshTask()->NeedToExecuteInternalRefresh()) { return; } TInt64 tblUid = pPrevMV->GetUID(); TInt32 prevDuration = pCurrMV->GetRefreshDurationEstimate(tblUid); TInt32 nextDuration = EvaluateHeuristic(currDuration, prevDuration); pCurrMV->SetRefreshDurationEstimate(tblUid, prevDuration); pCurrMV->SetDeltaSizeEstimate(tblUid, 0); }
void CRURefreshTaskExecutor::Init() { inherited::Init(); CRUMV &rootMV = GetRefreshTask()->GetRootMV(); SetRecompute(rootMV.WillBeRecomputed()); rootMVName_ = rootMV.GetFullName(); rootMVSchema_ = rootMV.GetCatName() + "." + rootMV.GetSchName(); rootMVCatalog_ = rootMV.GetCatName(); rootMVType_ = rootMV.GetRefreshType(); rootMVUID_ = rootMV.GetUID(); // Runtime consistency check. // Check requirement that the regular table's deltas // are empty (if they must be). CheckSingleDeltaRestriction(); ComposeMySql(); }
//--------------------------------------------------------------------------// // CRURefreshTaskExecutor::GetDefaultMdamOptForTable() // // If the table has more then two key columns and the range log is not empty // then mdam must be forced on the table unless the user forced otherwise //--------------------------------------------------------------------------// CRUForceOptions::MdamOptions CRURefreshTaskExecutor::GetDefaultMdamOptForTable(CRUTbl &tbl) { Int32 numTableKeyCol = tbl.GetKeyColumnList().GetCount(); if (numTableKeyCol < 2) { return CRUForceOptions::MDAM_NO_FORCE; } if (FALSE == GetRefreshTask()->IsSingleDeltaRefresh()) { return CRUForceOptions::MDAM_NO_FORCE; } const CRUDeltaDef *pDdef = GetRootMV().GetDeltaDefByUid(tbl.GetUID()); if (NULL != pDdef && TRUE == pDdef->isRangeLogNonEmpty_) { return CRUForceOptions::MDAM_ON; } return CRUForceOptions::MDAM_NO_FORCE; }