//---------------------------------------------------------------------------
// @function:
// CPhysicalHashJoin::FNullableHashKey
//
// @doc:
// Check whether a hash key is nullable
//
//---------------------------------------------------------------------------
BOOL
CPhysicalHashJoin::FNullableHashKey
(
ULONG ulKey,
CColRefSet *pcrsNotNull,
BOOL fInner
)
const
{
COperator *pop = NULL;
if (fInner)
{
pop = (*m_pdrgpexprInnerKeys)[ulKey]->Pop();
}
else
{
pop = (*m_pdrgpexprOuterKeys)[ulKey]->Pop();
}
EOperatorId eopid = pop->Eopid();
if (COperator::EopScalarIdent == eopid)
{
const CColRef *pcr = CScalarIdent::PopConvert(pop)->Pcr();
return (!pcrsNotNull->FMember(pcr));
}
if (COperator::EopScalarConst == eopid)
{
return CScalarConst::PopConvert(pop)->Pdatum()->FNull();
}
// be conservative for all other scalar expressions where we cannot easily
// determine nullability
return true;
}
Expression CFunction::operator()( const Expression &arg ){
uint run1,run2;
CFunction thisFunction(*this);
thisFunction.nn = arg.getDim();
for( run1 = 0; run1 < maxAlloc; run1++ ){
thisFunction.xStore [run1] = new double[thisFunction.nn];
thisFunction.seedStore[run1] = new double[thisFunction.nn];
for( run2 = 0; run2 < thisFunction.nn; run2++ ){
thisFunction.xStore [run1][run2] = 0.0;
thisFunction.seedStore[run1][run2] = 0.0;
}
}
Expression tmp(dim);
COperator dummy;
dummy.increaseID();
for( run1 = 0; run1 < dim; run1++ ){
delete tmp.element[run1];
tmp.element[run1] = new COperator( thisFunction, arg, run1 );
}
return tmp;
}
void CCmdMoveObject::_Execute()
{
COpearationLog::GetInst()->WriteOperationLog("DO LShift Or C move object");
CTerrainMesh * pTerrainMesh = CMapEditApp::GetInst()->GetEditingMesh();
COperator * pOperator = CMapEditApp::GetInst()->GetOperator();
CMapEditObject * pModel = m_diff.pObject->GetModelGroup()->GetSelfPresentation(0);
pModel->SetGroupOffset(m_diff.vGroupOffset);
// erase center image info
int nCenterGridIndex = pModel->GetUserOffsetAdjustedGridIndex(m_diff.nCenterGridIndex);
SGrid & gridCenter = pTerrainMesh->GetGrid(nCenterGridIndex);
gridCenter.vecCenterObjects.erase(
remove(gridCenter.vecCenterObjects.begin(), gridCenter.vecCenterObjects.end(), m_diff.pObject), gridCenter.vecCenterObjects.end() );
CToolSetModel::GetInst()->AddActiveObject(m_diff.pObject);
m_diff.pObject->SetCenterGridIndex(INVALID);
m_diff.pObject->GetModelGroup()->SetEditState(sqr::EES_MOVING);
// update hot
CTObject * p = NULL;
CVector3f v;
DWORD dwGridIndexHot = CPicker::GetInst()->GetPickPos(&p,&v);
pOperator->SetGridIndexHot(dwGridIndexHot);
pOperator->SetHitPoint(*((CVector3f*)&v));
pOperator->SetObjectHot(p);
}
//---------------------------------------------------------------------------
// @function:
// CXformGbAggWithMDQA2Join::PexprTransform
//
// @doc:
// Main transformation driver
//
//---------------------------------------------------------------------------
CExpression *
CXformGbAggWithMDQA2Join::PexprTransform
(
IMemoryPool *pmp,
CExpression *pexpr
)
{
// protect against stack overflow during recursion
GPOS_CHECK_STACK_SIZE;
GPOS_ASSERT(NULL != pmp);
GPOS_ASSERT(NULL != pexpr);
COperator *pop = pexpr->Pop();
if (COperator::EopLogicalGbAgg == pop->Eopid())
{
CExpression *pexprResult = PexprExpandMDQAs(pmp, pexpr);
if (NULL != pexprResult)
{
return pexprResult;
}
}
// recursively process child expressions
const ULONG ulArity = pexpr->UlArity();
DrgPexpr *pdrgpexprChildren = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ul = 0; ul < ulArity; ul++)
{
CExpression *pexprChild = PexprTransform(pmp, (*pexpr)[ul]);
pdrgpexprChildren->Append(pexprChild);
}
pop->AddRef();
return GPOS_NEW(pmp) CExpression(pmp, pop, pdrgpexprChildren);
}
//---------------------------------------------------------------------------
// @function:
// CExpressionHandle::PcrsUsedColumns
//
// @doc:
// Return the columns used by a logical operator and all its scalar children
//
//---------------------------------------------------------------------------
CColRefSet *
CExpressionHandle::PcrsUsedColumns
(
IMemoryPool *pmp
)
{
COperator *pop = Pop();
GPOS_ASSERT(pop->FLogical());
CColRefSet *pcrs = GPOS_NEW(pmp) CColRefSet(pmp);
// get columns used by the operator itself
pcrs->Include(CLogical::PopConvert(pop)->PcrsLocalUsed());
// get columns used by the scalar children
const ULONG ulArity = UlArity();
for (ULONG ul = 0; ul < ulArity; ul++)
{
if (FScalarChild(ul))
{
pcrs->Include(Pdpscalar(ul)->PcrsUsed());
}
}
return pcrs;
}
void CToolHideTileRegionInView::OperatorDeleteTileRegion()
{
CTerrainMesh *pTerrain = CMapEditApp::GetInst()->GetEditingMesh();
COperator *pOperator = CMapEditApp::GetInst()->GetOperator();
int nHotGrid = pOperator->GetGridIndexHot();
const SGrid &grid = pTerrain->GetGrid(nHotGrid);
STileRegion *pTileregion = pTerrain->GetTileRegion(grid.dwBufferIndex);
int nHotTileRegionIndex = grid.dwBufferIndex;
if( pTileregion )
{
invisiblePool::iterator iter = m_invisibleTileRegionIndexs.find(nHotTileRegionIndex);
if ( iter != m_invisibleTileRegionIndexs.end() )
{
int nTileRegionIndex = iter->first;
int nSubTileRegionIndex = -1;
const subRegIndexPool subIndexs = iter->second;
iter->second.erase(grid.bSubRenderUnitIndex);
if( iter->second.empty() )
m_invisibleTileRegionIndexs.erase(iter);
}
STileRenderRegionUnit *pRenderRegionUnit = pTileregion->vRenderRegionUnits[grid.bSubRenderUnitIndex];
pRenderRegionUnit->bIsVisibleInView = true;
pTerrain->SetTerrainNodeVisbileMark(nHotTileRegionIndex, grid.bSubRenderUnitIndex, true);
}
::SendMessage(m_hTileRegionView, WM_TILEREGIONVIEW_REFRESH,0,0);
}
//void CMaintenanceMenu::OnButton7(int iEvent, unsigned char * pEventData, int iDataLen)
//{
// string strErr = "";
//
// DBG_PRINT(("g_globalArg->m_curInvVol->m_ieno = %u", g_globalArg->m_curInvVol->m_ieno));
// DBG_PRINT(("g_globalArg->m_curInvVol->m_remain = %u", g_globalArg->m_curInvVol->m_remain));
// INT32 nOldCurNo = g_globalArg->m_curInvVol->m_ieno + 1 -
// g_globalArg->m_curInvVol->m_remain;
// DBG_PRINT(("g_globalArg->m_curInvVol->m_ieno = %u", nOldCurNo));
//
// if (g_globalArg->m_initFlag == 0)
// {
// strErr = "机器未初始化";
// CaMsgBox::ShowMsg(strErr);
// return ;
// }
//
// string strInvNo("");
// INT32 status;
// INT8 tmpstr[128];
// UINT32 curInvNo;
// CInvVol invVol;
//
// DBG_ENTER("CDeptEditWin::DoActive()");
// ReFresh();
//
// CaMsgBox msgBox("新当前号:",CaMsgBox::MB_INPUT);
// msgBox.SetInputType(CaInput::aINT);
// msgBox.SetMaxInputLen(8);
// while (1)
// {
// msgBox.ShowBox();
// status = msgBox.m_iStatus;
// strInvNo = (INT8 *)msgBox.GetInputContent();
// if (status != OK_PRESSED || strInvNo != "")
// break;
//
// CaMsgBox::ShowMsg("请输入有效发票号");
// }
//
// if (status == OK_PRESSED)
// {
// curInvNo = atoi(strInvNo.c_str());
// DBG_PRINT(("curInvNo = %u", curInvNo));
//
// if (curInvNo <= 0)
// {
// CaMsgBox::ShowMsg("当前发票号必须大于0");
// this->ReFresh();
// return;
// }
//
// DBG_PRINT(("m_InvStartNo = %u", g_globalArg->m_curInvVol->m_isno));
// DBG_PRINT(("m_InvEndNo = %u", g_globalArg->m_curInvVol->m_ieno));
//// if((curInvNo < g_globalArg->m_curInvVol->m_InvStartNo)||
//// ((curInvNo - g_globalArg->m_curInvVol->m_InvStartNo) >= MAX_INV_VOL_NUM))
// if( curInvNo < g_globalArg->m_curInvVol->m_isno ||
// curInvNo > g_globalArg->m_curInvVol->m_ieno)
// {
// CaMsgBox::ShowMsg("当前发票号必须属于当前卷");
// this->ReFresh();
// return;
// }
//
// DBG_PRINT(("nOldCurNo = u%", nOldCurNo));
// DBG_PRINT(("curInvNo = u%", curInvNo));
// if (curInvNo <= nOldCurNo)
// {
// CaMsgBox::ShowMsg("不能向前更新");
// this->ReFresh();
// return;
// }
//
// //更新INV_VOL中的当前卷信息
// string sqlstr= "";
// INT32 errcode;
// UINT32 nRemain = g_globalArg->m_curInvVol->m_ieno - curInvNo + 1;
//
// sprintf(tmpstr,"update INV_VOL set REMAIN = %u where CODE = '%s' and IS_NO = %u",
// nRemain, g_globalArg->m_curInvVol->m_code.c_str(),
// g_globalArg->m_curInvVol->m_isno);
// sqlstr=tmpstr;
// invVol.SetSQL(sqlstr);
// errcode = invVol.ExecuteSQL();
// if (invVol.ExecuteSQL() != SQLITE_OK)
// {
// DBG_PRINT(("更新当前发票号错误 errcode=%d", errcode));
// CaMsgBox::ShowMsg("更新当前发票号失败");
// return;
// }
// g_globalArg->m_curInvVol->m_remain = nRemain;
// CaMsgBox::ShowMsg("更新当前发票号成功");
// }
//}
void CMaintenanceMenu::OnButton7(int iEvent, unsigned char * pEventData, int iDataLen)
{
string strMsg("");
COperator oper;
INT8 chValue[64];
memset((void*)chValue, 0, sizeof(chValue));
sprintf(chValue, "where ROLE = %u", DIRECTOR_ROLE);
oper.m_filter = chValue;
oper.Requery();
INT32 errcode = oper.LoadOneRecord();
if (SQLITE_DONE == errcode)
{
strMsg = "无主管员工";
}
else if (SQLITE_OK == errcode)
{
sprintf(chValue, "密码：%s", oper.m_passwd.c_str());
strMsg = chValue;
}
else
{
strMsg = "查询主管员工失败";
}
CaMsgBox::ShowMsg(strMsg);
}
//---------------------------------------------------------------------------
// @function:
// COptimizationContext::FOptimize
//
// @doc:
// Return true if given group expression should be optimized under
// given context
//
//---------------------------------------------------------------------------
BOOL
COptimizationContext::FOptimize
(
IMemoryPool *mp,
CGroupExpression *pgexprParent,
CGroupExpression *pgexprChild,
COptimizationContext *pocChild,
ULONG ulSearchStages
)
{
COperator *pop = pgexprChild->Pop();
if (CUtils::FPhysicalMotion(pop))
{
return FOptimizeMotion(mp, pgexprParent, pgexprChild, pocChild, ulSearchStages);
}
if (COperator::EopPhysicalSort == pop->Eopid())
{
return FOptimizeSort(mp, pgexprParent, pgexprChild, pocChild, ulSearchStages);
}
if (CUtils::FPhysicalAgg(pop))
{
return FOptimizeAgg(mp, pgexprParent, pgexprChild, pocChild, ulSearchStages);
}
if (CUtils::FNLJoin(pop))
{
return FOptimizeNLJoin(mp, pgexprParent, pgexprChild, pocChild, ulSearchStages);
}
return true;
}
void CToolHideTileRegionInView::Render()
{
if( m_bShow )
{
invisiblePool::iterator beg = m_invisibleTileRegionIndexs.begin();
invisiblePool::iterator end = m_invisibleTileRegionIndexs.end();
for ( beg; beg!= end; ++beg )
{
int nTileRegionIndex = beg->first;
int nSubTileRegionIndex = -1;
const subRegIndexPool subIndexs = beg->second;
for ( subRegIndexPool::const_iterator iter = subIndexs.begin(); iter != subIndexs.end(); ++ iter )
{
nSubTileRegionIndex = *iter;
this->RenderOneTileRegion(nTileRegionIndex, nSubTileRegionIndex, m_pTileRegionSetTexture);
}
}
}
CTerrainMesh *pTerrain = CMapEditApp::GetInst()->GetEditingMesh();
COperator *pOperator = CMapEditApp::GetInst()->GetOperator();
int nHotGrid = pOperator->GetGridIndexHot();
SGrid &grid = pTerrain->GetGrid(nHotGrid);
int nHotTileRegionIndex = grid.dwBufferIndex;
int nSubTileRegionIndex = grid.bSubRenderUnitIndex;
this->RenderOneTileRegion(nHotTileRegionIndex, nSubTileRegionIndex, m_pTileRegionLockTexture);
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PushThruUnaryWithScalarChild
//
// @doc:
// Push a conjunct through a unary operator with scalar child
//
//---------------------------------------------------------------------------
void
CNormalizer::PushThruUnaryWithScalarChild
(
IMemoryPool *pmp,
CExpression *pexprLogical,
CExpression *pexprConj,
CExpression **ppexprResult
)
{
GPOS_ASSERT(NULL != pexprLogical);
GPOS_ASSERT(2 == pexprLogical->UlArity());
GPOS_ASSERT(NULL != pexprConj);
GPOS_ASSERT(NULL != ppexprResult);
// get logical and scalar children
CExpression *pexprLogicalChild = (*pexprLogical)[0];
CExpression *pexprScalarChild = (*pexprLogical)[1];
// push conjuncts through the logical child
CExpression *pexprNewLogicalChild = NULL;
DrgPexpr *pdrgpexprUnpushable = NULL;
// break scalar expression to conjuncts
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprConj);
PushThru(pmp, pexprLogicalChild, pdrgpexprConjuncts, &pexprNewLogicalChild, &pdrgpexprUnpushable);
pdrgpexprConjuncts->Release();
// create a new logical expression based on recursion results
COperator *pop = pexprLogical->Pop();
pop->AddRef();
pexprScalarChild->AddRef();
CExpression *pexprNewLogical = GPOS_NEW(pmp) CExpression(pmp, pop, pexprNewLogicalChild, pexprScalarChild);
*ppexprResult = PexprSelect(pmp, pexprNewLogical, pdrgpexprUnpushable);
}
//---------------------------------------------------------------------------
// @function:
// CDecorrelator::FProcessMaxOneRow
//
// @doc:
// Decorrelate max one row operator
//
//---------------------------------------------------------------------------
BOOL
CDecorrelator::FProcessMaxOneRow
(
IMemoryPool *pmp,
CExpression *pexpr,
BOOL fEqualityOnly,
CExpression **ppexprDecorrelated,
DrgPexpr *pdrgpexprCorrelations
)
{
GPOS_ASSERT(NULL != pexpr);
COperator *pop = pexpr->Pop();
GPOS_ASSERT(COperator::EopLogicalMaxOneRow == pop->Eopid());
// fail if MaxOneRow expression has outer references
if (CUtils::FHasOuterRefs(pexpr))
{
return false;
}
// decorrelate relational child
CExpression *pexprRelational = NULL;
if (!FProcess(pmp, (*pexpr)[0], fEqualityOnly, &pexprRelational, pdrgpexprCorrelations))
{
GPOS_ASSERT(NULL == pexprRelational);
return false;
}
// assemble new project
pop->AddRef();
*ppexprDecorrelated = GPOS_NEW(pmp) CExpression(pmp, pop, pexprRelational);
return true;
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PexprNormalize
//
// @doc:
// Main driver
//
//---------------------------------------------------------------------------
CExpression *
CNormalizer::PexprNormalize
(
IMemoryPool *pmp,
CExpression *pexpr
)
{
GPOS_CHECK_STACK_SIZE;
GPOS_ASSERT(NULL != pexpr);
if (0 == pexpr->UlArity())
{
// end recursion early for leaf patterns extracted from memo
pexpr->AddRef();
return pexpr;
}
CExpression *pexprResult = NULL;
COperator *pop = pexpr->Pop();
if (pop->FLogical() && CLogical::PopConvert(pop)->FSelectionOp())
{
if (FPushThruOuterChild(pexpr))
{
CExpression *pexprConstTrue = CUtils::PexprScalarConstBool(pmp, true /*fVal*/);
PushThru(pmp, pexpr, pexprConstTrue, &pexprResult);
pexprConstTrue->Release();
}
else
{
// add-ref all children except scalar predicate
const ULONG ulArity = pexpr->UlArity();
DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ul = 0; ul < ulArity - 1; ul++)
{
CExpression *pexprChild = (*pexpr)[ul];
pexprChild->AddRef();
pdrgpexpr->Append(pexprChild);
}
// normalize scalar predicate and construct a new expression
CExpression *pexprPred = (*pexpr)[pexpr->UlArity() - 1];
CExpression *pexprPredNormalized = PexprRecursiveNormalize(pmp, pexprPred);
pdrgpexpr->Append(pexprPredNormalized);
COperator *pop = pexpr->Pop();
pop->AddRef();
CExpression *pexprNew = GPOS_NEW(pmp) CExpression(pmp, pop, pdrgpexpr);
// push normalized predicate through
PushThru(pmp, pexprNew, pexprPredNormalized, &pexprResult);
pexprNew->Release();
}
}
else
{
pexprResult = PexprRecursiveNormalize(pmp, pexpr);
}
GPOS_ASSERT(NULL != pexprResult);
return pexprResult;
}
//---------------------------------------------------------------------------
// @function:
// CXformSubqJoin2Apply::PexprReplaceSubqueries
//
// @doc:
// Replace subqueries with scalar identifiers based on given map
//
//---------------------------------------------------------------------------
CExpression *
CXformSubqJoin2Apply::PexprReplaceSubqueries
(
IMemoryPool *mp,
CExpression *pexprScalar,
ExprToColRefMap *phmexprcr
)
{
GPOS_CHECK_STACK_SIZE;
GPOS_ASSERT(NULL != pexprScalar);
GPOS_ASSERT(NULL != phmexprcr);
CColRef *colref = phmexprcr->Find(pexprScalar);
if (NULL != colref)
{
// look-up succeeded on root operator, we return here
return CUtils::PexprScalarIdent(mp, colref);
}
// recursively process children
const ULONG arity = pexprScalar->Arity();
CExpressionArray *pdrgpexprChildren = GPOS_NEW(mp) CExpressionArray(mp);
for (ULONG ul = 0; ul < arity; ul++)
{
CExpression *pexprChild = PexprReplaceSubqueries(mp, (*pexprScalar)[ul], phmexprcr);
pdrgpexprChildren->Append(pexprChild);
}
COperator *pop = pexprScalar->Pop();
pop->AddRef();
return GPOS_NEW(mp) CExpression(mp, pop, pdrgpexprChildren);
}
COperator * CSceneManager::AddNodeOperator(HWND hResSetView, ISceneNode * pParent)
{
if ( !pParent )
pParent = this;
COperator * pNode = new COperator(pParent);
pNode->Create(hResSetView);
return pNode;
}
void CToolMainPlayer::OnEvent(const CMsg& msg)
{
COperator * pOperator = CMapEditApp::GetInst()->GetOperator();
CTerrainMesh * pTerrainMesh = CMapEditApp::GetInst()->GetEditingMesh();
switch ( msg.msgSource )
{
case MGS_MOUSEMSG:
{
if( msg.msgType.key_type == MGT_MOUSE_LBNDOWN )
{
if ( m_ani != "" && m_ani != "run01" )
{
if( !m_pMainPlayer->SetNextAnimation("run01",FramePair(0,-1),true,200,1.0f) )
{
if( m_pMainPlayer->SetNextAnimation("run01_y",FramePair(0,-1),true,200,1.0f) )
m_ani = "run01_y";
}
else
m_ani = "run01";
}
else
{
m_pMainPlayer->SetNextAnimation("stand01",FramePair(0,-1),true,200,1.0f) ;
}
if ( pTerrainMesh->IsValid(pOperator->GetGridIndexHot()) )
{
m_bStop = false;
m_vEnd = pOperator->GetHitPoint();
//实时更新区域值
CSceneRegionMgr::GetInst()->CalcRegionLightByRegionDistance(m_vEnd);
m_vStart = m_vPos;
m_fRoad = (m_vEnd-m_vStart).Mag();
m_vDir = m_vEnd - m_vPos;
m_vDir.y = 0.0f;
m_vDir.normalize();
m_mat._11 = m_vDir.z;
m_mat._13 = -m_vDir.x;
m_mat._31 = m_vDir.x;
m_mat._33 = m_vDir.z;
}
}
}
break;
}
}
//---------------------------------------------------------------------------
// @function:
// CExpressionHandle::DerivePlanProps
//
// @doc:
// Derive the properties of the plan carried by attached cost context
//
//---------------------------------------------------------------------------
void
CExpressionHandle::DerivePlanProps
(
CDrvdPropCtxtPlan *pdpctxtplan
)
{
GPOS_ASSERT(NULL != m_pcc);
GPOS_ASSERT(NULL != m_pgexpr);
GPOS_ASSERT(NULL == m_pdrgpdp);
GPOS_ASSERT(NULL == m_pdp);
GPOS_CHECK_ABORT;
// check if properties have been already derived
if (NULL != m_pcc->Pdpplan())
{
CopyCostCtxtProps();
return;
}
GPOS_ASSERT(NULL != pdpctxtplan);
// extract children's properties
m_pdrgpdp = GPOS_NEW(m_pmp) DrgPdp(m_pmp);
const ULONG ulArity = m_pcc->Pdrgpoc()->UlLength();
for (ULONG ul = 0; ul < ulArity; ul++)
{
COptimizationContext *pocChild = (*m_pcc->Pdrgpoc())[ul];
CDrvdPropPlan *pdpplan = pocChild->PccBest()->Pdpplan();
GPOS_ASSERT(NULL != pdpplan);
pdpplan->AddRef();
m_pdrgpdp->Append(pdpplan);
// add child props to derivation context
CDrvdPropCtxt::AddDerivedProps(pdpplan, pdpctxtplan);
}
COperator *pop = m_pgexpr->Pop();
if (COperator::EopPhysicalCTEConsumer == pop->Eopid())
{
// copy producer plan properties to passed derived plan properties context
ULONG ulCTEId = CPhysicalCTEConsumer::PopConvert(pop)->UlCTEId();
CDrvdPropPlan *pdpplan = m_pcc->Poc()->Prpp()->Pcter()->Pdpplan(ulCTEId);
if (NULL != pdpplan)
{
pdpctxtplan->CopyCTEProducerProps(pdpplan, ulCTEId);
}
}
// set the number of expected partition selectors in the context
pdpctxtplan->SetExpectedPartitionSelectors(pop, m_pcc);
// create/derive local properties
m_pdp = Pop()->PdpCreate(m_pmp);
m_pdp->Derive(m_pmp, *this, pdpctxtplan);
}
//---------------------------------------------------------------------------
// @function:
// CDecorrelator::FProcessProject
//
// @doc:
// Decorrelate project/sequence project
//
//---------------------------------------------------------------------------
BOOL
CDecorrelator::FProcessProject
(
IMemoryPool *pmp,
CExpression *pexpr,
BOOL fEqualityOnly,
CExpression **ppexprDecorrelated,
DrgPexpr *pdrgpexprCorrelations
)
{
COperator::EOperatorId eopid = pexpr->Pop()->Eopid();
GPOS_ASSERT(COperator::EopLogicalProject == eopid ||
COperator::EopLogicalSequenceProject == eopid);
CExpression *pexprPrjList = (*pexpr)[1];
// fail if project elements have outer references
CColRefSet *pcrsOutput = CDrvdPropRelational::Pdprel((*pexpr)[0]->PdpDerive())->PcrsOutput();
CColRefSet *pcrsUsed = CDrvdPropScalar::Pdpscalar(pexprPrjList->PdpDerive())->PcrsUsed();
if (!pcrsOutput->FSubset(pcrsUsed))
{
return false;
}
if (COperator::EopLogicalSequenceProject == eopid)
{
(void) pexpr->PdpDerive();
CExpressionHandle exprhdl(pmp);
exprhdl.Attach(pexpr);
exprhdl.DeriveProps(NULL /*pdpctxt*/);
if (CLogicalSequenceProject::PopConvert(pexpr->Pop())->FHasLocalOuterRefs(exprhdl))
{
// fail if a SequenceProject has local outer references
return false;
}
}
// decorrelate relational child
CExpression *pexprRelational = NULL;
if (!FProcess(pmp, (*pexpr)[0], fEqualityOnly, &pexprRelational, pdrgpexprCorrelations))
{
GPOS_ASSERT(NULL == pexprRelational);
return false;
}
// assemble new project
COperator *pop = pexpr->Pop();
pop->AddRef();
pexprPrjList->AddRef();
*ppexprDecorrelated = GPOS_NEW(pmp) CExpression(pmp, pop, pexprRelational, pexprPrjList);
return true;
}
//---------------------------------------------------------------------------
// @function:
// CBinding::PexprExtract
//
// @doc:
// Extract a binding according to a given pattern;
// Keep root node fixed;
//
//---------------------------------------------------------------------------
CExpression *
CBinding::PexprExtract
(
IMemoryPool *pmp,
CGroupExpression *pgexpr,
CExpression *pexprPattern,
CExpression *pexprLast
)
{
GPOS_CHECK_ABORT;
if (!pexprPattern->FMatchPattern(pgexpr))
{
// shallow matching fails
return NULL;
}
// the previously extracted pattern must have the same root
GPOS_ASSERT_IMP(NULL != pexprLast, pexprLast->Pgexpr() == pgexpr);
COperator *popPattern = pexprPattern->Pop();
if (popPattern->FPattern() && CPattern::PopConvert(popPattern)->FLeaf())
{
// return immediately; no deep extraction for leaf patterns
pgexpr->Pop()->AddRef();
return GPOS_NEW(pmp) CExpression(pmp, pgexpr->Pop(), pgexpr);
}
DrgPexpr *pdrgpexpr = NULL;
ULONG ulArity = pgexpr->UlArity();
if (0 == ulArity && NULL != pexprLast)
{
// no more bindings
return NULL;
}
else
{
// attempt binding to children
pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp);
if (!FExtractChildren(pmp, pgexpr, pexprPattern, pexprLast, pdrgpexpr))
{
pdrgpexpr->Release();
return NULL;
}
}
CExpression *pexpr = PexprFinalize(pmp, pgexpr, pdrgpexpr);
GPOS_ASSERT(NULL != pexpr);
return pexpr;
}
//---------------------------------------------------------------------------
// @function:
// CBinding::PexprFinalize
//
// @doc:
// Assemble expression; substitute operator with pattern as necessary
//
//---------------------------------------------------------------------------
CExpression *
CBinding::PexprFinalize
(
IMemoryPool *pmp,
CGroupExpression *pgexpr,
DrgPexpr *pdrgpexpr
)
{
COperator *pop = pgexpr->Pop();
pop->AddRef();
CExpression *pexpr = GPOS_NEW(pmp) CExpression(pmp, pop, pgexpr, pdrgpexpr, NULL /*pstatsInput*/);
return pexpr;
}
void CToolHideTileRegionInView::OnEvent(const CMsg& msg)
{
CTerrainMesh * pTerrain = CMapEditApp::GetInst()->GetTerrain();
switch ( msg.msgSource )
{
case MGS_KEYMSG:
{
switch(msg.msgType.key_type)
{
case MGT_KEY_DOWN:
{
switch(msg.msgInfo.key_info)
{
case MGI_KEY_F3:
{
this->OperatorAddTileRegionIndex();
}
return;
default:
break;
}
}
default:
return;
}
}
case MGS_MOUSEMSG:
{
switch(msg.msgType.mouse_type)
{
case MGT_MOUSE_MOVE:
CTerrainMesh *pTerrain = CMapEditApp::GetInst()->GetEditingMesh();
COperator *pOperator = CMapEditApp::GetInst()->GetOperator();
int nHotGrid = pOperator->GetGridIndexHot();
SGrid &grid = pTerrain->GetGrid(nHotGrid);
int nHotTileRegionIndex = grid.dwBufferIndex;
::SendMessage(m_hTileRegionView,WM_TILEREGIONVIEW_MARK, 0,(LPARAM)&nHotTileRegionIndex);
break;
}
default:
break;
}
}
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PushThruSeqPrj
//
// @doc:
// Push a conjunct through a sequence project expression
//
//---------------------------------------------------------------------------
void
CNormalizer::PushThruSeqPrj
(
IMemoryPool *pmp,
CExpression *pexprSeqPrj,
CExpression *pexprConj,
CExpression **ppexprResult
)
{
GPOS_ASSERT(NULL != pexprSeqPrj);
GPOS_ASSERT(CLogical::EopLogicalSequenceProject == pexprSeqPrj->Pop()->Eopid());
GPOS_ASSERT(NULL != pexprConj);
GPOS_ASSERT(NULL != ppexprResult);
// get logical and scalar children
CExpression *pexprLogicalChild = (*pexprSeqPrj)[0];
CExpression *pexprScalarChild = (*pexprSeqPrj)[1];
// break scalar expression to pushable and unpushable conjuncts
DrgPexpr *pdrgpexprPushable = NULL;
DrgPexpr *pdrgpexprUnpushable = NULL;
SplitConjunctForSeqPrj(pmp, pexprSeqPrj, pexprConj, &pdrgpexprPushable, &pdrgpexprUnpushable);
CExpression *pexprNewLogicalChild = NULL;
if (0 < pdrgpexprPushable->UlLength())
{
CExpression *pexprPushableConj = CPredicateUtils::PexprConjunction(pmp, pdrgpexprPushable);
PushThru(pmp, pexprLogicalChild, pexprPushableConj, &pexprNewLogicalChild);
pexprPushableConj->Release();
}
else
{
// no pushable predicates on top of sequence project,
// we still need to process child recursively to push-down child's own predicates
pdrgpexprPushable->Release();
pexprNewLogicalChild = PexprNormalize(pmp, pexprLogicalChild);
}
// create a new logical expression based on recursion results
COperator *pop = pexprSeqPrj->Pop();
pop->AddRef();
pexprScalarChild->AddRef();
CExpression *pexprNewLogical = GPOS_NEW(pmp) CExpression(pmp, pop, pexprNewLogicalChild, pexprScalarChild);
// create a select node for remaining predicates, if any
*ppexprResult = PexprSelect(pmp, pexprNewLogical, pdrgpexprUnpushable);
}
void CToolHideTileRegionInView::OperatorAddTileRegionIndex()
{
COperator *pOperator = CMapEditApp::GetInst()->GetOperator();
int nHotGrid = pOperator->GetGridIndexHot();
CTerrainMesh *pTerrain = CMapEditApp::GetInst()->GetEditingMesh();
const SGrid &grid = pTerrain->GetGrid(nHotGrid);
int nHotTileRegionIndex = grid.dwBufferIndex;
STileRegion *pTileregion = pTerrain->GetTileRegion(nHotTileRegionIndex);
if( pTileregion )
{
m_invisibleTileRegionIndexs[nHotTileRegionIndex].insert(grid.bSubRenderUnitIndex);
STileRenderRegionUnit *pRenderRegionUnit = pTileregion->vRenderRegionUnits[grid.bSubRenderUnitIndex];
pRenderRegionUnit->bIsVisibleInView = false;
pTerrain->SetTerrainNodeVisbileMark(nHotTileRegionIndex, grid.bSubRenderUnitIndex, false);
}
::SendMessage(m_hTileRegionView, WM_TILEREGIONVIEW_REFRESH,0,0);
}
/**********************************************************
* WinMain *
*---------*
* Description:
* Main entry point for the application
***********************************************************/
int WINAPI WinMain(
HINSTANCE hInst,
HINSTANCE hPrevInst,
LPSTR lpCmdLine,
int nCmdShow
)
{
// Initialize COM.
if (FAILED(::CoInitialize( NULL )))
{
return 0;
}
// Create an instance of our main call-handling class
COperator *pOperator = new COperator( hInst );
if ( !pOperator )
{
return 0;
}
// Does initialization of SAPI and TAPI objects
HRESULT hr = pOperator->Initialize();
if ( FAILED( hr ) )
{
return 0;
}
// everything is initialized, so
// start the main dialog box
::DialogBoxParam( hInst,
MAKEINTRESOURCE(IDD_MAINDLG),
NULL,
MainDialogProc,
(LPARAM) pOperator
);
// This does the cleanup of SAPI and TAPI objects
delete pOperator;
::CoUninitialize();
return 1;
}
//---------------------------------------------------------------------------
// @function:
// CDecorrelator::FProcessAssert
//
// @doc:
// Decorrelate assert operator
//
//---------------------------------------------------------------------------
BOOL
CDecorrelator::FProcessAssert
(
IMemoryPool *pmp,
CExpression *pexpr,
BOOL fEqualityOnly,
CExpression **ppexprDecorrelated,
DrgPexpr *pdrgpexprCorrelations
)
{
GPOS_ASSERT(NULL != pexpr);
COperator *pop = pexpr->Pop();
GPOS_ASSERT(COperator::EopLogicalAssert == pop->Eopid());
CExpression *pexprScalar = (*pexpr)[1];
// fail if assert expression has outer references
CColRefSet *pcrsOutput = CDrvdPropRelational::Pdprel((*pexpr)[0]->PdpDerive())->PcrsOutput();
CColRefSet *pcrsUsed = CDrvdPropScalar::Pdpscalar(pexprScalar->PdpDerive())->PcrsUsed();
if (!pcrsOutput->FSubset(pcrsUsed))
{
return false;
}
// decorrelate relational child
CExpression *pexprRelational = NULL;
if (!FProcess(pmp, (*pexpr)[0], fEqualityOnly, &pexprRelational, pdrgpexprCorrelations))
{
GPOS_ASSERT(NULL == pexprRelational);
return false;
}
// assemble new project
pop->AddRef();
pexprScalar->AddRef();
*ppexprDecorrelated = GPOS_NEW(pmp) CExpression(pmp, pop, pexprRelational, pexprScalar);
return true;
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PexprRecursiveNormalize
//
// @doc:
// Call normalizer recursively on children array
//
//
//---------------------------------------------------------------------------
CExpression *
CNormalizer::PexprRecursiveNormalize
(
IMemoryPool *pmp,
CExpression *pexpr
)
{
GPOS_ASSERT(NULL != pexpr);
const ULONG ulArity = pexpr->UlArity();
DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ul = 0; ul < ulArity; ul++)
{
CExpression *pexprChild = PexprNormalize(pmp, (*pexpr)[ul]);
pdrgpexpr->Append(pexprChild);
}
COperator *pop = pexpr->Pop();
pop->AddRef();
return GPOS_NEW(pmp) CExpression(pmp, pop, pdrgpexpr);
}
//---------------------------------------------------------------------------
// @function:
// CDecorrelator::FProcessLimit
//
// @doc:
// Decorrelate limit
//
//---------------------------------------------------------------------------
BOOL
CDecorrelator::FProcessLimit
(
IMemoryPool *pmp,
CExpression *pexpr,
BOOL fEqualityOnly,
CExpression **ppexprDecorrelated,
DrgPexpr *pdrgpexprCorrelations
)
{
GPOS_ASSERT(COperator::EopLogicalLimit == pexpr->Pop()->Eopid());
CExpression *pexprOffset = (*pexpr)[1];
CExpression *pexprRowCount = (*pexpr)[2];
// fail if there are any outer references below Limit
if (CUtils::FHasOuterRefs(pexpr))
{
return false;
}
// decorrelate relational child
CExpression *pexprRelational = NULL;
if (!FProcess(pmp, (*pexpr)[0], fEqualityOnly, &pexprRelational, pdrgpexprCorrelations))
{
GPOS_ASSERT(NULL == pexprRelational);
return false;
}
// assemble new project
COperator *pop = pexpr->Pop();
pop->AddRef();
pexprOffset->AddRef();
pexprRowCount->AddRef();
*ppexprDecorrelated = GPOS_NEW(pmp) CExpression(pmp, pop, pexprRelational, pexprOffset, pexprRowCount);
return true;
}
//---------------------------------------------------------------------------
// @function:
// CDistributionSpecHashed::PdshashedExcludeColumns
//
// @doc:
// Return a copy of the distribution spec after excluding the given
// columns, return NULL if all distribution expressions are excluded
//
//---------------------------------------------------------------------------
CDistributionSpecHashed *
CDistributionSpecHashed::PdshashedExcludeColumns
(
IMemoryPool *pmp,
CColRefSet *pcrs
)
{
GPOS_ASSERT(NULL != pcrs);
DrgPexpr *pdrgpexprNew = GPOS_NEW(pmp) DrgPexpr(pmp);
const ULONG ulExprs = m_pdrgpexpr->UlLength();
for (ULONG ul = 0; ul < ulExprs; ul++)
{
CExpression *pexpr = (*m_pdrgpexpr)[ul];
COperator *pop = pexpr->Pop();
if (COperator::EopScalarIdent == pop->Eopid())
{
// we only care here about column identifiers,
// any more complicated expressions are copied to output
const CColRef *pcr = CScalarIdent::PopConvert(pop)->Pcr();
if (pcrs->FMember(pcr))
{
continue;
}
}
pexpr->AddRef();
pdrgpexprNew->Append(pexpr);
}
if (0 == pdrgpexprNew->UlLength())
{
pdrgpexprNew->Release();
return NULL;
}
return GPOS_NEW(pmp) CDistributionSpecHashed(pdrgpexprNew, m_fNullsColocated);
}
void CToolHideTileRegionInView::GotoSelectTileRegion( const int nTileRegionIndex )
{
CTerrainMesh *pTerrain = CMapEditApp::GetInst()->GetEditingMesh();
STileRegion *pTileregion = pTerrain->GetTileRegion(nTileRegionIndex);
if( pTileregion == NULL )
return;
for ( uint n = 0; n < CTerrainMesh::Tile_PerSqr; ++n )
{
STileRenderRegionUnit *pRenderRegionUnit = pTileregion->vRenderRegionUnits[n];
if( pRenderRegionUnit->bIsVisibleInView )
continue;
size_t nGridCountInTileRegion = pRenderRegionUnit->vGridIndices.size();;
int nCenterGrid = nGridCountInTileRegion / 2;
DWORD dwGridIndex = pRenderRegionUnit->vGridIndices[nCenterGrid];
COperator *pOperator = CMapEditApp::GetInst()->GetOperator();
int nX = 0, nZ = 0;
pOperator->GetMapCoordinate(dwGridIndex, nX, nZ);
pOperator ->MoveTo(nX,nZ);
}
}
//---------------------------------------------------------------------------
// @function:
// CCostContext::FNeedsNewStats
//
// @doc:
// Check if we need to derive new stats for this context,
// by default a cost context inherits stats from the owner group,
// the only current exception is when part of the plan below cost
// context is affected by partition elimination done by partition
// selection in some other part of the plan
//
//---------------------------------------------------------------------------
BOOL
CCostContext::FNeedsNewStats() const
{
COperator *pop = m_pgexpr->Pop();
if (pop->FScalar())
{
// return false if scalar operator
return false;
}
CEnfdPartitionPropagation *pepp = Poc()->Prpp()->Pepp();
if (GPOS_FTRACE(EopttraceDeriveStatsForDPE) &&
CUtils::FPhysicalScan(pop) &&
CPhysicalScan::PopConvert(pop)->FDynamicScan() &&
!pepp->PpfmDerived()->FEmpty())
{
// context is attached to a dynamic scan that went through
// partition elimination in another part of the plan
return true;
}
// we need to derive stats if any child has modified stats
BOOL fDeriveStats = false;
const ULONG ulArity = Pdrgpoc()->UlLength();
for (ULONG ul = 0; !fDeriveStats && ul < ulArity; ul++)
{
COptimizationContext *pocChild = (*Pdrgpoc())[ul];
CCostContext *pccChild = pocChild->PccBest();
GPOS_ASSERT(NULL != pccChild);
fDeriveStats = pccChild->FOwnsStats();
}
return fDeriveStats;
}
int main()
{
//客户端调用例子
//客户端只需依赖COperator的接口类和工厂类，而无法知道具体的实现类
//实现了客户端和具体实现类之间的解耦
CFactory* ft= new CDivFactory(); //除法工厂
COperator* oper = ft->createOperator();
oper->setFirst(1);
oper->setSecond(2);
printf("%f + %f = %f\n", oper->getFirst(),oper->getSecond(),oper->getResult());
delete oper;
delete ft;
return 0;
}
