//---------------------------------------------------------------------------
// @function:
// CAutoTaskProxy::PropagateError
//
// @doc:
// Propagate the error from sub task to current task
//
//---------------------------------------------------------------------------
void
CAutoTaskProxy::PropagateError
(
CTask *ptskSub
)
{
GPOS_ASSERT(m_fPropagateError);
// sub-task must be in error status and have a pending exception
GPOS_ASSERT(ITask::EtsError == ptskSub->Ets() && ptskSub->FPendingExc());
CTask *ptskCur = CTask::PtskSelf();
// current task must have no pending error
GPOS_ASSERT(NULL != ptskCur && !ptskCur->FPendingExc());
IErrorContext *perrctxtCur = ptskCur->Perrctxt();
// copy necessary error info for propagation
perrctxtCur->CopyPropErrCtxt(ptskSub->Perrctxt());
// reset error of sub task
ptskSub->Perrctxt()->Reset();
// propagate the error
CException::Reraise(perrctxtCur->Exc(), true /*fPropagate*/);
}
//---------------------------------------------------------------------------
// @function:
// CException::Raise
//
// @doc:
// Throw/rethrow interface
//
//---------------------------------------------------------------------------
void
CException::Raise
(
CException exc
)
{
#ifdef GPOS_DEBUG
if (NULL != ITask::PtskSelf())
{
IErrorContext *perrctxt = ITask::PtskSelf()->Perrctxt();
GPOS_ASSERT_IMP(perrctxt->FPending(),
perrctxt->Exc() == exc &&
"Rethrow inconsistent with current error context");
}
#endif // GPOS_DEBUG
throw exc;
}
//---------------------------------------------------------------------------
// @function:
// CErrorHandlerStandard::Process
//
// @doc:
// Process pending error context;
//
//---------------------------------------------------------------------------
void
CErrorHandlerStandard::Process
(
CException exc
)
{
CTask *ptsk = CTask::PtskSelf();
GPOS_ASSERT(NULL != ptsk && "No task in current context");
IErrorContext *perrctxt = ptsk->Perrctxt();
CLogger *plog = dynamic_cast<CLogger*>(ptsk->PlogErr());
GPOS_ASSERT(perrctxt->FPending() && "No error to process");
GPOS_ASSERT(perrctxt->Exc() == exc &&
"Exception processed different from pending");
// print error stack trace
if (CException::ExmaSystem == exc.UlMajor() && !perrctxt->FRethrow())
{
if ((CException::ExmiIOError == exc.UlMinor() ||
CException::ExmiNetError == exc.UlMinor() ) &&
0 < errno)
{
perrctxt->AppendErrnoMsg();
}
if (ILogger::EeilMsgHeaderStack <= plog->Eil())
{
perrctxt->AppendStackTrace();
}
}
// scope for suspending cancellation
{
// suspend cancellation
CAutoSuspendAbort asa;
// log error message
plog->Log(perrctxt->WszMsg(), perrctxt->UlSev(), __FILE__, __LINE__);
}
}
//---------------------------------------------------------------------------
// @function:
// COptTasks::OptimizeTask
//
// @doc:
// task that does the optimizes query to physical DXL
//
//---------------------------------------------------------------------------
void*
COptTasks::OptimizeTask
(
void *ptr
)
{
GPOS_ASSERT(NULL != ptr);
SOptContext *opt_ctxt = SOptContext::Cast(ptr);
GPOS_ASSERT(NULL != opt_ctxt->m_query);
GPOS_ASSERT(NULL == opt_ctxt->m_plan_dxl);
GPOS_ASSERT(NULL == opt_ctxt->m_plan_stmt);
AUTO_MEM_POOL(amp);
IMemoryPool *mp = amp.Pmp();
// Does the metadatacache need to be reset?
//
// On the first call, before the cache has been initialized, we
// don't care about the return value of MDCacheNeedsReset(). But
// we need to call it anyway, to give it a chance to initialize
// the invalidation mechanism.
bool reset_mdcache = gpdb::MDCacheNeedsReset();
// initialize metadata cache, or purge if needed, or change size if requested
if (!CMDCache::FInitialized())
{
CMDCache::Init();
CMDCache::SetCacheQuota(optimizer_mdcache_size * 1024L);
}
else if (reset_mdcache)
{
CMDCache::Reset();
CMDCache::SetCacheQuota(optimizer_mdcache_size * 1024L);
}
else if (CMDCache::ULLGetCacheQuota() != (ULLONG) optimizer_mdcache_size * 1024L)
{
CMDCache::SetCacheQuota(optimizer_mdcache_size * 1024L);
}
// load search strategy
CSearchStageArray *search_strategy_arr = LoadSearchStrategy(mp, optimizer_search_strategy_path);
CBitSet *trace_flags = NULL;
CBitSet *enabled_trace_flags = NULL;
CBitSet *disabled_trace_flags = NULL;
CDXLNode *plan_dxl = NULL;
IMdIdArray *col_stats = NULL;
MdidHashSet *rel_stats = NULL;
GPOS_TRY
{
// set trace flags
trace_flags = CConfigParamMapping::PackConfigParamInBitset(mp, CXform::ExfSentinel);
SetTraceflags(mp, trace_flags, &enabled_trace_flags, &disabled_trace_flags);
// set up relcache MD provider
CMDProviderRelcache *relcache_provider = GPOS_NEW(mp) CMDProviderRelcache(mp);
{
// scope for MD accessor
CMDAccessor mda(mp, CMDCache::Pcache(), default_sysid, relcache_provider);
ULONG num_segments = gpdb::GetGPSegmentCount();
ULONG num_segments_for_costing = optimizer_segments;
if (0 == num_segments_for_costing)
{
num_segments_for_costing = num_segments;
}
CAutoP<CTranslatorQueryToDXL> query_to_dxl_translator;
query_to_dxl_translator = CTranslatorQueryToDXL::QueryToDXLInstance
(
mp,
&mda,
(Query*) opt_ctxt->m_query
);
ICostModel *cost_model = GetCostModel(mp, num_segments_for_costing);
COptimizerConfig *optimizer_config = CreateOptimizerConfig(mp, cost_model);
CConstExprEvaluatorProxy expr_eval_proxy(mp, &mda);
IConstExprEvaluator *expr_evaluator =
GPOS_NEW(mp) CConstExprEvaluatorDXL(mp, &mda, &expr_eval_proxy);
CDXLNode *query_dxl = query_to_dxl_translator->TranslateQueryToDXL();
CDXLNodeArray *query_output_dxlnode_array = query_to_dxl_translator->GetQueryOutputCols();
CDXLNodeArray *cte_dxlnode_array = query_to_dxl_translator->GetCTEs();
GPOS_ASSERT(NULL != query_output_dxlnode_array);
BOOL is_master_only = !optimizer_enable_motions ||
(!optimizer_enable_motions_masteronly_queries && !query_to_dxl_translator->HasDistributedTables());
CAutoTraceFlag atf(EopttraceDisableMotions, is_master_only);
plan_dxl = COptimizer::PdxlnOptimize
(
mp,
&mda,
query_dxl,
query_output_dxlnode_array,
cte_dxlnode_array,
expr_evaluator,
num_segments,
gp_session_id,
gp_command_count,
search_strategy_arr,
optimizer_config
);
if (opt_ctxt->m_should_serialize_plan_dxl)
{
// serialize DXL to xml
CWStringDynamic plan_str(mp);
COstreamString oss(&plan_str);
CDXLUtils::SerializePlan(mp, oss, plan_dxl, optimizer_config->GetEnumeratorCfg()->GetPlanId(), optimizer_config->GetEnumeratorCfg()->GetPlanSpaceSize(), true /*serialize_header_footer*/, true /*indentation*/);
opt_ctxt->m_plan_dxl = CreateMultiByteCharStringFromWCString(plan_str.GetBuffer());
}
// translate DXL->PlStmt only when needed
if (opt_ctxt->m_should_generate_plan_stmt)
{
// always use opt_ctxt->m_query->can_set_tag as the query_to_dxl_translator->Pquery() is a mutated Query object
// that may not have the correct can_set_tag
opt_ctxt->m_plan_stmt = (PlannedStmt *) gpdb::CopyObject(ConvertToPlanStmtFromDXL(mp, &mda, plan_dxl, opt_ctxt->m_query->canSetTag, query_to_dxl_translator->GetDistributionHashOpsKind()));
}
CStatisticsConfig *stats_conf = optimizer_config->GetStatsConf();
col_stats = GPOS_NEW(mp) IMdIdArray(mp);
stats_conf->CollectMissingStatsColumns(col_stats);
rel_stats = GPOS_NEW(mp) MdidHashSet(mp);
PrintMissingStatsWarning(mp, &mda, col_stats, rel_stats);
rel_stats->Release();
col_stats->Release();
expr_evaluator->Release();
query_dxl->Release();
optimizer_config->Release();
plan_dxl->Release();
}
}
GPOS_CATCH_EX(ex)
{
ResetTraceflags(enabled_trace_flags, disabled_trace_flags);
CRefCount::SafeRelease(rel_stats);
CRefCount::SafeRelease(col_stats);
CRefCount::SafeRelease(enabled_trace_flags);
CRefCount::SafeRelease(disabled_trace_flags);
CRefCount::SafeRelease(trace_flags);
CRefCount::SafeRelease(plan_dxl);
CMDCache::Shutdown();
IErrorContext *errctxt = CTask::Self()->GetErrCtxt();
opt_ctxt->m_should_error_out = ShouldErrorOut(ex);
opt_ctxt->m_is_unexpected_failure = IsUnexpectedFailure(ex);
opt_ctxt->m_error_msg = CreateMultiByteCharStringFromWCString(errctxt->GetErrorMsg());
GPOS_RETHROW(ex);
}
GPOS_CATCH_END;
// cleanup
ResetTraceflags(enabled_trace_flags, disabled_trace_flags);
CRefCount::SafeRelease(enabled_trace_flags);
CRefCount::SafeRelease(disabled_trace_flags);
CRefCount::SafeRelease(trace_flags);
if (!optimizer_metadata_caching)
{
CMDCache::Shutdown();
}
return NULL;
}
//---------------------------------------------------------------------------
// @function:
// CTreeMapTest::EresUnittest_Memo
//
// @doc:
// Test loading map from actual memo
//
//---------------------------------------------------------------------------
GPOS_RESULT
CTreeMapTest::EresUnittest_Memo()
{
GPOS_SET_TRACE(EtraceDisablePrintMemoryLeak);
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
// setup a file-based provider
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp);
CEngine *peng = NULL;
CExpression *pexpr = NULL;
CQueryContext *pqc = NULL;
CExpression *pexprPlan = NULL;
{
// install opt context in TLS
CAutoOptCtxt aoc
(
pmp,
&mda,
NULL, /* pceeval */
CTestUtils::Pcm(pmp)
);
CAutoTraceFlag atf(EopttraceEnumeratePlans, true);
peng = GPOS_NEW(pmp) CEngine(pmp);
// generate join expression
pexpr = CTestUtils::PexprLogicalJoin<CLogicalInnerJoin>(pmp);
// generate query context
pqc = CTestUtils::PqcGenerate(pmp, pexpr);
// Initialize engine
peng->Init(pqc, NULL /*pdrgpss*/);
// optimize query
peng->Optimize();
// extract plan
pexprPlan = peng->PexprExtractPlan();
GPOS_ASSERT(NULL != pexprPlan);
peng->Trace();
{
CAutoTrace at(pmp);
ULLONG ullCount = peng->Pmemotmap()->UllCount();
#ifdef GPOS_DEBUG
// test resetting map and re-creating it
peng->ResetTreeMap();
ULLONG ullCount2 = peng->Pmemotmap()->UllCount();
GPOS_ASSERT(ullCount == ullCount2);
#endif // GPOS_DEBUG
for (ULONG ulRank = 0; ulRank < ullCount; ulRank++)
{
CDrvdPropCtxtPlan *pdpctxtplan = GPOS_NEW(pmp) CDrvdPropCtxtPlan(pmp, false /*fUpdateCTEMap*/);
CExpression *pexprAlt = NULL;
GPOS_TRY
{
pexprAlt = peng->Pmemotmap()->PrUnrank(pmp, pdpctxtplan, ulRank);
at.Os() << std::endl << "ALTERNATIVE ["<< ulRank <<"]:" << std::endl << *pexprAlt << std::endl;
}
GPOS_CATCH_EX(ex)
{
if (!GPOS_MATCH_EX(ex, gpopt::ExmaGPOPT, gpopt::ExmiUnsatisfiedRequiredProperties))
{
GPOS_RETHROW(ex);
}
IErrorContext *perrctxt = CTask::PtskSelf()->Perrctxt();
at.Os() << perrctxt->WszMsg() << std::endl;
GPOS_RESET_EX;
}
GPOS_CATCH_END;
CRefCount::SafeRelease(pexprAlt);
CRefCount::SafeRelease(pdpctxtplan);
}
}
}
// clean up
CRefCount::SafeRelease(pexprPlan);
GPOS_DELETE(pqc);
CRefCount::SafeRelease(pexpr);
GPOS_DELETE(peng);
return GPOS_OK;
}