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