C++ COperator类代码示例

//---------------------------------------------------------------------------
//	@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));
//.........这里部分代码省略.........

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