You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hawq.apache.org by en...@apache.org on 2015/12/11 02:39:48 UTC
[1/4] incubator-hawq git commit: HAWQ-246. Refactor and cleanup of
memory management of the new optimizer.
Repository: incubator-hawq
Updated Branches:
refs/heads/master 4b60c6c77 -> 9b65a5adc
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/include/gpopt/Allocators.h
----------------------------------------------------------------------
diff --git a/src/include/gpopt/Allocators.h b/src/include/gpopt/Allocators.h
deleted file mode 100644
index 42ba4c9..0000000
--- a/src/include/gpopt/Allocators.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-//---------------------------------------------------------------------------
-// @filename:
-// Allocators.h
-//
-// @doc:
-// Memory allocation/deallocation operators
-//
-// @test:
-//
-//---------------------------------------------------------------------------
-#ifndef GPOS_Allocators_H
-#define GPOS_Allocators_H
-
-#include "gpos/memory/IMemoryPool.h"
-
-using namespace gpos;
-
-//---------------------------------------------------------------------------
-// Overloading global new operators
-//---------------------------------------------------------------------------
-
-
-// throwing global singleton new operator
-void* operator new
- (
- gpos::SIZE_T cSize
- )
- throw(gpos::BAD_ALLOC);
-
-
-// throwing global array new operator
-void* operator new []
- (
- gpos::SIZE_T cSize
- )
- throw(gpos::BAD_ALLOC);
-
-
-// non-throwing global singleton new operator
-void *operator new
- (
- gpos::SIZE_T cSize,
- const gpos::NO_THROW &
- )
- throw();
-
-
-// non-throwing global array new operator
-void* operator new []
- (
- gpos::SIZE_T cSize,
- const gpos::NO_THROW &
- )
- throw();
-
-//---------------------------------------------------------------------------
-// Overloading new/delete to implement placement variants
-//---------------------------------------------------------------------------
-
-
-// placement new operator
-void *operator new
- (
- gpos::SIZE_T cSize,
- gpos::IMemoryPool *pmp,
- const gpos::CHAR *szFilename,
- gpos::ULONG cLine
- );
-
-// placement array new operator
-void *operator new []
- (
- gpos::SIZE_T cSize,
- gpos::IMemoryPool *pmp,
- const gpos::CHAR *szFilename,
- gpos::ULONG cLine
- );
-
-
-
-//---------------------------------------------------------------------------
-// Must provide two variants for delete:
-// 1. one to be used in constructors
-// 2. one in all other situations
-//
-// Internally both map to the same delete function;
-//---------------------------------------------------------------------------
-
-// placement delete
-void operator delete (void *pv) throw();
-void operator delete
- (
- void *pv,
- gpos::IMemoryPool *pmp,
- const gpos::CHAR *szFilename,
- gpos::ULONG cLine
- );
-
-// placement array delete
-void operator delete [] (void *pv) throw();
-void operator delete []
- (
- void *pv,
- gpos::IMemoryPool *pmp,
- const gpos::CHAR *szFilename,
- gpos::ULONG cLine
- );
-
-
-// non-throwing singleton delete operator
-void operator delete
- (
- void* pv,
- const gpos::NO_THROW&
- )
- throw();
-
-// non-throwing array delete operator
-void operator delete[]
- (
- void* pv,
- const gpos::NO_THROW&
- )
- throw();
-
-#endif // !GPOS_Allocators_H
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/include/gpopt/Allocators.inl
----------------------------------------------------------------------
diff --git a/src/include/gpopt/Allocators.inl b/src/include/gpopt/Allocators.inl
deleted file mode 100644
index 18ac63a..0000000
--- a/src/include/gpopt/Allocators.inl
+++ /dev/null
@@ -1,287 +0,0 @@
-//---------------------------------------------------------------------------
-// Greenplum Database
-// Copyright (C) 2013 EMC Corp.
-//
-// @filename:
-// Allocators.inl
-//
-// @doc:
-// Implementation of GPOS memory allocators
-//
-// @owner:
-// solimm1
-//
-// @test:
-//
-//
-//---------------------------------------------------------------------------
-
-#include "gpos/memory/IMemoryPool.h"
-#include "gpos/memory/CMemoryPoolManager.h"
-
-using namespace gpos;
-
-//---------------------------------------------------------------------------
-// @function:
-// new
-//
-// @doc:
-// Overloaded throwing global singleton new operator
-//
-//---------------------------------------------------------------------------
-void* operator new
- (
- SIZE_T cSize
- )
- throw(BAD_ALLOC)
-{
- return NewImpl
- (
- CMemoryPoolManager::Pmpm()->PmpGlobal(),
- cSize,
- NULL, // szFileName
- 0, // ulLine
- IMemoryPool::EatSingleton
- );
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new[]
-//
-// @doc:
-// Overloaded throwing global array new operator
-//
-//---------------------------------------------------------------------------
-void* operator new []
- (
- SIZE_T cSize
- )
- throw(BAD_ALLOC)
-{
- return NewImpl
- (
- CMemoryPoolManager::Pmpm()->PmpGlobal(),
- cSize,
- NULL, // szFileName
- 0, // ulLine
- IMemoryPool::EatArray
- );
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new
-//
-// @doc:
-// Overloaded non-throwing global singleton new operator
-//
-//---------------------------------------------------------------------------
-void *operator new
- (
- SIZE_T cSize,
- const NO_THROW &
- )
- throw()
-{
- return NewImplNoThrow
- (
- CMemoryPoolManager::Pmpm()->PmpGlobal(),
- cSize,
- NULL, // szFileName
- 0, // ulLine
- IMemoryPool::EatSingleton
- );
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new
-//
-// @doc:
-// Overloaded non-throwing global array new operator
-//
-//---------------------------------------------------------------------------
-void* operator new []
- (
- SIZE_T cSize,
- const NO_THROW &
- )
- throw()
-{
- return NewImplNoThrow
- (
- CMemoryPoolManager::Pmpm()->PmpGlobal(),
- cSize,
- NULL, // szFileName
- 0, // ulLine
- IMemoryPool::EatArray
- );
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new
-//
-// @doc:
-// overloaded placement new operator
-//
-//---------------------------------------------------------------------------
-void *
-operator new
- (
- SIZE_T cSize,
- IMemoryPool *pmp,
- const CHAR *szFilename,
- ULONG ulLine
- )
-{
- return NewImpl(pmp, cSize, szFilename, ulLine, IMemoryPool::EatSingleton);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new[]
-//
-// @doc:
-// Overload for array allocation; raises OOM exception if
-// unable to allocate
-//
-//---------------------------------------------------------------------------
-void *
-operator new []
- (
- SIZE_T cSize,
- IMemoryPool *pmp,
- const CHAR *szFilename,
- ULONG ulLine
- )
-{
- return NewImpl(pmp, cSize, szFilename, ulLine, IMemoryPool::EatArray);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete
-//
-// @doc:
-// Overload for singleton deletion
-//
-//---------------------------------------------------------------------------
-void
-operator delete
- (
- void *pv
- )
- throw()
-{
- DeleteImpl(pv, IMemoryPool::EatSingleton);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete
-//
-// @doc:
-// Placement delete; only used if constructor throws
-//
-//---------------------------------------------------------------------------
-void
-operator delete
- (
- void *pv,
- IMemoryPool *, // pmp,
- const CHAR *, // szFilename,
- ULONG // ulLine
- )
-{
- DeleteImpl(pv, IMemoryPool::EatSingleton);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete []
-//
-// @doc:
-// Overload for array deletion
-//
-//---------------------------------------------------------------------------
-void
-operator delete []
- (
- void *pv
- )
- throw()
-{
- DeleteImpl(pv, IMemoryPool::EatArray);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete []
-//
-// @doc:
-// Placement delete []; only used if constructor throws
-//
-//---------------------------------------------------------------------------
-void
-operator delete []
- (
- void *pv,
- IMemoryPool *, // pmp,
- const CHAR *, // szFilename,
- ULONG // ulLine
- )
-{
- DeleteImpl(pv, IMemoryPool::EatArray);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete
-//
-// @doc:
-// Non-throwing singleton delete operator
-//
-//---------------------------------------------------------------------------
-void
-operator delete
- (
- void* pv,
- const gpos::NO_THROW&
- )
- throw()
-{
- DeleteImplNoThrow(pv, IMemoryPool::EatSingleton);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete
-//
-// @doc:
-// Non-throwing array delete operator
-//
-//---------------------------------------------------------------------------
-void
-operator delete []
- (
- void* pv,
- const gpos::NO_THROW&
- )
- throw()
-{
- DeleteImplNoThrow(pv, IMemoryPool::EatArray);
-}
-
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/include/gpopt/gpdbwrappers.h
----------------------------------------------------------------------
diff --git a/src/include/gpopt/gpdbwrappers.h b/src/include/gpopt/gpdbwrappers.h
index 4b4699d..67e1059 100644
--- a/src/include/gpopt/gpdbwrappers.h
+++ b/src/include/gpopt/gpdbwrappers.h
@@ -176,7 +176,7 @@ namespace gpdb {
// replace Vars that reference JOIN outputs with references to the original
// relation variables instead
- Query *PqueryFlattenJoinAliasVar(Query *pquery, ULONG ulQueryLevel);
+ Query *PqueryFlattenJoinAliasVar(Query *pquery, gpos::ULONG ulQueryLevel);
// is aggregate ordered
bool FOrderedAgg(Oid aggid);
@@ -510,11 +510,11 @@ namespace gpdb {
// return true if the table is partitioned and hash-distributed, and one of
// the child partitions is randomly distributed
- BOOL FChildPartDistributionMismatch(Relation rel);
+ gpos::BOOL FChildPartDistributionMismatch(Relation rel);
// return true if the table is partitioned and any of the child partitions
// have a trigger of the given type
- BOOL FChildTriggers(Oid oid, int triggerType);
+ gpos::BOOL FChildTriggers(Oid oid, int triggerType);
// does a relation exist with the given oid
bool FRelationExists(Oid oid);
@@ -652,7 +652,7 @@ namespace gpdb {
FaultInjectorType_e OptTasksFaultInjector(FaultInjectorIdentifier_e identifier);
// return the number of leaf partition for a given table oid
- ULONG UlLeafPartitions(Oid oidRelation);
+ gpos::ULONG UlLeafPartitions(Oid oidRelation);
// requests version for object from MD Versioning component
void MdVerRequestVersion(Oid key, uint64 *ddl_version, uint64 *dml_version);
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/include/gpopt/translate/COptColInfo.h
----------------------------------------------------------------------
diff --git a/src/include/gpopt/translate/COptColInfo.h b/src/include/gpopt/translate/COptColInfo.h
index 2d65eaa..20ce601 100644
--- a/src/include/gpopt/translate/COptColInfo.h
+++ b/src/include/gpopt/translate/COptColInfo.h
@@ -74,7 +74,7 @@ namespace gpdxl
virtual
~COptColInfo()
{
- delete m_pstr;
+ GPOS_DELETE(m_pstr);
}
// accessors
[2/4] incubator-hawq git commit: HAWQ-246. Refactor and cleanup of
memory management of the new optimizer.
Posted by en...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CTranslatorRelcacheToDXL.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CTranslatorRelcacheToDXL.cpp b/src/backend/gpopt/translate/CTranslatorRelcacheToDXL.cpp
index 65c0f0c..80a81ee 100644
--- a/src/backend/gpopt/translate/CTranslatorRelcacheToDXL.cpp
+++ b/src/backend/gpopt/translate/CTranslatorRelcacheToDXL.cpp
@@ -279,8 +279,8 @@ CTranslatorRelcacheToDXL::PmdnameRel
GPOS_ASSERT(NULL != rel);
CHAR *szRelName = NameStr(rel->rd_rel->relname);
CWStringDynamic *pstrRelName = CDXLUtils::PstrFromSz(pmp, szRelName);
- CMDName *pmdname = New(pmp) CMDName(pmp, pstrRelName);
- delete pstrRelName;
+ CMDName *pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrRelName);
+ GPOS_DELETE(pstrRelName);
return pmdname;
}
@@ -300,7 +300,7 @@ CTranslatorRelcacheToDXL::PdrgpmdidRelIndexes
)
{
GPOS_ASSERT(NULL != rel);
- DrgPmdid *pdrgpmdidIndexes = New(pmp) DrgPmdid(pmp);
+ DrgPmdid *pdrgpmdidIndexes = GPOS_NEW(pmp) DrgPmdid(pmp);
List *plIndexOids = NIL;
@@ -429,7 +429,7 @@ CTranslatorRelcacheToDXL::PdrgpmdidTriggers
}
}
- DrgPmdid *pdrgpmdidTriggers = New(pmp) DrgPmdid(pmp);
+ DrgPmdid *pdrgpmdidTriggers = GPOS_NEW(pmp) DrgPmdid(pmp);
const ULONG ulTriggers = rel->rd_rel->reltriggers;
for (ULONG ul = 0; ul < ulTriggers; ul++)
@@ -458,7 +458,7 @@ CTranslatorRelcacheToDXL::PdrgpmdidCheckConstraints
OID oid
)
{
- DrgPmdid *pdrgpmdidCheckConstraints = New(pmp) DrgPmdid(pmp);
+ DrgPmdid *pdrgpmdidCheckConstraints = GPOS_NEW(pmp) DrgPmdid(pmp);
List *plOidCheckConstraints = gpdb::PlCheckConstraint(oid);
ListCell *plcOid = NULL;
@@ -661,8 +661,8 @@ CTranslatorRelcacheToDXL::Pmdrel
fTemporary = rel->rd_istemp;
fHasOids = rel->rd_rel->relhasoids;
-
- delete [] pulAttnoMapping;
+
+ GPOS_DELETE_ARRAY(pulAttnoMapping);
gpdb::CloseRelation(rel);
}
GPOS_CATCH_EX(ex)
@@ -688,7 +688,7 @@ CTranslatorRelcacheToDXL::Pmdrel
pmdidFmtErrTbl = CTranslatorUtils::PmdidWithVersion(pmp, extentry->fmterrtbl);
}
- pmdrel = New(pmp) CMDRelationExternalGPDB
+ pmdrel = GPOS_NEW(pmp) CMDRelationExternalGPDB
(
pmp,
pmdid,
@@ -711,7 +711,7 @@ CTranslatorRelcacheToDXL::Pmdrel
// get part constraint
CMDPartConstraintGPDB *pmdpartcnstr = PmdpartcnstrRelation(pmp, pmda, oid, pdrgpmdcol);
- pmdrel = New(pmp) CMDRelationGPDB
+ pmdrel = GPOS_NEW(pmp) CMDRelationGPDB
(
pmp,
pmdid,
@@ -752,7 +752,7 @@ CTranslatorRelcacheToDXL::Pdrgpmdcol
IMDRelation::Erelstoragetype erelstorage
)
{
- DrgPmdcol *pdrgpmdcol = New(pmp) DrgPmdcol(pmp);
+ DrgPmdcol *pdrgpmdcol = GPOS_NEW(pmp) DrgPmdcol(pmp);
for (ULONG ul = 0; ul < (ULONG) rel->rd_att->natts; ul++)
{
@@ -774,7 +774,7 @@ CTranslatorRelcacheToDXL::Pdrgpmdcol
ulColLen = (ULONG) att->atttypmod - VARHDRSZ;
}
- CMDColumn *pmdcol = New(pmp) CMDColumn
+ CMDColumn *pmdcol = GPOS_NEW(pmp) CMDColumn
(
pmdnameCol,
att->attnum,
@@ -928,7 +928,7 @@ CTranslatorRelcacheToDXL::PdrpulDistrCols
ULONG ulSize
)
{
- ULONG *pul = New(pmp) ULONG[ulSize];
+ ULONG *pul = GPOS_NEW_ARRAY(pmp , ULONG, ulSize);
for (ULONG ul = 0; ul < pdrgpmdcol->UlLength(); ul++)
{
@@ -939,15 +939,15 @@ CTranslatorRelcacheToDXL::PdrpulDistrCols
pul[ulIndex] = ul;
}
- DrgPul *pdrpulDistrCols = New(pmp) DrgPul(pmp);
+ DrgPul *pdrpulDistrCols = GPOS_NEW(pmp) DrgPul(pmp);
for (ULONG ul = 0; ul < (ULONG) pgppolicy->nattrs; ul++)
{
AttrNumber attno = pgppolicy->attrs[ul];
- pdrpulDistrCols->Append(New(pmp) ULONG(UlPosition(attno, pul)));
+ pdrpulDistrCols->Append(GPOS_NEW(pmp) ULONG(UlPosition(attno, pul)));
}
- delete[] pul;
+ GPOS_DELETE_ARRAY(pul);
return pdrpulDistrCols;
}
@@ -989,9 +989,9 @@ CTranslatorRelcacheToDXL::AddSystemColumns
GPOS_ASSERT(NULL != pstrSysColName);
// copy string into column name
- CMDName *pmdnameCol = New(pmp) CMDName(pmp, pstrSysColName);
+ CMDName *pmdnameCol = GPOS_NEW(pmp) CMDName(pmp, pstrSysColName);
- CMDColumn *pmdcol = New(pmp) CMDColumn
+ CMDColumn *pmdcol = GPOS_NEW(pmp) CMDColumn
(
pmdnameCol,
attno,
@@ -1103,8 +1103,8 @@ CTranslatorRelcacheToDXL::Pmdindex
// get the index name
CHAR *szIndexName = NameStr(relIndex->rd_rel->relname);
CWStringDynamic *pstrName = CDXLUtils::PstrFromSz(pmp, szIndexName);
- pmdname = New(pmp) CMDName(pmp, pstrName);
- delete pstrName;
+ pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrName);
+ GPOS_DELETE(pstrName);
pmdidRel->Release();
gpdb::CloseRelation(relIndex);
}
@@ -1124,20 +1124,20 @@ CTranslatorRelcacheToDXL::Pmdindex
DrgPul *pdrgpulIncludeCols = PdrgpulIndexIncludedColumns(pmp, pmdrel);
// extract the position of the key columns
- DrgPul *pdrgpulKeyCols = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpulKeyCols = GPOS_NEW(pmp) DrgPul(pmp);
ULONG ulKeys = pgIndex->indnatts;
for (ULONG ul = 0; ul < ulKeys; ul++)
{
INT iAttno = pgIndex->indkey.values[ul];
GPOS_ASSERT(0 != iAttno && "Index expressions not supported");
- pdrgpulKeyCols->Append(New(pmp) ULONG(UlPosition(iAttno, pul)));
+ pdrgpulKeyCols->Append(GPOS_NEW(pmp) ULONG(UlPosition(iAttno, pul)));
}
pmdidIndex->AddRef();
DrgPmdid *pdrgpmdidOpClasses = PdrgpmdidIndexOpClasses(pmp, pmdidIndex);
- CMDIndexGPDB *pmdindex = New(pmp) CMDIndexGPDB
+ CMDIndexGPDB *pmdindex = GPOS_NEW(pmp) CMDIndexGPDB
(
pmp,
pmdidIndex,
@@ -1153,7 +1153,7 @@ CTranslatorRelcacheToDXL::Pmdindex
NULL // pmdpartcnstr
);
- delete [] pul;
+ GPOS_DELETE_ARRAY(pul);
return pmdindex;
}
@@ -1274,14 +1274,14 @@ CTranslatorRelcacheToDXL::PmdindexPartTable
DrgPul *pdrgpulIncludeCols = PdrgpulIndexIncludedColumns(pmp, pmdrel);
// extract the position of the key columns
- DrgPul *pdrgpulKeyCols = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpulKeyCols = GPOS_NEW(pmp) DrgPul(pmp);
const ULONG ulKeys = pidxinfo->nColumns;
for (ULONG ul = 0; ul < ulKeys; ul++)
{
INT iAttno = pidxinfo->indexKeys[ul];
GPOS_ASSERT(0 != iAttno && "Index expressions not supported");
- pdrgpulKeyCols->Append(New(pmp) ULONG(UlPosition(iAttno, pulAttrMap)));
+ pdrgpulKeyCols->Append(GPOS_NEW(pmp) ULONG(UlPosition(iAttno, pulAttrMap)));
}
Node *pnodePartCnstr = pidxinfo->partCons;
@@ -1302,12 +1302,12 @@ CTranslatorRelcacheToDXL::PmdindexPartTable
fUnbounded = fUnbounded && FDefaultPartition(plDefaultLevelsRel, ul);
}
- DrgPul *pdrgpulDefaultLevels = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpulDefaultLevels = GPOS_NEW(pmp) DrgPul(pmp);
for (ULONG ul = 0; ul < ulLevels; ul++)
{
if (fUnbounded || FDefaultPartition(plDefaultLevels, ul))
{
- pdrgpulDefaultLevels->Append(New(pmp) ULONG(ul));
+ pdrgpulDefaultLevels->Append(GPOS_NEW(pmp) ULONG(ul));
}
}
@@ -1344,7 +1344,7 @@ CTranslatorRelcacheToDXL::PmdindexPartTable
DrgPmdid *pdrgpmdidOpClasses = PdrgpmdidIndexOpClasses(pmp, pmdidIndex);
- CMDIndexGPDB *pmdindex = New(pmp) CMDIndexGPDB
+ CMDIndexGPDB *pmdindex = GPOS_NEW(pmp) CMDIndexGPDB
(
pmp,
pmdidIndex,
@@ -1360,7 +1360,7 @@ CTranslatorRelcacheToDXL::PmdindexPartTable
pmdpartcnstr
);
- delete [] pulAttrMap;
+ GPOS_DELETE_ARRAY(pulAttrMap);
return pmdindex;
}
@@ -1416,13 +1416,13 @@ CTranslatorRelcacheToDXL::PdrgpulIndexIncludedColumns
// TODO: raghav, 3/19/2012; currently we assume that all the columns
// in the table are available from the index.
- DrgPul *pdrgpulIncludeCols = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpulIncludeCols = GPOS_NEW(pmp) DrgPul(pmp);
const ULONG ulIncludedCols = pmdrel->UlColumns();
for (ULONG ul = 0; ul < ulIncludedCols; ul++)
{
if (!pmdrel->Pmdcol(ul)->FDropped())
{
- pdrgpulIncludeCols->Append(New(pmp) ULONG(ul));
+ pdrgpulIncludeCols->Append(GPOS_NEW(pmp) ULONG(ul));
}
}
@@ -1472,7 +1472,7 @@ CTranslatorRelcacheToDXL::PulAttnoPositionMap
const ULONG ulIncludedCols = pmdrel->UlColumns();
GPOS_ASSERT(ulIncludedCols <= ulSize);
- ULONG *pul = New(pmp) ULONG[ulSize];
+ ULONG *pul = GPOS_NEW_ARRAY(pmp , ULONG, ulSize);
for (ULONG ul = 0; ul < ulSize; ul++)
{
@@ -1516,19 +1516,19 @@ CTranslatorRelcacheToDXL::Pmdtype
switch (oidType)
{
case GPDB_INT2_OID:
- return New(pmp) CMDTypeInt2GPDB(pmp);
+ return GPOS_NEW(pmp) CMDTypeInt2GPDB(pmp);
case GPDB_INT4_OID:
- return New(pmp) CMDTypeInt4GPDB(pmp);
+ return GPOS_NEW(pmp) CMDTypeInt4GPDB(pmp);
case GPDB_INT8_OID:
- return New(pmp) CMDTypeInt8GPDB(pmp);
+ return GPOS_NEW(pmp) CMDTypeInt8GPDB(pmp);
case GPDB_BOOL:
- return New(pmp) CMDTypeBoolGPDB(pmp);
+ return GPOS_NEW(pmp) CMDTypeBoolGPDB(pmp);
case GPDB_OID_OID:
- return New(pmp) CMDTypeOidGPDB(pmp);
+ return GPOS_NEW(pmp) CMDTypeOidGPDB(pmp);
}
// continue to construct a generic type
@@ -1585,7 +1585,7 @@ CTranslatorRelcacheToDXL::Pmdtype
pmdid->AddRef();
- return New(pmp) CMDTypeGenericGPDB
+ return GPOS_NEW(pmp) CMDTypeGenericGPDB
(
pmp,
pmdid,
@@ -1702,7 +1702,7 @@ CTranslatorRelcacheToDXL::Pmdscop
BOOL fReturnsNullOnNullInput = gpdb::FOpStrict(oidOp);
pmdid->AddRef();
- CMDScalarOpGPDB *pmdscop = New(pmp) CMDScalarOpGPDB
+ CMDScalarOpGPDB *pmdscop = GPOS_NEW(pmp) CMDScalarOpGPDB
(
pmp,
pmdid,
@@ -1799,10 +1799,10 @@ CTranslatorRelcacheToDXL::Pmdfunc
}
CWStringDynamic *pstrFuncName = CDXLUtils::PstrFromSz(pmp, szName);
- CMDName *pmdname = New(pmp) CMDName(pmp, pstrFuncName);
+ CMDName *pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrFuncName);
// CMDName ctor created a copy of the string
- delete pstrFuncName;
+ GPOS_DELETE(pstrFuncName);
// get result type
OID oidResult = gpdb::OidFuncRetType(oidFunc);
@@ -1818,7 +1818,7 @@ CTranslatorRelcacheToDXL::Pmdfunc
if (NULL != plOutArgTypes)
{
ListCell *plc = NULL;
- pdrgpmdidArgTypes = New(pmp) DrgPmdid(pmp);
+ pdrgpmdidArgTypes = GPOS_NEW(pmp) DrgPmdid(pmp);
ForEach (plc, plOutArgTypes)
{
@@ -1838,7 +1838,7 @@ CTranslatorRelcacheToDXL::Pmdfunc
LookupFuncProps(oidFunc, &efs, &efda, &fStrict, &fReturnsSet);
pmdid->AddRef();
- CMDFunctionGPDB *pmdfunc = New(pmp) CMDFunctionGPDB
+ CMDFunctionGPDB *pmdfunc = GPOS_NEW(pmp) CMDFunctionGPDB
(
pmp,
pmdid,
@@ -1883,10 +1883,10 @@ CTranslatorRelcacheToDXL::Pmdagg
}
CWStringDynamic *pstrAggName = CDXLUtils::PstrFromSz(pmp, szName);
- CMDName *pmdname = New(pmp) CMDName(pmp, pstrAggName);
+ CMDName *pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrAggName);
// CMDName ctor created a copy of the string
- delete pstrAggName;
+ GPOS_DELETE(pstrAggName);
// get result type
OID oidResult = gpdb::OidFuncRetType(oidAgg);
@@ -1908,7 +1908,7 @@ CTranslatorRelcacheToDXL::Pmdagg
// due to the fact that hashAgg may spill
BOOL fHashAggCapable = !fOrdered && gpdb::FAggHasPrelimFunc(oidAgg);
- CMDAggregateGPDB *pmdagg = New(pmp) CMDAggregateGPDB
+ CMDAggregateGPDB *pmdagg = GPOS_NEW(pmp) CMDAggregateGPDB
(
pmp,
pmdid,
@@ -1950,8 +1950,8 @@ CTranslatorRelcacheToDXL::Pmdtrigger
}
CWStringDynamic *pstrTriggerName = CDXLUtils::PstrFromSz(pmp, szName);
- CMDName *pmdname = New(pmp) CMDName(pmp, pstrTriggerName);
- delete pstrTriggerName;
+ CMDName *pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrTriggerName);
+ GPOS_DELETE(pstrTriggerName);
// get relation oid
OID oidRel = gpdb::OidTriggerRelid(oidTrigger);
@@ -1970,7 +1970,7 @@ CTranslatorRelcacheToDXL::Pmdtrigger
BOOL fEnabled = gpdb::FTriggerEnabled(oidTrigger);
pmdid->AddRef();
- CMDTriggerGPDB *pmdtrigger = New(pmp) CMDTriggerGPDB
+ CMDTriggerGPDB *pmdtrigger = GPOS_NEW(pmp) CMDTriggerGPDB
(
pmp,
pmdid,
@@ -2009,8 +2009,8 @@ CTranslatorRelcacheToDXL::Pmdcheckconstraint
GPOS_RAISE(gpdxl::ExmaMD, gpdxl::ExmiMDCacheEntryNotFound, pmdid->Wsz());
}
CWStringDynamic *pstrCheckConstraintName = CDXLUtils::PstrFromSz(pmp, szName);
- CMDName *pmdname = New(pmp) CMDName(pmp, pstrCheckConstraintName);
- delete pstrCheckConstraintName;
+ CMDName *pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrCheckConstraintName);
+ GPOS_DELETE(pstrCheckConstraintName);
// get relation oid associated with the check constraint
OID oidRel = gpdb::OidCheckConstraintRelid(oidCheckConstraint);
@@ -2036,19 +2036,19 @@ CTranslatorRelcacheToDXL::Pmdcheckconstraint
);
// generate a mock mapping between var to column information
- CMappingVarColId *pmapvarcolid = New(pmp) CMappingVarColId(pmp);
- DrgPdxlcd *pdrgpdxlcd = New(pmp) DrgPdxlcd(pmp);
+ CMappingVarColId *pmapvarcolid = GPOS_NEW(pmp) CMappingVarColId(pmp);
+ DrgPdxlcd *pdrgpdxlcd = GPOS_NEW(pmp) DrgPdxlcd(pmp);
const IMDRelation *pmdrel = pmda->Pmdrel(pmdidRel);
const ULONG ulLen = pmdrel->UlColumns();
for (ULONG ul = 0; ul < ulLen; ul++)
{
const IMDColumn *pmdcol = pmdrel->Pmdcol(ul);
- CMDName *pmdnameCol = New(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
+ CMDName *pmdnameCol = GPOS_NEW(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
CMDIdGPDB *pmdidColType = CMDIdGPDB::PmdidConvert(pmdcol->PmdidType());
pmdidColType->AddRef();
// create a column descriptor for the column
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdnameCol,
@@ -2066,11 +2066,11 @@ CTranslatorRelcacheToDXL::Pmdcheckconstraint
// cleanup
pdrgpdxlcd->Release();
- delete pmapvarcolid;
+ GPOS_DELETE(pmapvarcolid);
pmdid->AddRef();
- return New(pmp) CMDCheckConstraintGPDB
+ return GPOS_NEW(pmp) CMDCheckConstraintGPDB
(
pmp,
pmdid,
@@ -2103,10 +2103,10 @@ CTranslatorRelcacheToDXL::PmdnameType
GPOS_ASSERT(NULL != szTypeName);
CWStringDynamic *pstrName = CDXLUtils::PstrFromSz(pmp, szTypeName);
- CMDName *pmdname = New(pmp) CMDName(pmp, pstrName);
+ CMDName *pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrName);
// cleanup
- delete pstrName;
+ GPOS_DELETE(pstrName);
return pmdname;
}
@@ -2232,7 +2232,7 @@ CTranslatorRelcacheToDXL::PmdidFunc
GPOS_RAISE(gpdxl::ExmaMD, gpdxl::ExmiMDCacheEntryNotFound, wszFuncName);
}
- delete [] szFuncName;
+ GPOS_DELETE_ARRAY(szFuncName);
return CTranslatorUtils::PmdidWithVersion(pmp, fcl->oid);
}
@@ -2269,9 +2269,9 @@ CTranslatorRelcacheToDXL::PimdobjRelStats
// get rel name
CHAR *szRelName = NameStr(rel->rd_rel->relname);
CWStringDynamic *pstrRelName = CDXLUtils::PstrFromSz(pmp, szRelName);
- pmdname = New(pmp) CMDName(pmp, pstrRelName);
+ pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrRelName);
// CMDName ctor created a copy of the string
- delete pstrRelName;
+ GPOS_DELETE(pstrRelName);
BlockNumber pages = 0;
GpPolicy *pgppolicy = gpdb::Pdistrpolicy(rel);
@@ -2300,7 +2300,7 @@ CTranslatorRelcacheToDXL::PimdobjRelStats
fEmptyStats = true;
}
- CDXLRelStats *pdxlrelstats = New(pmp) CDXLRelStats
+ CDXLRelStats *pdxlrelstats = GPOS_NEW(pmp) CDXLRelStats
(
pmp,
pmdidRelStats,
@@ -2348,11 +2348,11 @@ CTranslatorRelcacheToDXL::PimdobjColStats
CDouble dRows(rel->rd_rel->reltuples);
// extract column name and type
- CMDName *pmdnameCol = New(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
+ CMDName *pmdnameCol = GPOS_NEW(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
OID oidAttType = CMDIdGPDB::PmdidConvert(pmdcol->PmdidType())->OidObjectId();
gpdb::CloseRelation(rel);
- DrgPdxlbucket *pdrgpdxlbucket = New(pmp) DrgPdxlbucket(pmp);
+ DrgPdxlbucket *pdrgpdxlbucket = GPOS_NEW(pmp) DrgPdxlbucket(pmp);
if (0 > attrnum)
{
@@ -2383,7 +2383,7 @@ CTranslatorRelcacheToDXL::PimdobjColStats
if (!pmdcol->FDropped())
{
- CMDIdGPDB *pmdidAttType = New(pmp) CMDIdGPDB(oidAttType);
+ CMDIdGPDB *pmdidAttType = GPOS_NEW(pmp) CMDIdGPDB(oidAttType);
IMDType *pmdtype = Pmdtype(pmp, pmdidAttType);
dWidth = CStatisticsUtils::DDefaultColumnWidth(pmdtype);
pmdtype->Release();
@@ -2525,7 +2525,7 @@ CTranslatorRelcacheToDXL::PimdobjColStats
// create col stats object
pmdidColStats->AddRef();
- CDXLColStats *pdxlcolstats = New(pmp) CDXLColStats
+ CDXLColStats *pdxlcolstats = GPOS_NEW(pmp) CDXLColStats
(
pmp,
pmdidColStats,
@@ -2569,7 +2569,7 @@ CTranslatorRelcacheToDXL::PdxlcolstatsSystemColumn
GPOS_ASSERT(0 > attrnum);
GPOS_ASSERT(NULL != pdrgpdxlbucket);
- CMDIdGPDB *pmdidAttType = New(pmp) CMDIdGPDB(oidAttType);
+ CMDIdGPDB *pmdidAttType = GPOS_NEW(pmp) CMDIdGPDB(oidAttType);
IMDType *pmdtype = Pmdtype(pmp, pmdidAttType);
GPOS_ASSERT(pmdtype->FFixedLength());
@@ -2613,7 +2613,7 @@ CTranslatorRelcacheToDXL::PdxlcolstatsSystemColumn
pmdidAttType->Release();
pmdtype->Release();
- return New(pmp) CDXLColStats
+ return GPOS_NEW(pmp) CDXLColStats
(
pmp,
pmdidColStats,
@@ -2721,7 +2721,7 @@ CTranslatorRelcacheToDXL::PimdobjCast
CMDName *pmdname = CDXLUtils::PmdnameFromSz(pmp, szFuncName);
CMDIdGPDB *pmdidCastFunc = CTranslatorUtils::PmdidWithVersion(pmp, oidCastFunc);
- return New(pmp) CMDCastGPDB(pmp, pmdid, pmdname, pmdidSrc, pmdidDest, fBinaryCoercible, pmdidCastFunc);
+ return GPOS_NEW(pmp) CMDCastGPDB(pmp, pmdid, pmdname, pmdidSrc, pmdidDest, fBinaryCoercible, pmdidCastFunc);
}
//---------------------------------------------------------------------------
@@ -2770,7 +2770,7 @@ CTranslatorRelcacheToDXL::PmdobjScCmp
CMDName *pmdname = CDXLUtils::PmdnameFromSz(pmp, szName);
CMDIdGPDB *pmdidCmp = CTranslatorUtils::PmdidWithVersion(pmp, oidScCmp);
- return New(pmp) CMDScCmpGPDB(pmp, pmdid, pmdname, pmdidLeft, pmdidRight, ecmpt, pmdidCmp);
+ return GPOS_NEW(pmp) CMDScCmpGPDB(pmp, pmdid, pmdname, pmdidLeft, pmdidRight, ecmpt, pmdidCmp);
}
//---------------------------------------------------------------------------
@@ -2853,23 +2853,23 @@ CTranslatorRelcacheToDXL::PdrgpdxlbucketTransformStats
// both histogram and MCVs exist and have significant info, merge MCV and histogram buckets
CHistogram *phistMerged = CStatisticsUtils::PhistMergeMcvHist(pmp, phistGPDBMCV, phistGPDBHist);
pdrgpdxlbucket = Pdrgpdxlbucket(pmp, pmdtype, phistMerged);
- delete phistMerged;
+ GPOS_DELETE(phistMerged);
}
else
{
// no MCVs nor histogram
GPOS_ASSERT(!fHasHist && !fHasMCV);
- pdrgpdxlbucket = New(pmp) DrgPdxlbucket(pmp);
+ pdrgpdxlbucket = GPOS_NEW(pmp) DrgPdxlbucket(pmp);
}
// cleanup
pmdidAttType->Release();
pmdtype->Release();
- delete phistGPDBMCV;
+ GPOS_DELETE(phistGPDBMCV);
if (NULL != phistGPDBHist)
{
- delete phistGPDBHist;
+ GPOS_DELETE(phistGPDBHist);
}
return pdrgpdxlbucket;
@@ -2893,15 +2893,15 @@ CTranslatorRelcacheToDXL::PhistTransformGPDBMCV
ULONG ulNumMCVValues
)
{
- DrgPdatum *pdrgpdatum = New(pmp) DrgPdatum(pmp);
- DrgPdouble *pdrgpdFreq = New(pmp) DrgPdouble(pmp);
+ DrgPdatum *pdrgpdatum = GPOS_NEW(pmp) DrgPdatum(pmp);
+ DrgPdouble *pdrgpdFreq = GPOS_NEW(pmp) DrgPdouble(pmp);
for (ULONG ul = 0; ul < ulNumMCVValues; ul++)
{
Datum datumMCV = pdrgdatumMCVValues[ul];
IDatum *pdatum = CTranslatorScalarToDXL::Pdatum(pmp, pmdtype, false /* fNull */, datumMCV);
pdrgpdatum->Append(pdatum);
- pdrgpdFreq->Append(New(pmp) CDouble(pdrgfMCVFrequencies[ul]));
+ pdrgpdFreq->Append(GPOS_NEW(pmp) CDouble(pdrgfMCVFrequencies[ul]));
if (!pdatum->FStatsComparable(pdatum))
{
@@ -2909,7 +2909,7 @@ CTranslatorRelcacheToDXL::PhistTransformGPDBMCV
// building a histogram. return an empty histogram
pdrgpdatum->Release();
pdrgpdFreq->Release();
- return New(pmp) CHistogram(New(pmp) DrgPbucket(pmp));
+ return GPOS_NEW(pmp) CHistogram(GPOS_NEW(pmp) DrgPbucket(pmp));
}
}
@@ -2954,7 +2954,7 @@ CTranslatorRelcacheToDXL::PhistTransformGPDBHist
const ULONG ulBuckets = ulNumHistValues - 1;
// create buckets
- DrgPbucket *pdrgppbucket = New(pmp) DrgPbucket(pmp);
+ DrgPbucket *pdrgppbucket = GPOS_NEW(pmp) DrgPbucket(pmp);
for (ULONG ul = 0; ul < ulBuckets; ul++)
{
Datum datumMin = pdrgdatumHistValues[ul];
@@ -2971,10 +2971,10 @@ CTranslatorRelcacheToDXL::PhistTransformGPDBHist
fUpperClosed = true;
}
- CBucket *pbucket = New(pmp) CBucket
+ CBucket *pbucket = GPOS_NEW(pmp) CBucket
(
- New(pmp) CPoint(pdatumMin),
- New(pmp) CPoint(pdatumMax),
+ GPOS_NEW(pmp) CPoint(pdatumMin),
+ GPOS_NEW(pmp) CPoint(pdatumMax),
fLowerClosed,
fUpperClosed,
dFreqPerBucket,
@@ -2992,11 +2992,11 @@ CTranslatorRelcacheToDXL::PhistTransformGPDBHist
// order is different in GPDB, and use const expression eval to compare
// datums in Orca (MPP-22780)
pdrgppbucket->Release();
- return New(pmp) CHistogram(New(pmp) DrgPbucket(pmp));
+ return GPOS_NEW(pmp) CHistogram(GPOS_NEW(pmp) DrgPbucket(pmp));
}
}
- CHistogram *phist = New(pmp) CHistogram(pdrgppbucket);
+ CHistogram *phist = GPOS_NEW(pmp) CHistogram(pdrgppbucket);
return phist;
}
@@ -3017,7 +3017,7 @@ CTranslatorRelcacheToDXL::Pdrgpdxlbucket
const CHistogram *phist
)
{
- DrgPdxlbucket *pdrgpdxlbucket = New(pmp) DrgPdxlbucket(pmp);
+ DrgPdxlbucket *pdrgpdxlbucket = GPOS_NEW(pmp) DrgPdxlbucket(pmp);
const DrgPbucket *pdrgpbucket = phist->Pdrgpbucket();
ULONG ulNumBuckets = pdrgpbucket->UlLength();
for (ULONG ul = 0; ul < ulNumBuckets; ul++)
@@ -3027,7 +3027,7 @@ CTranslatorRelcacheToDXL::Pdrgpdxlbucket
CDXLDatum *pdxldatumLB = pmdtype->Pdxldatum(pmp, pdatumLB);
IDatum *pdatumUB = pbucket->PpUpper()->Pdatum();
CDXLDatum *pdxldatumUB = pmdtype->Pdxldatum(pmp, pdatumUB);
- CDXLBucket *pdxlbucket = New (pmp) CDXLBucket
+ CDXLBucket *pdxlbucket = GPOS_NEW(pmp) CDXLBucket
(
pdxldatumLB,
pdxldatumUB,
@@ -3108,7 +3108,7 @@ CTranslatorRelcacheToDXL::PdrgpulPartKeys
// TODO: antovl - Feb 23, 2012; support intermediate levels
- DrgPul *pdrgpulPartKeys = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpulPartKeys = GPOS_NEW(pmp) DrgPul(pmp);
MemoryContext mcxt = CurrentMemoryContext;
PartitionNode *pn = gpdb::PpnParts(oid, 0 /*level*/, 0 /*parent*/, false /*inctemplate*/, mcxt, true /*includesubparts*/);
@@ -3133,7 +3133,7 @@ CTranslatorRelcacheToDXL::PdrgpulPartKeys
INT iAttno = linitial_int(plPartKey);
GPOS_ASSERT(0 < iAttno);
- pdrgpulPartKeys->Append(New(pmp) ULONG(iAttno - 1));
+ pdrgpulPartKeys->Append(GPOS_NEW(pmp) ULONG(iAttno - 1));
}
return pdrgpulPartKeys;
@@ -3162,7 +3162,7 @@ CTranslatorRelcacheToDXL::PulAttnoMapping
// build a mapping for attnos->positions
const ULONG ulCols = pdrgpmdcol->UlLength();
- ULONG *pul = New(pmp) ULONG[ulMaxCols];
+ ULONG *pul = GPOS_NEW_ARRAY(pmp, ULONG, ulMaxCols);
// initialize all positions to ULONG_MAX
for (ULONG ul = 0; ul < ulMaxCols; ul++)
@@ -3200,7 +3200,7 @@ CTranslatorRelcacheToDXL::PdrgpdrgpulKeys
ULONG *pulMapping
)
{
- DrgPdrgPul *pdrgpdrgpul = New(pmp) DrgPdrgPul(pmp);
+ DrgPdrgPul *pdrgpdrgpul = GPOS_NEW(pmp) DrgPdrgPul(pmp);
List *plKeys = gpdb::PlRelationKeys(oid);
@@ -3209,14 +3209,14 @@ CTranslatorRelcacheToDXL::PdrgpdrgpulKeys
{
List *plKey = (List *) lfirst(plcKey);
- DrgPul *pdrgpulKey = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpulKey = GPOS_NEW(pmp) DrgPul(pmp);
ListCell *plcKeyElem = NULL;
ForEach (plcKeyElem, plKey)
{
INT iKey = lfirst_int(plcKeyElem);
ULONG ulPos = UlPosition(iKey, pulMapping);
- pdrgpulKey->Append(New(pmp) ULONG(ulPos));
+ pdrgpulKey->Append(GPOS_NEW(pmp) ULONG(ulPos));
}
GPOS_ASSERT(0 < pdrgpulKey->UlLength());
@@ -3227,17 +3227,17 @@ CTranslatorRelcacheToDXL::PdrgpdrgpulKeys
if (fAddDefaultKeys)
{
- DrgPul *pdrgpulKey = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpulKey = GPOS_NEW(pmp) DrgPul(pmp);
if (fPartitioned)
{
// TableOid is part of default key for partitioned tables
ULONG ulPosTableOid = UlPosition(TableOidAttributeNumber, pulMapping);
- pdrgpulKey->Append(New(pmp) ULONG(ulPosTableOid));
+ pdrgpulKey->Append(GPOS_NEW(pmp) ULONG(ulPosTableOid));
}
ULONG ulPosSegid= UlPosition(GpSegmentIdAttributeNumber, pulMapping);
ULONG ulPosCtid = UlPosition(SelfItemPointerAttributeNumber, pulMapping);
- pdrgpulKey->Append(New(pmp) ULONG(ulPosSegid));
- pdrgpulKey->Append(New(pmp) ULONG(ulPosCtid));
+ pdrgpulKey->Append(GPOS_NEW(pmp) ULONG(ulPosSegid));
+ pdrgpulKey->Append(GPOS_NEW(pmp) ULONG(ulPosCtid));
pdrgpdrgpul->Append(pdrgpulKey);
}
@@ -3337,18 +3337,18 @@ CTranslatorRelcacheToDXL::PmdpartcnstrIndex
BOOL fUnbounded
)
{
- DrgPdxlcd *pdrgpdxlcd = New(pmp) DrgPdxlcd(pmp);
+ DrgPdxlcd *pdrgpdxlcd = GPOS_NEW(pmp) DrgPdxlcd(pmp);
const ULONG ulColumns = pmdrel->UlColumns();
for (ULONG ul = 0; ul < ulColumns; ul++)
{
const IMDColumn *pmdcol = pmdrel->Pmdcol(ul);
- CMDName *pmdnameCol = New(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
+ CMDName *pmdnameCol = GPOS_NEW(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
CMDIdGPDB *pmdidColType = CMDIdGPDB::PmdidConvert(pmdcol->PmdidType());
pmdidColType->AddRef();
// create a column descriptor for the column
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdnameCol,
@@ -3393,12 +3393,12 @@ CTranslatorRelcacheToDXL::PmdpartcnstrRelation
gpdb::FreeList(plPartKeys);
BOOL fUnbounded = true;
- DrgPul *pdrgpulDefaultLevels = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpulDefaultLevels = GPOS_NEW(pmp) DrgPul(pmp);
for (ULONG ul = 0; ul < ulLevels; ul++)
{
if (FDefaultPartition(plDefaultLevelsRel, ul))
{
- pdrgpulDefaultLevels->Append(New(pmp) ULONG(ul));
+ pdrgpulDefaultLevels->Append(GPOS_NEW(pmp) ULONG(ul));
}
else
{
@@ -3406,17 +3406,17 @@ CTranslatorRelcacheToDXL::PmdpartcnstrRelation
}
}
- DrgPdxlcd *pdrgpdxlcd = New(pmp) DrgPdxlcd(pmp);
+ DrgPdxlcd *pdrgpdxlcd = GPOS_NEW(pmp) DrgPdxlcd(pmp);
const ULONG ulColumns = pdrgpmdcol->UlLength();
for (ULONG ul = 0; ul < ulColumns; ul++)
{
const IMDColumn *pmdcol = (*pdrgpmdcol)[ul];
- CMDName *pmdnameCol = New(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
+ CMDName *pmdnameCol = GPOS_NEW(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
CMDIdGPDB *pmdidColType = CMDIdGPDB::PmdidConvert(pmdcol->PmdidType());
pmdidColType->AddRef();
// create a column descriptor for the column
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdnameCol,
@@ -3475,7 +3475,7 @@ CTranslatorRelcacheToDXL::PmdpartcnstrFromNode
);
// generate a mock mapping between var to column information
- CMappingVarColId *pmapvarcolid = New(pmp) CMappingVarColId(pmp);
+ CMappingVarColId *pmapvarcolid = GPOS_NEW(pmp) CMappingVarColId(pmp);
pmapvarcolid->LoadColumns(0 /*ulQueryLevel */, 1 /* rteIndex */, pdrgpdxlcd);
@@ -3483,10 +3483,10 @@ CTranslatorRelcacheToDXL::PmdpartcnstrFromNode
CDXLNode *pdxlnScalar = sctranslator.PdxlnScOpFromExpr((Expr *) pnodeCnstr, pmapvarcolid);
// cleanup
- delete pmapvarcolid;
+ GPOS_DELETE(pmapvarcolid);
pdrgpulDefaultParts->AddRef();
- return New(pmp) CMDPartConstraintGPDB(pmp, pdxlnScalar, pdrgpulDefaultParts, fUnbounded);
+ return GPOS_NEW(pmp) CMDPartConstraintGPDB(pmp, pdxlnScalar, pdrgpulDefaultParts, fUnbounded);
}
//---------------------------------------------------------------------------
@@ -3579,7 +3579,7 @@ CTranslatorRelcacheToDXL::PdrgpmdidIndexOpClasses
)
{
List *plOpClasses = gpdb::PlIndexOpClasses(CMDIdGPDB::PmdidConvert(pmdidIndex)->OidObjectId());
- DrgPmdid *pdrgpmdid = New(pmp) DrgPmdid(pmp);
+ DrgPmdid *pdrgpmdid = GPOS_NEW(pmp) DrgPmdid(pmp);
ListCell *plc = NULL;
@@ -3609,7 +3609,7 @@ CTranslatorRelcacheToDXL::PdrgpmdidScOpOpClasses
)
{
List *plOpClasses = gpdb::PlScOpOpClasses(CMDIdGPDB::PmdidConvert(pmdidScOp)->OidObjectId());
- DrgPmdid *pdrgpmdid = New(pmp) DrgPmdid(pmp);
+ DrgPmdid *pdrgpmdid = GPOS_NEW(pmp) DrgPmdid(pmp);
ListCell *plc = NULL;
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CTranslatorScalarToDXL.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CTranslatorScalarToDXL.cpp b/src/backend/gpopt/translate/CTranslatorScalarToDXL.cpp
index b758f11..2be912b 100644
--- a/src/backend/gpopt/translate/CTranslatorScalarToDXL.cpp
+++ b/src/backend/gpopt/translate/CTranslatorScalarToDXL.cpp
@@ -191,13 +191,13 @@ CTranslatorScalarToDXL::PdxlnScIdFromVar
{
ulId = m_pidgtorCol->UlNextId();
}
- CMDName *pmdname = New(m_pmp) CMDName(m_pmp, pstr);
+ CMDName *pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, pstr);
// create a column reference for the given var
- CDXLColRef *pdxlcr = New(m_pmp) CDXLColRef(m_pmp, pmdname, ulId);
+ CDXLColRef *pdxlcr = GPOS_NEW(m_pmp) CDXLColRef(m_pmp, pmdname, ulId);
// create the scalar ident operator
- CDXLScalarIdent *pdxlopIdent = New(m_pmp) CDXLScalarIdent
+ CDXLScalarIdent *pdxlopIdent = GPOS_NEW(m_pmp) CDXLScalarIdent
(
m_pmp,
pdxlcr,
@@ -205,7 +205,7 @@ CTranslatorScalarToDXL::PdxlnScIdFromVar
);
// create the DXL node holding the scalar ident operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopIdent);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopIdent);
return pdxln;
}
@@ -238,7 +238,7 @@ CTranslatorScalarToDXL::PdxlnScIdFromParam
return NULL;
}
- return New(m_pmp) CDXLNode(m_pmp, pdxlopIdent);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopIdent);
}
//---------------------------------------------------------------------------
@@ -261,8 +261,8 @@ CTranslatorScalarToDXL::PdxlnSubPlanFromSubPlan
const SubPlan * psubplan = (SubPlan *)pexpr;
// outer references
- DrgPdxlcr *pdrgdxlcr = New(m_pmp) DrgPdxlcr(m_pmp);
- DrgPmdid *pdrgmdid = New(m_pmp) DrgPmdid(m_pmp);
+ DrgPdxlcr *pdrgdxlcr = GPOS_NEW(m_pmp) DrgPdxlcr(m_pmp);
+ DrgPmdid *pdrgmdid = GPOS_NEW(m_pmp) DrgPmdid(m_pmp);
ListCell *plc = NULL;
ULONG ul = 0;
@@ -298,10 +298,10 @@ CTranslatorScalarToDXL::PdxlnSubPlanFromSubPlan
ulId = m_pidgtorCol->UlNextId();
}
- CMDName *pmdname = New(m_pmp) CMDName(m_pmp, pstr);
+ CMDName *pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, pstr);
// create a column reference for the given var
- CDXLColRef *pdxlcr = New(m_pmp) CDXLColRef(m_pmp, pmdname, ulId);
+ CDXLColRef *pdxlcr = GPOS_NEW(m_pmp) CDXLColRef(m_pmp, pmdname, ulId);
pdrgdxlcr->Append(pdxlcr);
pdrgmdid->Append(CTranslatorUtils::PmdidWithVersion(m_pmp,pvar->vartype));
@@ -318,7 +318,19 @@ CTranslatorScalarToDXL::PdxlnSubPlanFromSubPlan
// create the DXL node holding the scalar subplan
EdxlSubPlanType edxlsubplantype = CTranslatorUtils::Edxlsubplantype(psubplan->subLinkType);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarSubPlan(m_pmp, pmdid, pdrgdxlcr, pdrgmdid, edxlsubplantype, pdxlnTestExpr));
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode
+ (
+ m_pmp,
+ GPOS_NEW(m_pmp) CDXLScalarSubPlan
+ (
+ m_pmp,
+ pmdid,
+ pdrgdxlcr,
+ pdrgmdid,
+ edxlsubplantype,
+ pdxlnTestExpr
+ )
+ );
// get the actual sub plan from the plstmt
Plan *pplanChild = (Plan *) gpdb::PvListNth(m_pplstmt->subplans, psubplan->plan_id - 1);
@@ -463,11 +475,11 @@ CTranslatorScalarToDXL::PdxlnScDistCmpFromDistExpr
GPOS_ASSERT(NULL != pdxlnLeft);
GPOS_ASSERT(NULL != pdxlnRight);
- CDXLScalarDistinctComp *pdxlop = New(m_pmp) CDXLScalarDistinctComp(m_pmp,
+ CDXLScalarDistinctComp *pdxlop = GPOS_NEW(m_pmp) CDXLScalarDistinctComp(m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pdistexpr->opno));
// create the DXL node holding the scalar distinct comparison operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// add children in the right order
pdxln->AddChild(pdxlnLeft);
@@ -514,10 +526,10 @@ CTranslatorScalarToDXL::PdxlnScCmpFromOpExpr
// get operator name
const CWStringConst *pstr = PstrOpName(pmdid);
- CDXLScalarComp *pdxlop = New(m_pmp) CDXLScalarComp(m_pmp, pmdid, New(m_pmp) CWStringConst(pstr->Wsz()));
+ CDXLScalarComp *pdxlop = GPOS_NEW(m_pmp) CDXLScalarComp(m_pmp, pmdid, GPOS_NEW(m_pmp) CWStringConst(pstr->Wsz()));
// create the DXL node holding the scalar comparison operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// add children in the right order
pdxln->AddChild(pdxlnLeft);
@@ -564,10 +576,10 @@ CTranslatorScalarToDXL::PdxlnScOpExprFromExpr
IMDId *pmdid = CTranslatorUtils::PmdidWithVersion(m_pmp, popexpr->opno);
const CWStringConst *pstr = PstrOpName(pmdid);
- CDXLScalarOpExpr *pdxlop = New(m_pmp) CDXLScalarOpExpr(m_pmp, pmdid, pmdidReturnType, New(m_pmp) CWStringConst(pstr->Wsz()));
+ CDXLScalarOpExpr *pdxlop = GPOS_NEW(m_pmp) CDXLScalarOpExpr(m_pmp, pmdid, pmdidReturnType, GPOS_NEW(m_pmp) CWStringConst(pstr->Wsz()));
// create the DXL node holding the scalar opexpr
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// process arguments
TranslateScalarChildren(pdxln, popexpr->args, pmapvarcolid);
@@ -594,14 +606,14 @@ CTranslatorScalarToDXL::PdxlnScNullIfFromExpr
GPOS_ASSERT(2 == gpdb::UlListLength(pnullifexpr->args));
- CDXLScalarNullIf *pdxlop = New(m_pmp) CDXLScalarNullIf
+ CDXLScalarNullIf *pdxlop = GPOS_NEW(m_pmp) CDXLScalarNullIf
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pnullifexpr->opno),
CTranslatorUtils::PmdidWithVersion(m_pmp, gpdb::OidExprType((Node *)pnullifexpr))
);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// process arguments
TranslateScalarChildren(pdxln, pnullifexpr->args, pmapvarcolid);
@@ -670,16 +682,16 @@ CTranslatorScalarToDXL::PdxlnScArrayCompFromExpr
edxlarraycomptype = Edxlarraycomptypeall;
}
- CDXLScalarArrayComp *pdxlop = New(m_pmp) CDXLScalarArrayComp
+ CDXLScalarArrayComp *pdxlop = GPOS_NEW(m_pmp) CDXLScalarArrayComp
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pscarrayopexpr->opno),
- New(m_pmp) CWStringConst(pstr->Wsz()),
+ GPOS_NEW(m_pmp) CWStringConst(pstr->Wsz()),
edxlarraycomptype
);
// create the DXL node holding the scalar opexpr
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// add children in the right order
pdxln->AddChild(pdxlnLeft);
@@ -705,10 +717,10 @@ CTranslatorScalarToDXL::PdxlnScConstFromExpr
GPOS_ASSERT(IsA(pexpr, Const));
const Const *pconst = (Const *) pexpr;
- CDXLNode *pdxln = New(m_pmp) CDXLNode
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarConstValue
+ GPOS_NEW(m_pmp) CDXLScalarConstValue
(
m_pmp,
Pdxldatum(pconst)
@@ -788,7 +800,7 @@ CTranslatorScalarToDXL::PdxlnScBoolExprFromExpr
GPOS_ASSERT(EdxlBoolExprTypeSentinel != boolexptype);
// create the DXL node holding the scalar boolean operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarBoolExpr(m_pmp, boolexptype));
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarBoolExpr(m_pmp, boolexptype));
ULONG ulCount = gpdb::UlListLength(pboolexpr->args);
@@ -864,10 +876,10 @@ CTranslatorScalarToDXL::PdxlnScBooleanTestFromExpr
GPOS_ASSERT(EdxlbooleantestSentinel != edxlbt && "Invalid boolean test type");
// create the DXL node holding the scalar boolean test operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarBooleanTest(m_pmp,edxlbt)
+ GPOS_NEW(m_pmp) CDXLScalarBooleanTest(m_pmp,edxlbt)
);
CDXLNode *pdxlnArg = PdxlnScOpFromExpr(pbooleantest->arg, pmapvarcolid);
@@ -908,7 +920,7 @@ CTranslatorScalarToDXL::PdxlnScNullTestFromNullTest
}
// create the DXL node holding the scalar NullTest operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarNullTest(m_pmp, fIsNull));
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarNullTest(m_pmp, fIsNull));
pdxln->AddChild(pdxlnChild);
return pdxln;
@@ -933,13 +945,13 @@ CTranslatorScalarToDXL::PdxlnScCoalesceFromExpr
CoalesceExpr *pcoalesceexpr = (CoalesceExpr *) pexpr;
GPOS_ASSERT(NULL != pcoalesceexpr->args);
- CDXLScalarCoalesce *pdxlop = New(m_pmp) CDXLScalarCoalesce
+ CDXLScalarCoalesce *pdxlop = GPOS_NEW(m_pmp) CDXLScalarCoalesce
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pcoalesceexpr->coalescetype)
);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
TranslateScalarChildren(pdxln, pcoalesceexpr->args, pmapvarcolid);
@@ -976,14 +988,14 @@ CTranslatorScalarToDXL::PdxlnScMinMaxFromExpr
emmt = CDXLScalarMinMax::EmmtMin;
}
- CDXLScalarMinMax *pdxlop = New(m_pmp) CDXLScalarMinMax
+ CDXLScalarMinMax *pdxlop = GPOS_NEW(m_pmp) CDXLScalarMinMax
(
m_pmp,
- New(m_pmp) CMDIdGPDB(pminmaxexpr->minmaxtype),
+ GPOS_NEW(m_pmp) CMDIdGPDB(pminmaxexpr->minmaxtype),
emmt
);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
TranslateScalarChildren(pdxln, pminmaxexpr->args, pmapvarcolid);
@@ -1074,12 +1086,12 @@ CTranslatorScalarToDXL::PdxlnScSwitchFromCaseExpr
{
GPOS_ASSERT (NULL != pcaseexpr->arg);
- CDXLScalarSwitch *pdxlop = New(m_pmp) CDXLScalarSwitch
+ CDXLScalarSwitch *pdxlop = GPOS_NEW(m_pmp) CDXLScalarSwitch
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pcaseexpr->casetype)
);
- CDXLNode *pdxlnSwitch = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxlnSwitch = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// translate the switch expression
CDXLNode *pdxlnArg = PdxlnScOpFromExpr(pcaseexpr->arg, pmapvarcolid);
@@ -1091,8 +1103,8 @@ CTranslatorScalarToDXL::PdxlnScSwitchFromCaseExpr
{
CaseWhen *pexpr = (CaseWhen *) lfirst(plc);
- CDXLScalarSwitchCase *pdxlopCase = New(m_pmp) CDXLScalarSwitchCase(m_pmp);
- CDXLNode *pdxlnCase = New(m_pmp) CDXLNode(m_pmp, pdxlopCase);
+ CDXLScalarSwitchCase *pdxlopCase = GPOS_NEW(m_pmp) CDXLScalarSwitchCase(m_pmp);
+ CDXLNode *pdxlnCase = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopCase);
CDXLNode *pdxlnCmpExpr = PdxlnScOpFromExpr(pexpr->expr, pmapvarcolid);
GPOS_ASSERT(NULL != pdxlnCmpExpr);
@@ -1136,13 +1148,13 @@ CTranslatorScalarToDXL::PdxlnScCaseTestFromExpr
{
GPOS_ASSERT(IsA(pexpr, CaseTestExpr));
const CaseTestExpr *pcasetestexpr = (CaseTestExpr *) pexpr;
- CDXLScalarCaseTest *pdxlop = New(m_pmp) CDXLScalarCaseTest
+ CDXLScalarCaseTest *pdxlop = GPOS_NEW(m_pmp) CDXLScalarCaseTest
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pcasetestexpr->typeId)
);
- return New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
}
//---------------------------------------------------------------------------
@@ -1167,13 +1179,13 @@ CTranslatorScalarToDXL::PdxlnScIfStmtFromCaseExpr
for (ULONG ul = 0; ul < ulWhenClauseCount; ul++)
{
- CDXLScalarIfStmt *pdxlopIfstmtNew = New(m_pmp) CDXLScalarIfStmt
+ CDXLScalarIfStmt *pdxlopIfstmtNew = GPOS_NEW(m_pmp) CDXLScalarIfStmt
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pcaseexpr->casetype)
);
- CDXLNode *pdxlnIfStmtNew = New(m_pmp) CDXLNode(m_pmp, pdxlopIfstmtNew);
+ CDXLNode *pdxlnIfStmtNew = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopIfstmtNew);
CaseWhen *pexpr = (CaseWhen *) gpdb::PvListNth(pcaseexpr->args, ul);
GPOS_ASSERT(IsA(pexpr, CaseWhen));
@@ -1233,10 +1245,10 @@ CTranslatorScalarToDXL::PdxlnScCastFromRelabelType
GPOS_ASSERT(NULL != pdxlnChild);
// create the DXL node holding the scalar boolean operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarCast
+ GPOS_NEW(m_pmp) CDXLScalarCast
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, prelabeltype->resulttype),
@@ -1274,10 +1286,10 @@ CTranslatorScalarToDXL::PdxlnScCoerceFromCoerce
GPOS_ASSERT(NULL != pdxlnChild);
// create the DXL node holding the scalar boolean operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarCoerceToDomain
+ GPOS_NEW(m_pmp) CDXLScalarCoerceToDomain
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pcoerce->resulttype),
@@ -1311,10 +1323,10 @@ CTranslatorScalarToDXL::PdxlnScFuncExprFromFuncExpr
CMDIdGPDB *pmdidFunc = CTranslatorUtils::PmdidWithVersion(m_pmp, pfuncexpr->funcid);
// create the DXL node holding the scalar funcexpr
- CDXLNode *pdxln = New(m_pmp) CDXLNode
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarFuncExpr
+ GPOS_NEW(m_pmp) CDXLScalarFuncExpr
(
m_pmp,
pmdidFunc,
@@ -1409,10 +1421,10 @@ CTranslatorScalarToDXL::PdxlnScAggrefFromAggref
pmdidResolvedRetType = CTranslatorUtils::PmdidWithVersion(m_pmp, paggref->aggtype);
}
- CDXLScalarAggref *pdxlopAggref = New(m_pmp) CDXLScalarAggref(m_pmp, pmdidAgg, pmdidResolvedRetType, paggref->aggdistinct, edxlaggstage);
+ CDXLScalarAggref *pdxlopAggref = GPOS_NEW(m_pmp) CDXLScalarAggref(m_pmp, pmdidAgg, pmdidResolvedRetType, paggref->aggdistinct, edxlaggstage);
// create the DXL node holding the scalar aggref
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopAggref);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopAggref);
TranslateScalarChildren(pdxln, paggref->args, pmapvarcolid);
@@ -1522,8 +1534,8 @@ CTranslatorScalarToDXL::Pdxlwf
}
GPOS_ASSERT(EdxlfesSentinel != edxlfes && "Invalid window frame exclusion");
- CDXLNode *pdxlnLeadEdge = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, true /* fLeading */, edxlfbLead));
- CDXLNode *pdxlnTrailEdge = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, false /* fLeading */, edxlfbTrail));
+ CDXLNode *pdxlnLeadEdge = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, true /* fLeading */, edxlfbLead));
+ CDXLNode *pdxlnTrailEdge = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, false /* fLeading */, edxlfbTrail));
// translate the lead and trail value
if (NULL != pwindowframe->lead->val)
@@ -1536,7 +1548,7 @@ CTranslatorScalarToDXL::Pdxlwf
pdxlnTrailEdge->AddChild(PdxlnWindowFrameEdgeVal(pwindowframe->trail->val, pmapvarcolid, pdxlnNewChildScPrL, pfHasDistributedTables));
}
- CDXLWindowFrame *pdxlWf = New(m_pmp) CDXLWindowFrame(m_pmp, edxlfs, edxlfes, pdxlnLeadEdge, pdxlnTrailEdge);
+ CDXLWindowFrame *pdxlWf = GPOS_NEW(m_pmp) CDXLWindowFrame(m_pmp, edxlfs, edxlfes, pdxlnLeadEdge, pdxlnTrailEdge);
return pdxlWf;
}
@@ -1564,30 +1576,30 @@ CTranslatorScalarToDXL::PdxlnWindowFrameEdgeVal
{
GPOS_ASSERT(NULL != pdxlnNewChildScPrL);
CWStringConst strUnnamedCol(GPOS_WSZ_LIT("?column?"));
- CMDName *pmdnameAlias = New(m_pmp) CMDName(m_pmp, &strUnnamedCol);
+ CMDName *pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, &strUnnamedCol);
ULONG ulPrElId = m_pidgtorCol->UlNextId();
// construct a projection element
- CDXLNode *pdxlnPrEl = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjElem(m_pmp, ulPrElId, pmdnameAlias));
+ CDXLNode *pdxlnPrEl = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjElem(m_pmp, ulPrElId, pmdnameAlias));
pdxlnPrEl->AddChild(pdxlnVal);
// add it to the computed columns project list
pdxlnNewChildScPrL->AddChild(pdxlnPrEl);
// construct a new scalar ident
- CDXLScalarIdent *pdxlopIdent = New(m_pmp) CDXLScalarIdent
+ CDXLScalarIdent *pdxlopIdent = GPOS_NEW(m_pmp) CDXLScalarIdent
(
m_pmp,
- New(m_pmp) CDXLColRef
+ GPOS_NEW(m_pmp) CDXLColRef
(
m_pmp,
- New(m_pmp) CMDName(m_pmp, &strUnnamedCol),
+ GPOS_NEW(m_pmp) CMDName(m_pmp, &strUnnamedCol),
ulPrElId
),
CTranslatorUtils::PmdidWithVersion(m_pmp, gpdb::OidExprType(const_cast<Node*>(pnode)))
);
- pdxlnVal = New(m_pmp) CDXLNode(m_pmp, pdxlopIdent);
+ pdxlnVal = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopIdent);
}
return pdxlnVal;
@@ -1644,7 +1656,7 @@ CTranslatorScalarToDXL::PdxlnScWindowref
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiQuery2DXLUnsupportedFeature, GPOS_WSZ_LIT("Window functions with outer references"));
}
- CDXLScalarWindowRef *pdxlopWinref = New(m_pmp) CDXLScalarWindowRef
+ CDXLScalarWindowRef *pdxlopWinref = GPOS_NEW(m_pmp) CDXLScalarWindowRef
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, pwindowref->winfnoid),
@@ -1655,7 +1667,7 @@ CTranslatorScalarToDXL::PdxlnScWindowref
);
// create the DXL node holding the scalar aggref
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopWinref);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopWinref);
TranslateScalarChildren(pdxln, pwindowref->args, pmapvarcolid);
@@ -1693,7 +1705,7 @@ CTranslatorScalarToDXL::PdxlnScCondFromQual
{
// GPDB assumes that if there are a list of qual conditions then it is an implicit AND operation
// Here we build the left deep AND tree
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarBoolExpr(m_pmp, Edxland));
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarBoolExpr(m_pmp, Edxland));
TranslateScalarChildren(pdxln, plQual, pmapvarcolid, pfHasDistributedTables);
@@ -1724,20 +1736,20 @@ CTranslatorScalarToDXL::PdxlnFilterFromQual
switch (edxlopFilterType)
{
case EdxlopScalarFilter:
- pdxlop = New(m_pmp) CDXLScalarFilter(m_pmp);
+ pdxlop = GPOS_NEW(m_pmp) CDXLScalarFilter(m_pmp);
break;
case EdxlopScalarJoinFilter:
- pdxlop = New(m_pmp) CDXLScalarJoinFilter(m_pmp);
+ pdxlop = GPOS_NEW(m_pmp) CDXLScalarJoinFilter(m_pmp);
break;
case EdxlopScalarOneTimeFilter:
- pdxlop = New(m_pmp) CDXLScalarOneTimeFilter(m_pmp);
+ pdxlop = GPOS_NEW(m_pmp) CDXLScalarOneTimeFilter(m_pmp);
break;
default:
GPOS_ASSERT(!"Unrecognized filter type");
}
- CDXLNode *pdxlnFilter = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxlnFilter = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
CDXLNode *pdxlnCond = PdxlnScCondFromQual(plQual, pmapvarcolid, pfHasDistributedTables);
@@ -1861,27 +1873,27 @@ CTranslatorScalarToDXL::PdxlnQuantifiedSubqueryFromSublink
GPOS_ASSERT(ALL_SUBLINK == psublink->subLinkType || ANY_SUBLINK == psublink->subLinkType);
if (ALL_SUBLINK == psublink->subLinkType)
{
- pdxlopSubquery = New (m_pmp) CDXLScalarSubqueryAll
+ pdxlopSubquery = GPOS_NEW(m_pmp) CDXLScalarSubqueryAll
(
m_pmp,
pmdid,
- New(m_pmp) CMDName(m_pmp, pstr),
+ GPOS_NEW(m_pmp) CMDName(m_pmp, pstr),
ulColId
);
}
else
{
- pdxlopSubquery = New (m_pmp) CDXLScalarSubqueryAny
+ pdxlopSubquery = GPOS_NEW(m_pmp) CDXLScalarSubqueryAny
(
m_pmp,
pmdid,
- New(m_pmp) CMDName(m_pmp, pstr),
+ GPOS_NEW(m_pmp) CMDName(m_pmp, pstr),
ulColId
);
}
- pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopSubquery);
+ pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopSubquery);
pdxln->AddChild(pdxlnOuter);
pdxln->AddChild(pdxlnInner);
@@ -1942,7 +1954,7 @@ CTranslatorScalarToDXL::PdxlnScSubqueryFromSublink
const CDXLColRef *pdxlcr = pdxlopIdent->Pdxlcr();
const ULONG ulColId = pdxlcr->UlID();
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, New (m_pmp) CDXLScalarSubquery(m_pmp, ulColId));
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarSubquery(m_pmp, ulColId));
pdxln->AddChild(pdxlnSubQuery);
@@ -1969,7 +1981,7 @@ CTranslatorScalarToDXL::PdxlnArray
const ArrayExpr *parrayexpr = (ArrayExpr *) pexpr;
CDXLScalarArray *pdxlop =
- New(m_pmp) CDXLScalarArray
+ GPOS_NEW(m_pmp) CDXLScalarArray
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, parrayexpr->element_typeid),
@@ -1977,7 +1989,7 @@ CTranslatorScalarToDXL::PdxlnArray
parrayexpr->multidims
);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
TranslateScalarChildren(pdxln, parrayexpr->elements, pmapvarcolid);
@@ -2004,7 +2016,7 @@ CTranslatorScalarToDXL::PdxlnArrayRef
const ArrayRef *parrayref = (ArrayRef *) pexpr;
CDXLScalarArrayRef *pdxlop =
- New(m_pmp) CDXLScalarArrayRef
+ GPOS_NEW(m_pmp) CDXLScalarArrayRef
(
m_pmp,
CTranslatorUtils::PmdidWithVersion(m_pmp, parrayref->refelemtype),
@@ -2012,7 +2024,7 @@ CTranslatorScalarToDXL::PdxlnArrayRef
CTranslatorUtils::PmdidWithVersion(m_pmp, parrayref->refrestype)
);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// add children
AddArrayIndexList(pdxln, parrayref->reflowerindexpr, CDXLScalarArrayRefIndexList::EilbLower, pmapvarcolid);
@@ -2050,10 +2062,10 @@ CTranslatorScalarToDXL::AddArrayIndexList
GPOS_ASSERT(CDXLScalarArrayRefIndexList::EilbSentinel > eilb);
CDXLNode *pdxlnIndexList =
- New(m_pmp) CDXLNode
+ GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarArrayRefIndexList(m_pmp, eilb)
+ GPOS_NEW(m_pmp) CDXLScalarArrayRefIndexList(m_pmp, eilb)
);
TranslateScalarChildren(pdxlnIndexList, plist, pmapvarcolid);
@@ -2119,7 +2131,7 @@ CTranslatorScalarToDXL::PdxlnExistSubqueryFromSublink
CUtils::AddRefAppend(m_pdrgpdxlnCTE, pdrgpdxlnCTE);
m_fHasDistributedTables = m_fHasDistributedTables || ptrquerytodxl->FHasDistributedTables();
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, New (m_pmp) CDXLScalarSubqueryExists(m_pmp));
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarSubqueryExists(m_pmp));
pdxln->AddChild(pdxlnRoot);
return pdxln;
@@ -2176,7 +2188,7 @@ CTranslatorScalarToDXL::PdxlnInitPlanFromParam
GPOS_ASSERT(NULL != pparam);
// TODO: Venky; Need to handle when parameters that are passed to the plan
- CDXLNode *pdxlnInitPlan = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarInitPlan(m_pmp));
+ CDXLNode *pdxlnInitPlan = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarInitPlan(m_pmp));
GPOS_ASSERT(NULL != m_pplstmt->subplans && "We only support parameters that are generated by initplans");
@@ -2264,7 +2276,7 @@ CTranslatorScalarToDXL::PdxldatumGeneric
)
{
CMDIdGPDB *pmdidMDC = CMDIdGPDB::PmdidConvert(pmdtype->Pmdid());
- CMDIdGPDB *pmdid = New(pmp) CMDIdGPDB(*pmdidMDC);
+ CMDIdGPDB *pmdid = GPOS_NEW(pmp) CMDIdGPDB(*pmdidMDC);
BOOL fConstByVal = pmdtype->FByValue();
BYTE *pba = Pba(pmp, pmdtype, fNull, ulLen, datum);
@@ -2309,9 +2321,9 @@ CTranslatorScalarToDXL::PdxldatumBool
{
GPOS_ASSERT(pmdtype->FByValue());
CMDIdGPDB *pmdidMDC = CMDIdGPDB::PmdidConvert(pmdtype->Pmdid());
- CMDIdGPDB *pmdid = New(pmp) CMDIdGPDB(*pmdidMDC);
+ CMDIdGPDB *pmdid = GPOS_NEW(pmp) CMDIdGPDB(*pmdidMDC);
- return New(pmp) CDXLDatumBool(pmp, pmdid, fNull, gpdb::FBoolFromDatum(datum));
+ return GPOS_NEW(pmp) CDXLDatumBool(pmp, pmdid, fNull, gpdb::FBoolFromDatum(datum));
}
@@ -2334,9 +2346,9 @@ CTranslatorScalarToDXL::PdxldatumOid
{
GPOS_ASSERT(pmdtype->FByValue());
CMDIdGPDB *pmdidMDC = CMDIdGPDB::PmdidConvert(pmdtype->Pmdid());
- CMDIdGPDB *pmdid = New(pmp) CMDIdGPDB(*pmdidMDC);
+ CMDIdGPDB *pmdid = GPOS_NEW(pmp) CMDIdGPDB(*pmdidMDC);
- return New(pmp) CDXLDatumOid(pmp, pmdid, fNull, gpdb::OidFromDatum(datum));
+ return GPOS_NEW(pmp) CDXLDatumOid(pmp, pmdid, fNull, gpdb::OidFromDatum(datum));
}
@@ -2359,9 +2371,9 @@ CTranslatorScalarToDXL::PdxldatumInt2
{
GPOS_ASSERT(pmdtype->FByValue());
CMDIdGPDB *pmdidMDC = CMDIdGPDB::PmdidConvert(pmdtype->Pmdid());
- CMDIdGPDB *pmdid = New(pmp) CMDIdGPDB(*pmdidMDC);
+ CMDIdGPDB *pmdid = GPOS_NEW(pmp) CMDIdGPDB(*pmdidMDC);
- return New(pmp) CDXLDatumInt2(pmp, pmdid, fNull, gpdb::SInt16FromDatum(datum));
+ return GPOS_NEW(pmp) CDXLDatumInt2(pmp, pmdid, fNull, gpdb::SInt16FromDatum(datum));
}
@@ -2384,9 +2396,9 @@ CTranslatorScalarToDXL::PdxldatumInt4
{
GPOS_ASSERT(pmdtype->FByValue());
CMDIdGPDB *pmdidMDC = CMDIdGPDB::PmdidConvert(pmdtype->Pmdid());
- CMDIdGPDB *pmdid = New(pmp) CMDIdGPDB(*pmdidMDC);
+ CMDIdGPDB *pmdid = GPOS_NEW(pmp) CMDIdGPDB(*pmdidMDC);
- return New(pmp) CDXLDatumInt4(pmp, pmdid, fNull, gpdb::IInt32FromDatum(datum));
+ return GPOS_NEW(pmp) CDXLDatumInt4(pmp, pmdid, fNull, gpdb::IInt32FromDatum(datum));
}
@@ -2409,9 +2421,9 @@ CTranslatorScalarToDXL::PdxldatumInt8
{
GPOS_ASSERT(pmdtype->FByValue());
CMDIdGPDB *pmdidMDC = CMDIdGPDB::PmdidConvert(pmdtype->Pmdid());
- CMDIdGPDB *pmdid = New(pmp) CMDIdGPDB(*pmdidMDC);
+ CMDIdGPDB *pmdid = GPOS_NEW(pmp) CMDIdGPDB(*pmdidMDC);
- return New(pmp) CDXLDatumInt8(pmp, pmdid, fNull, gpdb::LlInt64FromDatum(datum));
+ return GPOS_NEW(pmp) CDXLDatumInt8(pmp, pmdid, fNull, gpdb::LlInt64FromDatum(datum));
}
@@ -2514,7 +2526,7 @@ CTranslatorScalarToDXL::Pba
ulLength = (ULONG) gpdb::SDatumSize(datum, pmdtype->FByValue(), ulLen);
GPOS_ASSERT(ulLength > 0);
- pba = New(pmp) BYTE[ulLength];
+ pba = GPOS_NEW_ARRAY(pmp, BYTE, ulLength);
if (pmdtype->FByValue())
{
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CTranslatorUtils.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CTranslatorUtils.cpp b/src/backend/gpopt/translate/CTranslatorUtils.cpp
index f0ac652..30f00a8 100644
--- a/src/backend/gpopt/translate/CTranslatorUtils.cpp
+++ b/src/backend/gpopt/translate/CTranslatorUtils.cpp
@@ -139,13 +139,13 @@ CTranslatorUtils::PreloadMD
const IMDType *pmdtypeOid = pmda->PtMDType<IMDTypeOid>(sysid);
PreloadMDType(pmda, pmdtypeOid);
- CMDIdGPDB *pmdidDate = New(pmp) CMDIdGPDB(CMDIdGPDB::m_mdidDate.OidObjectId());
+ CMDIdGPDB *pmdidDate = GPOS_NEW(pmp) CMDIdGPDB(CMDIdGPDB::m_mdidDate.OidObjectId());
(void) pmda->Pmdtype(pmdidDate);
- CMDIdGPDB *pmdidNumeric = New(pmp) CMDIdGPDB(CMDIdGPDB::m_mdidNumeric.OidObjectId());
+ CMDIdGPDB *pmdidNumeric = GPOS_NEW(pmp) CMDIdGPDB(CMDIdGPDB::m_mdidNumeric.OidObjectId());
(void) pmda->Pmdtype(pmdidNumeric);
- CMDIdGPDB *pmdidTimestamp = New(pmp) CMDIdGPDB(CMDIdGPDB::m_mdidTimestamp.OidObjectId());
+ CMDIdGPDB *pmdidTimestamp = GPOS_NEW(pmp) CMDIdGPDB(CMDIdGPDB::m_mdidTimestamp.OidObjectId());
(void) pmda->Pmdtype(pmdidTimestamp);
pmdidDate->Release();
@@ -263,7 +263,7 @@ CTranslatorUtils::PreloadMDStats
for (ULONG ulAttNo = 0; ulAttNo < pmdrelation->UlColumns(); ulAttNo++)
{
pmdidgpdbRel->AddRef();
- CMDIdColStats *pmdidColStats = New(pmp) CMDIdColStats(pmdidgpdbRel, ulAttNo);
+ CMDIdColStats *pmdidColStats = GPOS_NEW(pmp) CMDIdColStats(pmdidgpdbRel, ulAttNo);
(void *) pmda->Pmdcolstats(pmdidColStats);
pmdidColStats->Release();
}
@@ -271,7 +271,7 @@ CTranslatorUtils::PreloadMDStats
// preload relation stats
{
pmdidgpdbRel->AddRef();
- CMDIdRelStats *pmdidRelStats = New(pmp) CMDIdRelStats(pmdidgpdbRel);
+ CMDIdRelStats *pmdidRelStats = GPOS_NEW(pmp) CMDIdRelStats(pmdidgpdbRel);
(void *) pmda->Pmdrelstats(pmdidRelStats);
pmdidRelStats->Release();
}
@@ -368,7 +368,7 @@ CTranslatorUtils::PmdidWithVersion
}
// TODO: gcaragea - Feb 6, 2015; Refactor CMDIdGPDB to eliminate need for casting
- return New(pmp) CMDIdGPDB(oidObj, (ULONG) ullDDLv, (ULONG) ullDMLv);
+ return GPOS_NEW(pmp) CMDIdGPDB(oidObj, (ULONG) ullDDLv, (ULONG) ullDMLv);
}
@@ -390,9 +390,9 @@ CTranslatorUtils::Pdxlid
{
const IMDIndex *pmdindex = pmda->Pmdindex(pmdid);
const CWStringConst *pstrIndexName = pmdindex->Mdname().Pstr();
- CMDName *pmdnameIdx = New(pmp) CMDName(pmp, pstrIndexName);
+ CMDName *pmdnameIdx = GPOS_NEW(pmp) CMDName(pmp, pstrIndexName);
- return New (pmp) CDXLIndexDescr(pmp, pmdid, pmdnameIdx);
+ return GPOS_NEW(pmp) CDXLIndexDescr(pmp, pmdid, pmdnameIdx);
}
//---------------------------------------------------------------------------
@@ -421,9 +421,9 @@ CTranslatorUtils::Pdxltabdesc
// look up table name
const CWStringConst *pstrTblName = pmdrel->Mdname().Pstr();
- CMDName *pmdnameTbl = New(pmp) CMDName(pmp, pstrTblName);
+ CMDName *pmdnameTbl = GPOS_NEW(pmp) CMDName(pmp, pstrTblName);
- CDXLTableDescr *pdxltabdesc = New(pmp) CDXLTableDescr(pmp, pmdid, pmdnameTbl, prte->checkAsUser);
+ CDXLTableDescr *pdxltabdesc = GPOS_NEW(pmp) CDXLTableDescr(pmp, pmdid, pmdnameTbl, prte->checkAsUser);
const ULONG ulLen = pmdrel->UlColumns();
@@ -450,12 +450,12 @@ CTranslatorUtils::Pdxltabdesc
continue;
}
- CMDName *pmdnameCol = New(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
+ CMDName *pmdnameCol = GPOS_NEW(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
CMDIdGPDB *pmdidColType = CMDIdGPDB::PmdidConvert(pmdcol->PmdidType());
pmdidColType->AddRef();
// create a column descriptor for the column
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdnameCol,
@@ -608,9 +608,9 @@ CTranslatorUtils::Pdxltvf
pdrgdxlcd = PdrgdxlcdBase(pmp, pidgtor, pmdidRetType, &mdnameFunc);
}
- CMDName *pmdfuncname = New(pmp) CMDName(pmp, pmdfunc->Mdname().Pstr());
+ CMDName *pmdfuncname = GPOS_NEW(pmp) CMDName(pmp, pmdfunc->Mdname().Pstr());
- CDXLLogicalTVF *pdxlopTVF = New(pmp) CDXLLogicalTVF(pmp, pmdidFunc, pmdidRetType, pmdfuncname, pdrgdxlcd);
+ CDXLLogicalTVF *pdxlopTVF = GPOS_NEW(pmp) CDXLLogicalTVF(pmp, pmdidFunc, pmdidRetType, pmdfuncname, pdrgdxlcd);
return pdxlopTVF;
}
@@ -667,7 +667,7 @@ CTranslatorUtils::PdrgpmdidResolvePolymorphicTypes
}
// generate a new array of mdids based on the resolved types
- DrgPmdid *pdrgpmdidResolved = New(pmp) DrgPmdid(pmp);
+ DrgPmdid *pdrgpmdidResolved = GPOS_NEW(pmp) DrgPmdid(pmp);
const ULONG ulLen = pdrgpmdidTypes->UlLength();
for (ULONG ul = 0; ul < ulLen; ul++)
@@ -780,7 +780,7 @@ CTranslatorUtils::PdrgdxlcdRecord
ListCell *plcColType = NULL;
ULONG ul = 0;
- DrgPdxlcd *pdrgdxlcd = New(pmp) DrgPdxlcd(pmp);
+ DrgPdxlcd *pdrgdxlcd = GPOS_NEW(pmp) DrgPdxlcd(pmp);
ForBoth (plcColName, plColNames,
plcColType, plColTypes)
@@ -790,12 +790,12 @@ CTranslatorUtils::PdrgdxlcdRecord
CHAR *szColName = strVal(pvalue);
CWStringDynamic *pstrColName = CDXLUtils::PstrFromSz(pmp, szColName);
- CMDName *pmdColName = New(pmp) CMDName(pmp, pstrColName);
- delete(pstrColName);
+ CMDName *pmdColName = GPOS_NEW(pmp) CMDName(pmp, pstrColName);
+ GPOS_DELETE(pstrColName);
IMDId *pmdidColType = CTranslatorUtils::PmdidWithVersion(pmp, coltype);
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdColName,
@@ -832,7 +832,7 @@ CTranslatorUtils::PdrgdxlcdRecord
ListCell *plcColName = NULL;
ULONG ul = 0;
- DrgPdxlcd *pdrgdxlcd = New(pmp) DrgPdxlcd(pmp);
+ DrgPdxlcd *pdrgdxlcd = GPOS_NEW(pmp) DrgPdxlcd(pmp);
ForEach (plcColName, plColNames)
{
@@ -840,13 +840,13 @@ CTranslatorUtils::PdrgdxlcdRecord
CHAR *szColName = strVal(pvalue);
CWStringDynamic *pstrColName = CDXLUtils::PstrFromSz(pmp, szColName);
- CMDName *pmdColName = New(pmp) CMDName(pmp, pstrColName);
- delete(pstrColName);
+ CMDName *pmdColName = GPOS_NEW(pmp) CMDName(pmp, pstrColName);
+ GPOS_DELETE(pstrColName);
IMDId *pmdidColType = (*pdrgpmdidOutArgTypes)[ul];
pmdidColType->AddRef();
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdColName,
@@ -879,12 +879,12 @@ CTranslatorUtils::PdrgdxlcdBase
CMDName *pmdName
)
{
- DrgPdxlcd *pdrgdxlcd = New(pmp) DrgPdxlcd(pmp);
+ DrgPdxlcd *pdrgdxlcd = GPOS_NEW(pmp) DrgPdxlcd(pmp);
pmdidRetType->AddRef();
- CMDName *pmdColName = New(pmp) CMDName(pmp, pmdName->Pstr());
+ CMDName *pmdColName = GPOS_NEW(pmp) CMDName(pmp, pmdName->Pstr());
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdColName,
@@ -918,17 +918,17 @@ CTranslatorUtils::PdrgdxlcdComposite
{
DrgPmdcol *pdrgPmdCol = ExpandCompositeType(pmp, pmda, pmdType);
- DrgPdxlcd *pdrgdxlcd = New(pmp) DrgPdxlcd(pmp);
+ DrgPdxlcd *pdrgdxlcd = GPOS_NEW(pmp) DrgPdxlcd(pmp);
for (ULONG ul = 0; ul < pdrgPmdCol->UlLength(); ul++)
{
CMDColumn *pmdcol = (*pdrgPmdCol)[ul];
- CMDName *pmdColName = New(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
+ CMDName *pmdColName = GPOS_NEW(pmp) CMDName(pmp, pmdcol->Mdname().Pstr());
IMDId *pmdidColType = pmdcol->PmdidType();
pmdidColType->AddRef();
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdColName,
@@ -968,7 +968,7 @@ CTranslatorUtils::ExpandCompositeType
const IMDRelation *pmdrel = pmda->Pmdrel(pmdidRel);
GPOS_ASSERT(NULL != pmdrel);
- DrgPmdcol *pdrgPmdcol = New(pmp) DrgPmdcol(pmp);
+ DrgPmdcol *pdrgPmdcol = GPOS_NEW(pmp) DrgPmdcol(pmp);
for(ULONG ul = 0; ul < pmdrel->UlColumns(); ul++)
{
@@ -1394,7 +1394,7 @@ CTranslatorUtils::PtemapCopy
TEMap *ptemap
)
{
- TEMap *ptemapCopy = New(pmp) TEMap(pmp);
+ TEMap *ptemapCopy = GPOS_NEW(pmp) TEMap(pmp);
// iterate over full map
TEMapIter temapiter(ptemap);
@@ -1403,7 +1403,7 @@ CTranslatorUtils::PtemapCopy
CMappingElementColIdTE *pmapelement = const_cast<CMappingElementColIdTE *>(temapiter.Pt());
const ULONG ulColId = pmapelement->UlColId();
- ULONG *pulKey1 = New(pmp) ULONG(ulColId);
+ ULONG *pulKey1 = GPOS_NEW(pmp) ULONG(ulColId);
pmapelement->AddRef();
#ifdef GPOS_DEBUG
@@ -1521,7 +1521,7 @@ CTranslatorUtils::PdrgpulGroupingCols
HMIUl *phmiulSortGrpColsColId
)
{
- DrgPul *pdrgpul = New (pmp) DrgPul(pmp);
+ DrgPul *pdrgpul = GPOS_NEW(pmp) DrgPul(pmp);
if (NULL != pbsGroupByCols)
{
@@ -1530,7 +1530,7 @@ CTranslatorUtils::PdrgpulGroupingCols
while (bsi.FAdvance())
{
const ULONG ulColId = UlColId(bsi.UlBit(), phmiulSortGrpColsColId);
- pdrgpul->Append(New(pmp) ULONG(ulColId));
+ pdrgpul->Append(GPOS_NEW(pmp) ULONG(ulColId));
}
}
@@ -1566,7 +1566,7 @@ CTranslatorUtils::PdrgpbsGroupBy
{
// simple group by
CBitSet *pbsGroupingSet = PbsGroupingSet(pmp, plGroupClause, ulCols, phmululGrpColPos, pbsGrpCols);
- DrgPbs *pdrgpbs = New(pmp) DrgPbs(pmp);
+ DrgPbs *pdrgpbs = GPOS_NEW(pmp) DrgPbs(pmp);
pdrgpbs->Append(pbsGroupingSet);
return pdrgpbs;
}
@@ -1594,7 +1594,7 @@ CTranslatorUtils::PdrgpbsGroupBy
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiQuery2DXLUnsupportedFeature, GPOS_WSZ_LIT("Rollup and cube"));
}
- DrgPbs *pdrgpbs = New(pmp) DrgPbs(pmp);
+ DrgPbs *pdrgpbs = GPOS_NEW(pmp) DrgPbs(pmp);
ListCell *plcGroupingSet = NULL;
ForEach (plcGroupingSet, pgrcl->groupsets)
@@ -1605,7 +1605,7 @@ CTranslatorUtils::PdrgpbsGroupBy
if (IsA(pnodeGroupingSet, GroupClause))
{
// grouping set contains a single grouping column
- pbs = New(pmp) CBitSet(pmp, ulCols);
+ pbs = GPOS_NEW(pmp) CBitSet(pmp, ulCols);
ULONG ulSortGrpRef = ((GroupClause *) pnodeGroupingSet)->tleSortGroupRef;
pbs->FExchangeSet(ulSortGrpRef);
UpdateGrpColMapping(pmp, phmululGrpColPos, pbsGrpCols, ulSortGrpRef);
@@ -1648,12 +1648,12 @@ CTranslatorUtils::PdrgpbsRollup
{
GPOS_ASSERT(NULL != pgrcl);
- DrgPbs *pdrgpbsGroupingSets = New(pmp) DrgPbs(pmp);
+ DrgPbs *pdrgpbsGroupingSets = GPOS_NEW(pmp) DrgPbs(pmp);
ListCell *plcGroupingSet = NULL;
ForEach (plcGroupingSet, pgrcl->groupsets)
{
Node *pnode = (Node *) lfirst(plcGroupingSet);
- CBitSet *pbs = New(pmp) CBitSet(pmp);
+ CBitSet *pbs = GPOS_NEW(pmp) CBitSet(pmp);
if (IsA(pnode, GroupClause))
{
// simple group clause, create a singleton grouping set
@@ -1694,12 +1694,12 @@ CTranslatorUtils::PdrgpbsRollup
}
const ULONG ulGroupingSets = pdrgpbsGroupingSets->UlLength();
- DrgPbs *pdrgpbs = New(pmp) DrgPbs(pmp);
+ DrgPbs *pdrgpbs = GPOS_NEW(pmp) DrgPbs(pmp);
// compute prefixes of grouping sets array
for (ULONG ulPrefix = 0; ulPrefix <= ulGroupingSets; ulPrefix++)
{
- CBitSet *pbs = New(pmp) CBitSet(pmp);
+ CBitSet *pbs = GPOS_NEW(pmp) CBitSet(pmp);
for (ULONG ulIdx = 0; ulIdx < ulPrefix; ulIdx++)
{
CBitSet *pbsCurrent = (*pdrgpbsGroupingSets)[ulIdx];
@@ -1734,7 +1734,7 @@ CTranslatorUtils::PbsGroupingSet
GPOS_ASSERT(NULL != plGroupElems);
GPOS_ASSERT(0 < gpdb::UlListLength(plGroupElems));
- CBitSet *pbs = New(pmp) CBitSet(pmp, ulCols);
+ CBitSet *pbs = GPOS_NEW(pmp) CBitSet(pmp, ulCols);
ListCell *plc = NULL;
ForEach (plc, plGroupElems)
@@ -1789,7 +1789,7 @@ CTranslatorUtils::PdrgpulGenerateColIds
ULONG ulColPos = 0;
ListCell *plcTE = NULL;
- DrgPul *pdrgpul = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpul = GPOS_NEW(pmp) DrgPul(pmp);
ForEach (plcTE, plTargetList)
{
@@ -1816,7 +1816,7 @@ CTranslatorUtils::PdrgpulGenerateColIds
}
GPOS_ASSERT(ULONG_MAX != ulColId);
- pdrgpul->Append(New(pmp) ULONG(ulColId));
+ pdrgpul->Append(GPOS_NEW(pmp) ULONG(ulColId));
ulColPos++;
}
@@ -1954,7 +1954,7 @@ CTranslatorUtils::Pdrgpdxlcd
GPOS_ASSERT(NULL != pdrgpulColIds);
ListCell *plcTE = NULL;
- DrgPdxlcd *pdrgpdxlcd = New(pmp) DrgPdxlcd(pmp);
+ DrgPdxlcd *pdrgpdxlcd = GPOS_NEW(pmp) DrgPdxlcd(pmp);
ULONG ul = 0;
ForEach (plcTE, plTargetList)
{
@@ -1995,7 +1995,7 @@ CTranslatorUtils::PdrgpulPosInTargetList
GPOS_ASSERT(NULL != plTargetList);
ListCell *plcTE = NULL;
- DrgPul *pdrgul = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgul = GPOS_NEW(pmp) DrgPul(pmp);
ULONG ul = 0;
ForEach (plcTE, plTargetList)
{
@@ -2006,7 +2006,7 @@ CTranslatorUtils::PdrgpulPosInTargetList
continue;
}
- pdrgul->Append(New(pmp) ULONG(ul));
+ pdrgul->Append(GPOS_NEW(pmp) ULONG(ul));
ul++;
}
@@ -2037,20 +2037,20 @@ CTranslatorUtils::Pdxlcd
if (NULL == pte->resname)
{
CWStringConst strUnnamedCol(GPOS_WSZ_LIT("?column?"));
- pmdname = New(pmp) CMDName(pmp, &strUnnamedCol);
+ pmdname = GPOS_NEW(pmp) CMDName(pmp, &strUnnamedCol);
}
else
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(pmp, pte->resname);
- pmdname = New(pmp) CMDName(pmp, pstrAlias);
+ pmdname = GPOS_NEW(pmp) CMDName(pmp, pstrAlias);
// CName constructor copies string
- delete pstrAlias;
+ GPOS_DELETE(pstrAlias);
}
// create a column descriptor
OID oidType = gpdb::OidExprType((Node *) pte->expr);
CMDIdGPDB *pmdidColType = CTranslatorUtils::PmdidWithVersion(pmp, oidType);
- CDXLColDescr *pdxlcd = New(pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(pmp) CDXLColDescr
(
pmp,
pmdname,
@@ -2080,24 +2080,24 @@ CTranslatorUtils::PdxlnDummyPrElem
)
{
CMDIdGPDB *pmdidOriginal = CMDIdGPDB::PmdidConvert(pdxlcdOutput->PmdidType());
- CMDIdGPDB *pmdidCopy = New(pmp) CMDIdGPDB(pmdidOriginal->OidObjectId(), pmdidOriginal->UlVersionMajor(), pmdidOriginal->UlVersionMinor());
+ CMDIdGPDB *pmdidCopy = GPOS_NEW(pmp) CMDIdGPDB(pmdidOriginal->OidObjectId(), pmdidOriginal->UlVersionMajor(), pmdidOriginal->UlVersionMinor());
// create a column reference for the scalar identifier to be casted
ULONG ulColId = pdxlcdOutput->UlID();
- CMDName *pmdname = New(pmp) CMDName(pmp, pdxlcdOutput->Pmdname()->Pstr());
- CDXLColRef *pdxlcr = New(pmp) CDXLColRef(pmp, pmdname, ulColIdInput);
- CDXLScalarIdent *pdxlopIdent = New(pmp) CDXLScalarIdent(pmp, pdxlcr, pmdidCopy);
+ CMDName *pmdname = GPOS_NEW(pmp) CMDName(pmp, pdxlcdOutput->Pmdname()->Pstr());
+ CDXLColRef *pdxlcr = GPOS_NEW(pmp) CDXLColRef(pmp, pmdname, ulColIdInput);
+ CDXLScalarIdent *pdxlopIdent = GPOS_NEW(pmp) CDXLScalarIdent(pmp, pdxlcr, pmdidCopy);
- CDXLNode *pdxlnPrEl = New(pmp) CDXLNode
+ CDXLNode *pdxlnPrEl = GPOS_NEW(pmp) CDXLNode
(
pmp,
- New(pmp) CDXLScalarProjElem
+ GPOS_NEW(pmp) CDXLScalarProjElem
(
pmp,
ulColIdOutput,
- New(pmp) CMDName(pmp, pdxlcdOutput->Pmdname()->Pstr())
+ GPOS_NEW(pmp) CMDName(pmp, pdxlcdOutput->Pmdname()->Pstr())
),
- New(pmp) CDXLNode(pmp, pdxlopIdent)
+ GPOS_NEW(pmp) CDXLNode(pmp, pdxlopIdent)
);
return pdxlnPrEl;
@@ -2122,7 +2122,7 @@ CTranslatorUtils::PdrgpulColIds
GPOS_ASSERT(NULL != plTargetList);
GPOS_ASSERT(NULL != phmiulAttnoColId);
- DrgPul *pdrgpul = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpul = GPOS_NEW(pmp) DrgPul(pmp);
ListCell *plcTE = NULL;
ForEach (plcTE, plTargetList)
@@ -2137,7 +2137,7 @@ CTranslatorUtils::PdrgpulColIds
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiQuery2DXLAttributeNotFound, ulResNo);
}
- pdrgpul->Append(New(pmp) ULONG(*pul));
+ pdrgpul->Append(GPOS_NEW(pmp) ULONG(*pul));
}
return pdrgpul;
@@ -2304,11 +2304,11 @@ CTranslatorUtils::PdxlnInt4Const
const IMDTypeInt4 *pmdtypeint4 = pmda->PtMDType<IMDTypeInt4>();
pmdtypeint4->Pmdid()->AddRef();
- CDXLDatumInt4 *pdxldatum = New(pmp) CDXLDatumInt4(pmp, pmdtypeint4->Pmdid(), false /*fConstNull*/, iVal);
+ CDXLDatumInt4 *pdxldatum = GPOS_NEW(pmp) CDXLDatumInt4(pmp, pmdtypeint4->Pmdid(), false /*fConstNull*/, iVal);
- CDXLScalarConstValue *pdxlConst = New(pmp) CDXLScalarConstValue(pmp, pdxldatum);
+ CDXLScalarConstValue *pdxlConst = GPOS_NEW(pmp) CDXLScalarConstValue(pmp, pdxldatum);
- return New(pmp) CDXLNode(pmp, pdxlConst);
+ return GPOS_NEW(pmp) CDXLNode(pmp, pdxlConst);
}
@@ -2620,7 +2620,7 @@ CTranslatorUtils::PhmululMap
GPOS_ASSERT(NULL != pdrgpulNew);
GPOS_ASSERT(pdrgpulNew->UlLength() == pdrgpulOld->UlLength());
- HMUlUl *phmulul = New(pmp) HMUlUl(pmp);
+ HMUlUl *phmulul = GPOS_NEW(pmp) HMUlUl(pmp);
const ULONG ulCols = pdrgpulOld->UlLength();
for (ULONG ul = 0; ul < ulCols; ul++)
{
@@ -2629,7 +2629,7 @@ CTranslatorUtils::PhmululMap
#ifdef GPOS_DEBUG
BOOL fResult =
#endif // GPOS_DEBUG
- phmulul->FInsert(New(pmp) ULONG(ulColIdOld), New(pmp) ULONG(ulColIdNew));
+ phmulul->FInsert(GPOS_NEW(pmp) ULONG(ulColIdOld), GPOS_NEW(pmp) ULONG(ulColIdNew));
GPOS_ASSERT(fResult);
}
@@ -2756,7 +2756,7 @@ CTranslatorUtils::PdxlnPrElNull
CHAR *szColumnName = CDXLUtils::SzFromWsz(pmp, wszColName);
CDXLNode *pdxlnPrE = PdxlnPrElNull(pmp, pmda, pmdid, ulColId, szColumnName);
- delete[] szColumnName;
+ GPOS_DELETE_ARRAY(szColumnName);
return pdxlnPrE;
}
@@ -2786,36 +2786,36 @@ CTranslatorUtils::PdxlnPrElNull
if (NULL == szAliasName)
{
CWStringConst strUnnamedCol(GPOS_WSZ_LIT("?column?"));
- pmdnameAlias = New(pmp) CMDName(pmp, &strUnnamedCol);
+ pmdnameAlias = GPOS_NEW(pmp) CMDName(pmp, &strUnnamedCol);
}
else
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(pmp, szAliasName);
- pmdnameAlias = New(pmp) CMDName(pmp, pstrAlias);
- delete pstrAlias;
+ pmdnameAlias = GPOS_NEW(pmp) CMDName(pmp, pstrAlias);
+ GPOS_DELETE(pstrAlias);
}
pmdid->AddRef();
CDXLDatum *pdxldatum = NULL;
if (pmdid->FEquals(&CMDIdGPDB::m_mdidInt2))
{
- pdxldatum = New(pmp) CDXLDatumInt2(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
+ pdxldatum = GPOS_NEW(pmp) CDXLDatumInt2(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
}
else if (pmdid->FEquals(&CMDIdGPDB::m_mdidInt4))
{
- pdxldatum = New(pmp) CDXLDatumInt4(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
+ pdxldatum = GPOS_NEW(pmp) CDXLDatumInt4(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
}
else if (pmdid->FEquals(&CMDIdGPDB::m_mdidInt8))
{
- pdxldatum = New(pmp) CDXLDatumInt8(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
+ pdxldatum = GPOS_NEW(pmp) CDXLDatumInt8(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
}
else if (pmdid->FEquals(&CMDIdGPDB::m_mdidBool))
{
- pdxldatum = New(pmp) CDXLDatumBool(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
+ pdxldatum = GPOS_NEW(pmp) CDXLDatumBool(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
}
else if (pmdid->FEquals(&CMDIdGPDB::m_mdidOid))
{
- pdxldatum = New(pmp) CDXLDatumOid(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
+ pdxldatum = GPOS_NEW(pmp) CDXLDatumOid(pmp, pmdid, true /*fConstNull*/, 0 /*value*/);
}
else
{
@@ -2832,9 +2832,9 @@ CTranslatorUtils::PdxlnPrElNull
);
}
- CDXLNode *pdxlnConst = New(pmp) CDXLNode(pmp, New(pmp) CDXLScalarConstValue(pmp, pdxldatum));
+ CDXLNode *pdxlnConst = GPOS_NEW(pmp) CDXLNode(pmp, GPOS_NEW(pmp) CDXLScalarConstValue(pmp, pdxldatum));
- return New(pmp) CDXLNode(pmp, New(pmp) CDXLScalarProjElem(pmp, ulColId, pmdnameAlias), pdxlnConst);
+ return GPOS_NEW(pmp) CDXLNode(pmp, GPOS_NEW(pmp) CDXLScalarProjElem(pmp, ulColId, pmdnameAlias), pdxlnConst);
}
@@ -2909,7 +2909,7 @@ CTranslatorUtils::UpdateGrpColMapping
#ifdef GPOS_DEBUG
BOOL fResult =
#endif
- phmululGrpColPos->FInsert(New(pmp) ULONG (ulUniqueGrpCols), New(pmp) ULONG(ulSortGrpRef));
+ phmululGrpColPos->FInsert(GPOS_NEW(pmp) ULONG (ulUniqueGrpCols), GPOS_NEW(pmp) ULONG(ulSortGrpRef));
(void) pbsGrpCols->FExchangeSet(ulSortGrpRef);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/unexported_symbols_list.txt
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/unexported_symbols_list.txt b/src/backend/gpopt/unexported_symbols_list.txt
deleted file mode 100644
index 15e32d2..0000000
--- a/src/backend/gpopt/unexported_symbols_list.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-__ZdaPv
-__ZdaPvRKSt9nothrow_t
-__ZdlPv
-__ZdlPvRKSt9nothrow_t
-__ZdlPvS_
-__Znam
-__ZnamRKSt9nothrow_t
-__Znwm
-__ZnwmPv
-__ZnwmRKSt9nothrow_t
-
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/utils/CConstExprEvaluatorProxy.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/utils/CConstExprEvaluatorProxy.cpp b/src/backend/gpopt/utils/CConstExprEvaluatorProxy.cpp
index 71aa7fd..f1be886 100644
--- a/src/backend/gpopt/utils/CConstExprEvaluatorProxy.cpp
+++ b/src/backend/gpopt/utils/CConstExprEvaluatorProxy.cpp
@@ -112,7 +112,7 @@ CConstExprEvaluatorProxy::PdxlnEvaluateExpr
Const *pconstResult = (Const *)pexprResult;
CDXLDatum *pdxldatum = CTranslatorScalarToDXL::Pdxldatum(m_pmp, m_pmda, pconstResult);
- CDXLNode *pdxlnResult = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarConstValue(m_pmp, pdxldatum));
+ CDXLNode *pdxlnResult = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarConstValue(m_pmp, pdxldatum));
gpdb::GPDBFree(pexprResult);
gpdb::GPDBFree(pexpr);
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/utils/COptTasks.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/utils/COptTasks.cpp b/src/backend/gpopt/utils/COptTasks.cpp
index 29f20fa..893cde2 100644
--- a/src/backend/gpopt/utils/COptTasks.cpp
+++ b/src/backend/gpopt/utils/COptTasks.cpp
@@ -355,7 +355,7 @@ COptTasks::SzAllocate
}
else
{
- sz = New(pmp) CHAR[ulSize];
+ sz = GPOS_NEW_ARRAY(pmp, CHAR, ulSize);
}
}
GPOS_CATCH_EX(ex)
@@ -422,16 +422,16 @@ COptTasks::PvMDCast
CAutoMemoryPool amp(CAutoMemoryPool::ElcExc);
IMemoryPool *pmp = amp.Pmp();
- DrgPimdobj *pdrgpmdobj = New(pmp) DrgPimdobj(pmp);
+ DrgPimdobj *pdrgpmdobj = GPOS_NEW(pmp) DrgPimdobj(pmp);
- IMDId *pmdidCast = New(pmp) CMDIdCast
+ IMDId *pmdidCast = GPOS_NEW(pmp) CMDIdCast
(
CTranslatorUtils::PmdidWithVersion(pmp, oidSrc),
CTranslatorUtils::PmdidWithVersion(pmp, oidDest)
);
// relcache MD provider
- CMDProviderRelcache *pmdpr = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpr = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
CAutoMDAccessor amda(pmp, pmdpr, sysidDefault);
@@ -486,9 +486,9 @@ COptTasks::PvMDScCmp
CAutoMemoryPool amp(CAutoMemoryPool::ElcExc);
IMemoryPool *pmp = amp.Pmp();
- DrgPimdobj *pdrgpmdobj = New(pmp) DrgPimdobj(pmp);
+ DrgPimdobj *pdrgpmdobj = GPOS_NEW(pmp) DrgPimdobj(pmp);
- IMDId *pmdidScCmp = New(pmp) CMDIdScCmp
+ IMDId *pmdidScCmp = GPOS_NEW(pmp) CMDIdScCmp
(
CTranslatorUtils::PmdidWithVersion(pmp, oidLeft),
CTranslatorUtils::PmdidWithVersion(pmp, oidRight),
@@ -496,7 +496,7 @@ COptTasks::PvMDScCmp
);
// relcache MD provider
- CMDProviderRelcache *pmdpr = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpr = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
CAutoMDAccessor amda(pmp, pmdpr, sysidDefault);
@@ -577,7 +577,7 @@ COptTasks::Execute
elog(LOG, "%s", SzFromWsz((WCHAR *)err_buf));
}
- delete []err_buf;
+ GPOS_DELETE_ARRAY(err_buf);
}
@@ -606,14 +606,14 @@ COptTasks::PvDXLFromQueryTask
IMemoryPool *pmp = amp.Pmp();
// ColId generator
- CIdGenerator *pidgtorCol = New(pmp) CIdGenerator(GPDXL_COL_ID_START);
- CIdGenerator *pidgtorCTE = New(pmp) CIdGenerator(GPDXL_CTE_ID_START);
+ CIdGenerator *pidgtorCol = GPOS_NEW(pmp) CIdGenerator(GPDXL_COL_ID_START);
+ CIdGenerator *pidgtorCTE = GPOS_NEW(pmp) CIdGenerator(GPDXL_CTE_ID_START);
// map that stores gpdb att to optimizer col mapping
- CMappingVarColId *pmapvarcolid = New(pmp) CMappingVarColId(pmp);
+ CMappingVarColId *pmapvarcolid = GPOS_NEW(pmp) CMappingVarColId(pmp);
// relcache MD provider
- CMDProviderRelcache *pmdpr = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpr = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
CAutoMDAccessor amda(pmp, pmdpr, sysidDefault);
@@ -634,8 +634,8 @@ COptTasks::PvDXLFromQueryTask
DrgPdxln *pdrgpdxlnCTE = ptrquerytodxl->PdrgpdxlnCTE();
GPOS_ASSERT(NULL != pdrgpdxlnQueryOutput);
- delete pidgtorCol;
- delete pidgtorCTE;
+ GPOS_DELETE(pidgtorCol);
+ GPOS_DELETE(pidgtorCTE);
CWStringDynamic str(pmp);
COstreamString oss(&str);
@@ -654,7 +654,7 @@ COptTasks::PvDXLFromQueryTask
// clean up
pdxlnQuery->Release();
- delete pstrDXL;
+ GPOS_DELETE(pstrDXL);
}
return NULL;
@@ -744,7 +744,7 @@ COptTasks::PdrgPssLoad
}
GPOS_CATCH_END;
- delete pphDXL;
+ GPOS_DELETE(pphDXL);
return pdrgpss;
}
@@ -775,11 +775,11 @@ COptTasks::PoconfCreate
ULONG ulCTEInliningCutoff = (ULONG) optimizer_cte_inlining_bound;
- return New(pmp) COptimizerConfig
+ return GPOS_NEW(pmp) COptimizerConfig
(
- New(pmp) CEnumeratorConfig(pmp, ullPlanId, ullSamples, dCostThreshold),
- New(pmp) CStatisticsConfig(pmp, dDampingFactorFilter, dDampingFactorJoin, dDampingFactorGroupBy),
- New(pmp) CCTEConfig(ulCTEInliningCutoff),
+ GPOS_NEW(pmp) CEnumeratorConfig(pmp, ullPlanId, ullSamples, dCostThreshold),
+ GPOS_NEW(pmp) CStatisticsConfig(pmp, dDampingFactorFilter, dDampingFactorJoin, dDampingFactorGroupBy),
+ GPOS_NEW(pmp) CCTEConfig(ulCTEInliningCutoff),
pcm
);
}
@@ -913,11 +913,11 @@ COptTasks::Pcm
ICostModel *pcm = NULL;
if (OPTIMIZER_GPDB_CALIBRATED == optimizer_cost_model)
{
- pcm = New(pmp) CCostModelGPDB(pmp, ulSegments);
+ pcm = GPOS_NEW(pmp) CCostModelGPDB(pmp, ulSegments);
}
else
{
- pcm = New(pmp) CCostModelGPDBLegacy(pmp, ulSegments);
+ pcm = GPOS_NEW(pmp) CCostModelGPDBLegacy(pmp, ulSegments);
}
SetCostModelParams(pcm);
@@ -977,7 +977,7 @@ COptTasks::PvOptimizeTask
SetTraceflags(pmp, pbsTraceFlags, &pbsEnabled, &pbsDisabled);
// set up relcache MD provider
- CMDProviderRelcache *pmdpRelcache = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpRelcache = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
// scope for MD accessor
@@ -988,7 +988,7 @@ COptTasks::PvOptimizeTask
CIdGenerator idgtorCTE(GPDXL_CTE_ID_START);
// map that stores gpdb att to optimizer col mapping
- CMappingVarColId *pmapvarcolid = New(pmp) CMappingVarColId(pmp);
+ CMappingVarColId *pmapvarcolid = GPOS_NEW(pmp) CMappingVarColId(pmp);
ULONG ulSegments = gpdb::UlSegmentCountGP();
ULONG ulSegmentsForCosting = optimizer_segments;
@@ -1013,7 +1013,7 @@ COptTasks::PvOptimizeTask
COptimizerConfig *pocconf = PoconfCreate(pmp, pcm);
CConstExprEvaluatorProxy ceevalproxy(pmp, &mda);
IConstExprEvaluator *pceeval =
- New(pmp) CConstExprEvaluatorDXL(pmp, &mda, &ceevalproxy);
+ GPOS_NEW(pmp) CConstExprEvaluatorDXL(pmp, &mda, &ceevalproxy);
// preload metadata if optimizer uses multiple threads
if (optimizer_parallel)
@@ -1054,7 +1054,7 @@ COptTasks::PvOptimizeTask
// serialize DXL to xml
CWStringDynamic *pstrPlan = CDXLUtils::PstrSerializePlan(pmp, pdxlnPlan, pocconf->Pec()->UllPlanId(), pocconf->Pec()->UllPlanSpaceSize(), true /*fSerializeHeaderFooter*/, true /*fIndent*/);
poctx->m_szPlanDXL = SzFromWsz(pstrPlan->Wsz());
- delete pstrPlan;
+ GPOS_DELETE(pstrPlan);
}
// translate DXL->PlStmt only when needed
@@ -1064,10 +1064,10 @@ COptTasks::PvOptimizeTask
}
CStatisticsConfig *pstatsconf = pocconf->Pstatsconf();
- pdrgmdidCol = New(pmp) DrgPmdid(pmp);
+ pdrgmdidCol = GPOS_NEW(pmp) DrgPmdid(pmp);
pstatsconf->CollectMissingStatsColumns(pdrgmdidCol);
- phmmdidRel = New(pmp) HMMDIdMDId(pmp);
+ phmmdidRel = GPOS_NEW(pmp) HMMDIdMDId(pmp);
PrintMissingStatsWarning(pmp, &mda, pdrgmdidCol, phmmdidRel);
phmmdidRel->Release();
@@ -1245,7 +1245,7 @@ COptTasks::PvOptimizeMinidumpTask
true // fIndent
);
poptmdpctxt->m_szDXLResult = SzFromWsz(pstrDXL->Wsz());
- delete pstrDXL;
+ GPOS_DELETE(pstrDXL);
CRefCount::SafeRelease(pdxlnResult);
pocconf->Release();
@@ -1280,7 +1280,7 @@ COptTasks::PvDXLFromPlstmtTask
CIdGenerator idgtor(1);
// relcache MD provider
- CMDProviderRelcache *pmdpr = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpr = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
CAutoMDAccessor amda(pmp, pmdpr, sysidDefault);
@@ -1302,7 +1302,7 @@ COptTasks::PvDXLFromPlstmtTask
poctx->m_szPlanDXL = SzFromWsz(pstrDXL->Wsz());
// cleanup
- delete pstrDXL;
+ GPOS_DELETE(pstrDXL);
pdxlnPlan->Release();
}
@@ -1360,7 +1360,7 @@ COptTasks::PvPlstmtFromDXLTask
);
// relcache MD provider
- CMDProviderRelcache *pmdpr = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpr = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
CAutoMDAccessor amda(pmp, pmdpr, sysidDefault);
@@ -1419,13 +1419,13 @@ COptTasks::PvQueryFromDXLTask
GPOS_ASSERT(NULL != ptroutput->Pdxln());
// relcache MD provider
- CMDProviderRelcache *pmdpr = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpr = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
CAutoMDAccessor amda(pmp, pmdpr, sysidDefault);
// initialize hash table that maintains the mapping between ColId and Var
- TEMap *ptemap = New (pmp) TEMap(pmp);
+ TEMap *ptemap = GPOS_NEW(pmp) TEMap(pmp);
CTranslatorDXLToQuery trdxlquery(pmp, amda.Pmda(), gpdb::UlSegmentCountGP());
CStateDXLToQuery statedxltoquery(pmp);
@@ -1433,7 +1433,7 @@ COptTasks::PvQueryFromDXLTask
Query *pquery = trdxlquery.PqueryFromDXL(ptroutput->Pdxln(), ptroutput->PdrgpdxlnOutputCols(), &statedxltoquery, ptemap, GPDXL_QUERY_LEVEL);
CRefCount::SafeRelease(ptemap);
- delete ptroutput;
+ GPOS_DELETE(ptroutput);
GPOS_ASSERT(NULL != pquery);
GPOS_ASSERT(NULL != CurrentMemoryContext);
@@ -1467,10 +1467,10 @@ COptTasks::PvDXLFromMDObjsTask
AUTO_MEM_POOL(amp);
IMemoryPool *pmp = amp.Pmp();
- DrgPimdobj *pdrgpmdobj = New(pmp) DrgPimdobj(pmp, 1024, 1024);
+ DrgPimdobj *pdrgpmdobj = GPOS_NEW(pmp) DrgPimdobj(pmp, 1024, 1024);
// relcache MD provider
- CMDProviderRelcache *pmdp = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdp = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
CAutoMDAccessor amda(pmp, pmdp, sysidDefault);
ListCell *plc = NULL;
@@ -1537,12 +1537,12 @@ COptTasks::PvDXLFromRelStatsTask
IMemoryPool *pmp = amp.Pmp();
// relcache MD provider
- CMDProviderRelcache *pmdpr = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpr = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
CAutoMDAccessor amda(pmp, pmdpr, sysidDefault);
ICostModel *pcm = Pcm(pmp, gpdb::UlSegmentCountGP());
CAutoOptCtxt aoc(pmp, amda.Pmda(), NULL /*pceeval*/, pcm);
- DrgPimdobj *pdrgpmdobj = New(pmp) DrgPimdobj(pmp);
+ DrgPimdobj *pdrgpmdobj = GPOS_NEW(pmp) DrgPimdobj(pmp);
ListCell *plc = NULL;
ForEach (plc, pctxrelcache->m_plistOids)
@@ -1553,7 +1553,7 @@ COptTasks::PvDXLFromRelStatsTask
CMDIdGPDB *pmdid = CTranslatorUtils::PmdidWithVersion(pmp, oidRelation);
// generate mdid for relstats
- CMDIdRelStats *pmdidRelStats = New(pmp) CMDIdRelStats(pmdid);
+ CMDIdRelStats *pmdidRelStats = GPOS_NEW(pmp) CMDIdRelStats(pmdid);
IMDRelStats *pimdobjrelstats = const_cast<IMDRelStats *>(amda.Pmda()->Pmdrelstats(pmdidRelStats));
pdrgpmdobj->Append(dynamic_cast<IMDCacheObject *>(pimdobjrelstats));
@@ -1565,7 +1565,7 @@ COptTasks::PvDXLFromRelStatsTask
if (!rel->rd_att->attrs[ul]->attisdropped)
{
pmdid->AddRef();
- CMDIdColStats *pmdidColStats = New(pmp) CMDIdColStats(pmdid, ulPosCounter);
+ CMDIdColStats *pmdidColStats = GPOS_NEW(pmp) CMDIdColStats(pmdid, ulPosCounter);
ulPosCounter++;
IMDColStats *pimdobjcolstats = const_cast<IMDColStats *>(amda.Pmda()->Pmdcolstats(pmdidColStats));
pdrgpmdobj->Append(dynamic_cast<IMDCacheObject *>(pimdobjcolstats));
@@ -1642,7 +1642,7 @@ COptTasks::PvEvalExprFromDXLTask
GPOS_TRY
{
// set up relcache MD provider
- CMDProviderRelcache *pmdpRelcache = New(pmp) CMDProviderRelcache(pmp);
+ CMDProviderRelcache *pmdpRelcache = GPOS_NEW(pmp) CMDProviderRelcache(pmp);
{
// scope for MD accessor
CMDAccessor mda(pmp, CMDCache::Pcache(), sysidDefault, pmdpRelcache);
@@ -1686,7 +1686,7 @@ COptTasks::PvEvalExprFromDXLTask
true // fIndent
);
pevalctxt->m_szDXLResult = SzFromWsz(pstrDXL->Wsz());
- delete pstrDXL;
+ GPOS_DELETE(pstrDXL);
CRefCount::SafeRelease(pdxlnResult);
pdxlnInput->Release();
[4/4] incubator-hawq git commit: HAWQ-246. Refactor and cleanup of
memory management of the new optimizer.
Posted by en...@apache.org.
HAWQ-246. Refactor and cleanup of memory management of the new optimizer.
This commit eliminates the global new/delete overrides that were causing
compatibility problems (the Allocators.(h/cpp/inl) files have been
completely removed). The GPOS `New()` macro is retained and works the
same way, but has been renamed `GPOS_NEW()` to avoid confusion and
possible name collisions. `GPOS_NEW()` works only for allocating
singleton objects. For allocating arrays, `GPOS_NEW_ARRAY()` is
provided. Because we no longer override the global delete,
objects/arrays allocated by `GPOS_NEW()` and `GPOS_NEW_ARRAY()` must now
be deleted by the new functions `GPOS_DELETE()` and
`GPOS_DELETE_ARRAY()` respectively. All code in GPOS has been
retrofitted for these changes, but Orca and other code that depends on
GPOS should also be changed.
Note that `GPOS_NEW()` and `GPOS_NEW_ARRAY()` should both be
exception-safe and not leak memory when a constructor throws.
Closes #181
Project: http://git-wip-us.apache.org/repos/asf/incubator-hawq/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-hawq/commit/9b65a5ad
Tree: http://git-wip-us.apache.org/repos/asf/incubator-hawq/tree/9b65a5ad
Diff: http://git-wip-us.apache.org/repos/asf/incubator-hawq/diff/9b65a5ad
Branch: refs/heads/master
Commit: 9b65a5adcdda343ad9c6c0c087e44b6c02c424c0
Parents: 4b60c6c
Author: Entong Shen <es...@pivotal.io>
Authored: Wed Dec 9 22:02:52 2015 -0800
Committer: Entong Shen <sh...@gmail.com>
Committed: Thu Dec 10 17:39:15 2015 -0800
----------------------------------------------------------------------
src/backend/gpopt/Allocators.cpp | 299 ------------
src/backend/gpopt/CGPOptimizer.cpp | 1 -
src/backend/gpopt/Makefile | 4 +-
.../gpopt/config/CConfigParamMapping.cpp | 2 +-
src/backend/gpopt/gpdbwrappers.cpp | 8 +-
src/backend/gpopt/translate/CCTEListEntry.cpp | 10 +-
.../gpopt/translate/CContextDXLToPlStmt.cpp | 14 +-
.../gpopt/translate/CDXLTranslateContext.cpp | 16 +-
.../translate/CDXLTranslateContextBaseTable.cpp | 6 +-
.../gpopt/translate/CMappingColIdVarQuery.cpp | 4 +-
.../gpopt/translate/CMappingParamIdScalarId.cpp | 4 +-
.../gpopt/translate/CMappingVarColId.cpp | 36 +-
.../gpopt/translate/CStateDXLToQuery.cpp | 4 +-
.../gpopt/translate/CTranslatorDXLToPlStmt.cpp | 72 +--
.../gpopt/translate/CTranslatorDXLToQuery.cpp | 26 +-
.../gpopt/translate/CTranslatorDXLToScalar.cpp | 26 +-
.../gpopt/translate/CTranslatorPlStmtToDXL.cpp | 214 ++++-----
.../gpopt/translate/CTranslatorQueryToDXL.cpp | 451 ++++++++++---------
.../translate/CTranslatorRelcacheToDXL.cpp | 220 ++++-----
.../gpopt/translate/CTranslatorScalarToDXL.cpp | 192 ++++----
.../gpopt/translate/CTranslatorUtils.cpp | 156 +++----
src/backend/gpopt/unexported_symbols_list.txt | 11 -
.../gpopt/utils/CConstExprEvaluatorProxy.cpp | 2 +-
src/backend/gpopt/utils/COptTasks.cpp | 86 ++--
src/include/gpopt/Allocators.h | 145 ------
src/include/gpopt/Allocators.inl | 287 ------------
src/include/gpopt/gpdbwrappers.h | 8 +-
src/include/gpopt/translate/COptColInfo.h | 2 +-
28 files changed, 791 insertions(+), 1515 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/Allocators.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/Allocators.cpp b/src/backend/gpopt/Allocators.cpp
deleted file mode 100644
index de762ae..0000000
--- a/src/backend/gpopt/Allocators.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-//---------------------------------------------------------------------------
-// @filename:
-// Allocators.h
-//
-// @doc:
-// Memory allocation/deallocation operators
-//
-// @test:
-//
-//---------------------------------------------------------------------------
-
-#include "gpopt/Allocators.h"
-#include "gpos/memory/CMemoryPoolManager.h"
-
-using namespace gpos;
-
-//---------------------------------------------------------------------------
-// @function:
-// new
-//
-// @doc:
-// Overloaded throwing global singleton new operator
-//
-//---------------------------------------------------------------------------
-void* operator new
- (
- SIZE_T cSize
- )
- throw(BAD_ALLOC)
-{
- return NewImpl
- (
- CMemoryPoolManager::Pmpm()->PmpGlobal(),
- cSize,
- NULL, // szFileName
- 0, // ulLine
- IMemoryPool::EatSingleton
- );
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new[]
-//
-// @doc:
-// Overloaded throwing global array new operator
-//
-//---------------------------------------------------------------------------
-void* operator new []
- (
- SIZE_T cSize
- )
- throw(BAD_ALLOC)
-{
- return NewImpl
- (
- CMemoryPoolManager::Pmpm()->PmpGlobal(),
- cSize,
- NULL, // szFileName
- 0, // ulLine
- IMemoryPool::EatArray
- );
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new
-//
-// @doc:
-// Overloaded non-throwing global singleton new operator
-//
-//---------------------------------------------------------------------------
-void *operator new
- (
- SIZE_T cSize,
- const NO_THROW &
- )
- throw()
-{
- return NewImplNoThrow
- (
- CMemoryPoolManager::Pmpm()->PmpGlobal(),
- cSize,
- NULL, // szFileName
- 0, // ulLine
- IMemoryPool::EatSingleton
- );
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new
-//
-// @doc:
-// Overloaded non-throwing global array new operator
-//
-//---------------------------------------------------------------------------
-void* operator new []
- (
- SIZE_T cSize,
- const NO_THROW &
- )
- throw()
-{
- return NewImplNoThrow
- (
- CMemoryPoolManager::Pmpm()->PmpGlobal(),
- cSize,
- NULL, // szFileName
- 0, // ulLine
- IMemoryPool::EatArray
- );
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new
-//
-// @doc:
-// overloaded placement new operator
-//
-//---------------------------------------------------------------------------
-void *
-operator new
- (
- SIZE_T cSize,
- IMemoryPool *pmp,
- const CHAR *szFilename,
- ULONG ulLine
- )
-{
- return NewImpl(pmp, cSize, szFilename, ulLine, IMemoryPool::EatSingleton);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// new[]
-//
-// @doc:
-// Overload for array allocation; raises OOM exception if
-// unable to allocate
-//
-//---------------------------------------------------------------------------
-void *
-operator new []
- (
- SIZE_T cSize,
- IMemoryPool *pmp,
- const CHAR *szFilename,
- ULONG ulLine
- )
-{
- return NewImpl(pmp, cSize, szFilename, ulLine, IMemoryPool::EatArray);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete
-//
-// @doc:
-// Overload for singleton deletion
-//
-//---------------------------------------------------------------------------
-void
-operator delete
- (
- void *pv
- )
- throw()
-{
- DeleteImpl(pv, IMemoryPool::EatSingleton);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete
-//
-// @doc:
-// Placement delete; only used if constructor throws
-//
-//---------------------------------------------------------------------------
-void
-operator delete
- (
- void *pv,
- IMemoryPool *, // pmp,
- const CHAR *, // szFilename,
- ULONG // ulLine
- )
-{
- DeleteImpl(pv, IMemoryPool::EatSingleton);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete []
-//
-// @doc:
-// Overload for array deletion
-//
-//---------------------------------------------------------------------------
-void
-operator delete []
- (
- void *pv
- )
- throw()
-{
- DeleteImpl(pv, IMemoryPool::EatArray);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete []
-//
-// @doc:
-// Placement delete []; only used if constructor throws
-//
-//---------------------------------------------------------------------------
-void
-operator delete []
- (
- void *pv,
- IMemoryPool *, // pmp,
- const CHAR *, // szFilename,
- ULONG // ulLine
- )
-{
- DeleteImpl(pv, IMemoryPool::EatArray);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete
-//
-// @doc:
-// Non-throwing singleton delete operator
-//
-//---------------------------------------------------------------------------
-void
-operator delete
- (
- void* pv,
- const gpos::NO_THROW&
- )
- throw()
-{
- DeleteImplNoThrow(pv, IMemoryPool::EatSingleton);
-}
-
-
-//---------------------------------------------------------------------------
-// @function:
-// delete
-//
-// @doc:
-// Non-throwing array delete operator
-//
-//---------------------------------------------------------------------------
-void
-operator delete []
- (
- void* pv,
- const gpos::NO_THROW&
- )
- throw()
-{
- DeleteImplNoThrow(pv, IMemoryPool::EatArray);
-}
-
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/CGPOptimizer.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/CGPOptimizer.cpp b/src/backend/gpopt/CGPOptimizer.cpp
index ab88232..c0eaa3e 100644
--- a/src/backend/gpopt/CGPOptimizer.cpp
+++ b/src/backend/gpopt/CGPOptimizer.cpp
@@ -29,7 +29,6 @@
//
//---------------------------------------------------------------------------
-#include "gpopt/Allocators.h"
#include "gpopt/CGPOptimizer.h"
#include "gpopt/utils/COptTasks.h"
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/Makefile
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/Makefile b/src/backend/gpopt/Makefile
index eb58017..b587ffd 100644
--- a/src/backend/gpopt/Makefile
+++ b/src/backend/gpopt/Makefile
@@ -16,12 +16,12 @@ include $(top_builddir)/src/backend/gpopt/gpopt.mk
SUBDIRS = config translate relcache utils
-OBJS = Allocators.o CGPOptimizer.o gpdbwrappers.o
+OBJS = CGPOptimizer.o gpdbwrappers.o
OTHER_TASK = libdxltranslators.$(LDSFX) libgpoptudf.$(LDSFX)
ifeq (Darwin, $(UNAME))
- LDLIBFLAGS = -dynamiclib -flat_namespace -undefined dynamic_lookup -Wl,-unexported_symbols_list -Wl,unexported_symbols_list.txt
+ LDLIBFLAGS = -dynamiclib -flat_namespace -undefined dynamic_lookup -Wl
endif
ifeq (Linux, $(UNAME))
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/config/CConfigParamMapping.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/config/CConfigParamMapping.cpp b/src/backend/gpopt/config/CConfigParamMapping.cpp
index 4c54061..beb355e 100644
--- a/src/backend/gpopt/config/CConfigParamMapping.cpp
+++ b/src/backend/gpopt/config/CConfigParamMapping.cpp
@@ -409,7 +409,7 @@ CConfigParamMapping::PbsPack
ULONG ulXforms // number of available xforms
)
{
- CBitSet *pbs = New(pmp) CBitSet(pmp, EopttraceSentinel);
+ CBitSet *pbs = GPOS_NEW(pmp) CBitSet(pmp, EopttraceSentinel);
for (ULONG ul = 0; ul < GPOS_ARRAY_SIZE(m_elem); ul++)
{
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/gpdbwrappers.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/gpdbwrappers.cpp b/src/backend/gpopt/gpdbwrappers.cpp
index 45a7349..8be3fd7 100644
--- a/src/backend/gpopt/gpdbwrappers.cpp
+++ b/src/backend/gpopt/gpdbwrappers.cpp
@@ -888,7 +888,7 @@ Query *
gpdb::PqueryFlattenJoinAliasVar
(
Query *pquery,
- ULONG ulQueryLevel
+ gpos::ULONG ulQueryLevel
)
{
GP_WRAP_START;
@@ -2403,7 +2403,7 @@ gpdb::PqrActiveQueryResource(void)
}
-BOOL
+gpos::BOOL
gpdb::FChildPartDistributionMismatch
(
Relation rel
@@ -2417,7 +2417,7 @@ gpdb::FChildPartDistributionMismatch
return false;
}
-BOOL
+gpos::BOOL
gpdb::FChildTriggers
(
Oid oid,
@@ -3100,7 +3100,7 @@ gpdb::OptTasksFaultInjector
return FaultInjectorTypeNotSpecified;
}
-ULONG
+gpos::ULONG
gpdb::UlLeafPartitions
(
Oid oidRelation
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CCTEListEntry.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CCTEListEntry.cpp b/src/backend/gpopt/translate/CCTEListEntry.cpp
index 077bd55..372b4c5 100644
--- a/src/backend/gpopt/translate/CCTEListEntry.cpp
+++ b/src/backend/gpopt/translate/CCTEListEntry.cpp
@@ -65,13 +65,13 @@ CCTEListEntry::CCTEListEntry
{
GPOS_ASSERT(NULL != pcte && NULL != pdxlnCTEProducer);
- m_phmszcteinfo = New(pmp) HMSzCTEInfo(pmp);
+ m_phmszcteinfo = GPOS_NEW(pmp) HMSzCTEInfo(pmp);
Query *pqueryCTE = (Query*) pcte->ctequery;
#ifdef GPOS_DEBUG
BOOL fResult =
#endif
- m_phmszcteinfo->FInsert(pcte->ctename, New(pmp) SCTEProducerInfo(pdxlnCTEProducer, pqueryCTE->targetList));
+ m_phmszcteinfo->FInsert(pcte->ctename, GPOS_NEW(pmp) SCTEProducerInfo(pdxlnCTEProducer, pqueryCTE->targetList));
GPOS_ASSERT(fResult);
}
@@ -98,7 +98,7 @@ CCTEListEntry::CCTEListEntry
GPOS_ASSERT(NULL != pdrgpdxln);
GPOS_ASSERT(pdrgpdxln->UlLength() == gpdb::UlListLength(plCTE));
- m_phmszcteinfo = New(pmp) HMSzCTEInfo(pmp);
+ m_phmszcteinfo = GPOS_NEW(pmp) HMSzCTEInfo(pmp);
const ULONG ulCTEs = pdrgpdxln->UlLength();
for (ULONG ul = 0; ul < ulCTEs; ul++)
@@ -110,7 +110,7 @@ CCTEListEntry::CCTEListEntry
#ifdef GPOS_DEBUG
BOOL fResult =
#endif
- m_phmszcteinfo->FInsert(pcte->ctename, New(pmp) SCTEProducerInfo(pdxlnCTEProducer, pqueryCTE->targetList));
+ m_phmszcteinfo->FInsert(pcte->ctename, GPOS_NEW(pmp) SCTEProducerInfo(pdxlnCTEProducer, pqueryCTE->targetList));
GPOS_ASSERT(fResult);
GPOS_ASSERT(NULL != m_phmszcteinfo->PtLookup(pcte->ctename));
@@ -187,7 +187,7 @@ CCTEListEntry::AddCTEProducer
#ifdef GPOS_DEBUG
BOOL fResult =
#endif
- m_phmszcteinfo->FInsert(pcte->ctename, New(pmp) SCTEProducerInfo(pdxlnCTEProducer, pqueryCTE->targetList));
+ m_phmszcteinfo->FInsert(pcte->ctename, GPOS_NEW(pmp) SCTEProducerInfo(pdxlnCTEProducer, pqueryCTE->targetList));
GPOS_ASSERT(fResult);
}
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CContextDXLToPlStmt.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CContextDXLToPlStmt.cpp b/src/backend/gpopt/translate/CContextDXLToPlStmt.cpp
index f886148..bc48575 100644
--- a/src/backend/gpopt/translate/CContextDXLToPlStmt.cpp
+++ b/src/backend/gpopt/translate/CContextDXLToPlStmt.cpp
@@ -71,9 +71,9 @@ CContextDXLToPlStmt::CContextDXLToPlStmt
m_pintocl(NULL),
m_pdistrpolicy(NULL)
{
- m_phmuldxltrctxSharedScan = New(m_pmp) HMUlDxltrctx(m_pmp);
- m_phmulcteconsumerinfo = New(m_pmp) HMUlCTEConsumerInfo(m_pmp);
- m_pdrgpulNumSelectors = New(m_pmp) DrgPul(m_pmp);
+ m_phmuldxltrctxSharedScan = GPOS_NEW(m_pmp) HMUlDxltrctx(m_pmp);
+ m_phmulcteconsumerinfo = GPOS_NEW(m_pmp) HMUlCTEConsumerInfo(m_pmp);
+ m_pdrgpulNumSelectors = GPOS_NEW(m_pmp) DrgPul(m_pmp);
}
//---------------------------------------------------------------------------
@@ -187,11 +187,11 @@ CContextDXLToPlStmt::AddCTEConsumerInfo
List *plPlanCTE = ListMake1(pshscan);
- ULONG *pulKey = New(m_pmp) ULONG(ulCteId);
+ ULONG *pulKey = GPOS_NEW(m_pmp) ULONG(ulCteId);
#ifdef GPOS_DEBUG
BOOL fResult =
#endif
- m_phmulcteconsumerinfo->FInsert(pulKey, New(m_pmp) SCTEConsumerInfo(plPlanCTE));
+ m_phmulcteconsumerinfo->FInsert(pulKey, GPOS_NEW(m_pmp) SCTEConsumerInfo(plPlanCTE));
GPOS_ASSERT(fResult);
}
@@ -313,7 +313,7 @@ CContextDXLToPlStmt::IncrementPartitionSelectors
const ULONG ulLen = m_pdrgpulNumSelectors->UlLength();
for (ULONG ul = ulLen; ul <= ulScanId; ul++)
{
- ULONG *pul = New(m_pmp) ULONG(0);
+ ULONG *pul = GPOS_NEW(m_pmp) ULONG(0);
m_pdrgpulNumSelectors->Append(pul);
}
@@ -412,7 +412,7 @@ CContextDXLToPlStmt::AddSharedScanTranslationContext
CDXLTranslateContext *pdxltrctx
)
{
- ULONG *pul = New(m_pmp) ULONG(ulSpoolId);
+ ULONG *pul = GPOS_NEW(m_pmp) ULONG(ulSpoolId);
#ifdef GPOS_DEBUG
BOOL fInserted =
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CDXLTranslateContext.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CDXLTranslateContext.cpp b/src/backend/gpopt/translate/CDXLTranslateContext.cpp
index fa2140a..434a800 100644
--- a/src/backend/gpopt/translate/CDXLTranslateContext.cpp
+++ b/src/backend/gpopt/translate/CDXLTranslateContext.cpp
@@ -52,8 +52,8 @@ CDXLTranslateContext::CDXLTranslateContext
m_fChildAggNode(fChildAggNode)
{
// initialize hash table
- m_phmulte = New(m_pmp) HMUlTe(m_pmp);
- m_phmcolparam = New(m_pmp) HMColParam(m_pmp);
+ m_phmulte = GPOS_NEW(m_pmp) HMUlTe(m_pmp);
+ m_phmcolparam = GPOS_NEW(m_pmp) HMColParam(m_pmp);
}
//---------------------------------------------------------------------------
@@ -74,8 +74,8 @@ CDXLTranslateContext::CDXLTranslateContext
m_pmp(pmp),
m_fChildAggNode(fChildAggNode)
{
- m_phmulte = New(m_pmp) HMUlTe(m_pmp);
- m_phmcolparam = New(m_pmp) HMColParam(m_pmp);
+ m_phmulte = GPOS_NEW(m_pmp) HMUlTe(m_pmp);
+ m_phmcolparam = GPOS_NEW(m_pmp) HMColParam(m_pmp);
CopyParamHashmap(phmOriginal);
}
@@ -128,7 +128,7 @@ CDXLTranslateContext::CopyParamHashmap
CMappingElementColIdParamId *pmecolidparamid = const_cast<CMappingElementColIdParamId *>(hashmapiter.Pt());
const ULONG ulColId = pmecolidparamid->UlColId();
- ULONG *pulKey = New(m_pmp) ULONG(ulColId);
+ ULONG *pulKey = GPOS_NEW(m_pmp) ULONG(ulColId);
pmecolidparamid->AddRef();
m_phmcolparam->FInsert(pulKey, pmecolidparamid);
}
@@ -186,14 +186,14 @@ CDXLTranslateContext::InsertMapping
)
{
// copy key
- ULONG *pulKey = New(m_pmp) ULONG(ulColId);
+ ULONG *pulKey = GPOS_NEW(m_pmp) ULONG(ulColId);
// insert colid->target entry mapping in the hash map
BOOL fResult = m_phmulte->FInsert(pulKey, pte);
if (!fResult)
{
- delete pulKey;
+ GPOS_DELETE(pulKey);
}
}
@@ -213,7 +213,7 @@ CDXLTranslateContext::FInsertParamMapping
)
{
// copy key
- ULONG *pulKey = New(m_pmp) ULONG(ulColId);
+ ULONG *pulKey = GPOS_NEW(m_pmp) ULONG(ulColId);
// insert colid->target entry mapping in the hash map
return m_phmcolparam->FInsert(pulKey, pmecolidparamid);
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CDXLTranslateContextBaseTable.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CDXLTranslateContextBaseTable.cpp b/src/backend/gpopt/translate/CDXLTranslateContextBaseTable.cpp
index a4a2c1d..7ad61cf 100644
--- a/src/backend/gpopt/translate/CDXLTranslateContextBaseTable.cpp
+++ b/src/backend/gpopt/translate/CDXLTranslateContextBaseTable.cpp
@@ -54,7 +54,7 @@ CDXLTranslateContextBaseTable::CDXLTranslateContextBaseTable
m_iRel(0)
{
// initialize hash table
- m_phmuli = New(m_pmp) HMUlI(m_pmp);
+ m_phmuli = GPOS_NEW(m_pmp) HMUlI(m_pmp);
}
//---------------------------------------------------------------------------
@@ -179,8 +179,8 @@ CDXLTranslateContextBaseTable::FInsertMapping
)
{
// copy key and value
- ULONG *pulKey = New(m_pmp) ULONG(ulDXLColId);
- INT *piValue = New(m_pmp) INT(iAttno);
+ ULONG *pulKey = GPOS_NEW(m_pmp) ULONG(ulDXLColId);
+ INT *piValue = GPOS_NEW(m_pmp) INT(iAttno);
// insert colid-idx mapping in the hash map
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CMappingColIdVarQuery.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CMappingColIdVarQuery.cpp b/src/backend/gpopt/translate/CMappingColIdVarQuery.cpp
index 37ee8c8..e059f02 100644
--- a/src/backend/gpopt/translate/CMappingColIdVarQuery.cpp
+++ b/src/backend/gpopt/translate/CMappingColIdVarQuery.cpp
@@ -109,10 +109,10 @@ CMappingColIdVarQuery::FInsertMapping
GPOS_ASSERT(NULL == m_ptemap->PtLookup(&ulColId));
// create mapping element
- CMappingElementColIdTE *pmappingelement = New (m_pmp) CMappingElementColIdTE(ulColId, m_ulQueryLevel, pte);
+ CMappingElementColIdTE *pmappingelement = GPOS_NEW(m_pmp) CMappingElementColIdTE(ulColId, m_ulQueryLevel, pte);
// insert ColId->TE mapping
- ULONG *pulKey1 = New(m_pmp) ULONG(ulColId);
+ ULONG *pulKey1 = GPOS_NEW(m_pmp) ULONG(ulColId);
BOOL fRes1 = m_ptemap->FInsert(pulKey1, pmappingelement);
GPOS_ASSERT(fRes1);
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CMappingParamIdScalarId.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CMappingParamIdScalarId.cpp b/src/backend/gpopt/translate/CMappingParamIdScalarId.cpp
index e041efc..df1c4ad 100644
--- a/src/backend/gpopt/translate/CMappingParamIdScalarId.cpp
+++ b/src/backend/gpopt/translate/CMappingParamIdScalarId.cpp
@@ -47,7 +47,7 @@ CMappingParamIdScalarId::CMappingParamIdScalarId
:
m_pmp(pmp)
{
- m_phmps = New(m_pmp) HMParamScalar(m_pmp);
+ m_phmps = GPOS_NEW(m_pmp) HMParamScalar(m_pmp);
}
//---------------------------------------------------------------------------
@@ -84,7 +84,7 @@ CMappingParamIdScalarId::FInsertMapping
)
{
// copy key
- ULONG *pulKey = New(m_pmp) ULONG(ulParamId);
+ ULONG *pulKey = GPOS_NEW(m_pmp) ULONG(ulParamId);
// insert mapping in the hash map
return m_phmps->FInsert(pulKey, pscid);
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CMappingVarColId.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CMappingVarColId.cpp b/src/backend/gpopt/translate/CMappingVarColId.cpp
index 798efcc..4745517 100644
--- a/src/backend/gpopt/translate/CMappingVarColId.cpp
+++ b/src/backend/gpopt/translate/CMappingVarColId.cpp
@@ -67,7 +67,7 @@ CMappingVarColId::CMappingVarColId
:
m_pmp(pmp)
{
- m_pmvcmap = New(m_pmp) CMVCMap(m_pmp);
+ m_pmvcmap = GPOS_NEW(m_pmp) CMVCMap(m_pmp);
}
//---------------------------------------------------------------------------
@@ -102,7 +102,7 @@ CMappingVarColId::Pgpdbattoptcol
ulVarNo = OUTER;
}
- CGPDBAttInfo *pgpdbattinfo = New(m_pmp) CGPDBAttInfo(ulAbsQueryLevel, ulVarNo, pvar->varattno);
+ CGPDBAttInfo *pgpdbattinfo = GPOS_NEW(m_pmp) CGPDBAttInfo(ulAbsQueryLevel, ulVarNo, pvar->varattno);
CGPDBAttOptCol *pgpdbattoptcol = m_pmvcmap->PtLookup(pgpdbattinfo);
if (NULL == pgpdbattoptcol)
@@ -178,14 +178,14 @@ CMappingVarColId::Insert
GPOS_ASSERT(ulVarNo > 0);
// create key
- CGPDBAttInfo *pgpdbattinfo = New(m_pmp) CGPDBAttInfo(ulQueryLevel, ulVarNo, iAttNo);
+ CGPDBAttInfo *pgpdbattinfo = GPOS_NEW(m_pmp) CGPDBAttInfo(ulQueryLevel, ulVarNo, iAttNo);
// create value
- COptColInfo *poptcolinfo = New(m_pmp) COptColInfo(ulColId, pstrColName);
+ COptColInfo *poptcolinfo = GPOS_NEW(m_pmp) COptColInfo(ulColId, pstrColName);
// key is part of value, bump up refcount
pgpdbattinfo->AddRef();
- CGPDBAttOptCol *pgpdbattoptcol = New(m_pmp) CGPDBAttOptCol(pgpdbattinfo, poptcolinfo);
+ CGPDBAttOptCol *pgpdbattoptcol = GPOS_NEW(m_pmp) CGPDBAttOptCol(pgpdbattinfo, poptcolinfo);
#ifdef GPOS_DEBUG
BOOL fResult =
@@ -308,7 +308,7 @@ CMappingVarColId::Load
);
ul ++;
- delete(pstrColName);
+ GPOS_DELETE(pstrColName);
}
}
@@ -485,7 +485,7 @@ CMappingVarColId::PmapvarcolidCopy
)
const
{
- CMappingVarColId *pmapvarcolid = New(m_pmp) CMappingVarColId(m_pmp);
+ CMappingVarColId *pmapvarcolid = GPOS_NEW(m_pmp) CMappingVarColId(m_pmp);
// iterate over full map
CMVCMapIter mvcmi(this->m_pmvcmap);
@@ -498,10 +498,10 @@ CMappingVarColId::PmapvarcolidCopy
if (pgpdbattinfo->UlQueryLevel() <= ulQueryLevel)
{
// include all variables defined at same query level or before
- CGPDBAttInfo *pgpdbattinfoNew = New(m_pmp) CGPDBAttInfo(pgpdbattinfo->UlQueryLevel(), pgpdbattinfo->UlVarNo(), pgpdbattinfo->IAttNo());
- COptColInfo *poptcolinfoNew = New(m_pmp) COptColInfo(poptcolinfo->UlColId(), New(m_pmp) CWStringConst(m_pmp, poptcolinfo->PstrColName()->Wsz()));
+ CGPDBAttInfo *pgpdbattinfoNew = GPOS_NEW(m_pmp) CGPDBAttInfo(pgpdbattinfo->UlQueryLevel(), pgpdbattinfo->UlVarNo(), pgpdbattinfo->IAttNo());
+ COptColInfo *poptcolinfoNew = GPOS_NEW(m_pmp) COptColInfo(poptcolinfo->UlColId(), GPOS_NEW(m_pmp) CWStringConst(m_pmp, poptcolinfo->PstrColName()->Wsz()));
pgpdbattinfoNew->AddRef();
- CGPDBAttOptCol *pgpdbattoptcolNew = New(m_pmp) CGPDBAttOptCol(pgpdbattinfoNew, poptcolinfoNew);
+ CGPDBAttOptCol *pgpdbattoptcolNew = GPOS_NEW(m_pmp) CGPDBAttOptCol(pgpdbattinfoNew, poptcolinfoNew);
// insert into hashmap
#ifdef GPOS_DEBUG
@@ -530,7 +530,7 @@ CMappingVarColId::PmapvarcolidCopy
)
const
{
- CMappingVarColId *pmapvarcolid = New(pmp) CMappingVarColId(pmp);
+ CMappingVarColId *pmapvarcolid = GPOS_NEW(pmp) CMappingVarColId(pmp);
// iterate over full map
CMVCMapIter mvcmi(this->m_pmvcmap);
@@ -540,10 +540,10 @@ CMappingVarColId::PmapvarcolidCopy
const CGPDBAttInfo *pgpdbattinfo = pgpdbattoptcol->Pgpdbattinfo();
const COptColInfo *poptcolinfo = pgpdbattoptcol->Poptcolinfo();
- CGPDBAttInfo *pgpdbattinfoNew = New(pmp) CGPDBAttInfo(pgpdbattinfo->UlQueryLevel(), pgpdbattinfo->UlVarNo(), pgpdbattinfo->IAttNo());
- COptColInfo *poptcolinfoNew = New(pmp) COptColInfo(poptcolinfo->UlColId(), New(pmp) CWStringConst(pmp, poptcolinfo->PstrColName()->Wsz()));
+ CGPDBAttInfo *pgpdbattinfoNew = GPOS_NEW(pmp) CGPDBAttInfo(pgpdbattinfo->UlQueryLevel(), pgpdbattinfo->UlVarNo(), pgpdbattinfo->IAttNo());
+ COptColInfo *poptcolinfoNew = GPOS_NEW(pmp) COptColInfo(poptcolinfo->UlColId(), GPOS_NEW(pmp) CWStringConst(pmp, poptcolinfo->PstrColName()->Wsz()));
pgpdbattinfoNew->AddRef();
- CGPDBAttOptCol *pgpdbattoptcolNew = New(pmp) CGPDBAttOptCol(pgpdbattinfoNew, poptcolinfoNew);
+ CGPDBAttOptCol *pgpdbattoptcolNew = GPOS_NEW(pmp) CGPDBAttOptCol(pgpdbattinfoNew, poptcolinfoNew);
// insert into hashmap
#ifdef GPOS_DEBUG
@@ -580,7 +580,7 @@ CMappingVarColId::PmapvarcolidRemap
// construct a mapping old cols -> new cols
HMUlUl *phmulul = CTranslatorUtils::PhmululMap(pmp, pdrgpulOld, pdrgpulNew);
- CMappingVarColId *pmapvarcolid = New(pmp) CMappingVarColId(pmp);
+ CMappingVarColId *pmapvarcolid = GPOS_NEW(pmp) CMappingVarColId(pmp);
CMVCMapIter mvcmi(this->m_pmvcmap);
while (mvcmi.FAdvance())
@@ -589,7 +589,7 @@ CMappingVarColId::PmapvarcolidRemap
const CGPDBAttInfo *pgpdbattinfo = pgpdbattoptcol->Pgpdbattinfo();
const COptColInfo *poptcolinfo = pgpdbattoptcol->Poptcolinfo();
- CGPDBAttInfo *pgpdbattinfoNew = New(pmp) CGPDBAttInfo(pgpdbattinfo->UlQueryLevel(), pgpdbattinfo->UlVarNo(), pgpdbattinfo->IAttNo());
+ CGPDBAttInfo *pgpdbattinfoNew = GPOS_NEW(pmp) CGPDBAttInfo(pgpdbattinfo->UlQueryLevel(), pgpdbattinfo->UlVarNo(), pgpdbattinfo->IAttNo());
ULONG ulColId = poptcolinfo->UlColId();
ULONG *pulColIdNew = phmulul->PtLookup(&ulColId);
if (NULL != pulColIdNew)
@@ -597,9 +597,9 @@ CMappingVarColId::PmapvarcolidRemap
ulColId = *pulColIdNew;
}
- COptColInfo *poptcolinfoNew = New(pmp) COptColInfo(ulColId, New(pmp) CWStringConst(pmp, poptcolinfo->PstrColName()->Wsz()));
+ COptColInfo *poptcolinfoNew = GPOS_NEW(pmp) COptColInfo(ulColId, GPOS_NEW(pmp) CWStringConst(pmp, poptcolinfo->PstrColName()->Wsz()));
pgpdbattinfoNew->AddRef();
- CGPDBAttOptCol *pgpdbattoptcolNew = New(pmp) CGPDBAttOptCol(pgpdbattinfoNew, poptcolinfoNew);
+ CGPDBAttOptCol *pgpdbattoptcolNew = GPOS_NEW(pmp) CGPDBAttOptCol(pgpdbattinfoNew, poptcolinfoNew);
#ifdef GPOS_DEBUG
BOOL fResult =
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CStateDXLToQuery.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CStateDXLToQuery.cpp b/src/backend/gpopt/translate/CStateDXLToQuery.cpp
index 8bd7533..f69a56a 100644
--- a/src/backend/gpopt/translate/CStateDXLToQuery.cpp
+++ b/src/backend/gpopt/translate/CStateDXLToQuery.cpp
@@ -58,7 +58,7 @@ CStateDXLToQuery::CStateDXLToQuery
m_plTEColumns(NIL),
m_plColumnNames(NIL)
{
- m_pdrgpulColIds = New(m_pmp) DrgPul(m_pmp);
+ m_pdrgpulColIds = GPOS_NEW(m_pmp) DrgPul(m_pmp);
}
@@ -96,7 +96,7 @@ CStateDXLToQuery::AddOutputColumnEntry
GPOS_ASSERT((ULONG) gpdb::UlListLength(m_plTEColumns) == m_pdrgpulColIds->UlLength());
m_plTEColumns = gpdb::PlAppendElement(m_plTEColumns, pte);
m_plColumnNames = gpdb::PlAppendElement(m_plColumnNames, szColumnName);
- m_pdrgpulColIds->Append(New(m_pmp) ULONG(ulColId));
+ m_pdrgpulColIds->Append(GPOS_NEW(m_pmp) ULONG(ulColId));
}
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CTranslatorDXLToPlStmt.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CTranslatorDXLToPlStmt.cpp b/src/backend/gpopt/translate/CTranslatorDXLToPlStmt.cpp
index ec0c511..12ef75f 100644
--- a/src/backend/gpopt/translate/CTranslatorDXLToPlStmt.cpp
+++ b/src/backend/gpopt/translate/CTranslatorDXLToPlStmt.cpp
@@ -134,7 +134,7 @@ CTranslatorDXLToPlStmt::CTranslatorDXLToPlStmt
m_ulSegments(ulSegments),
m_ulPartitionSelectorCounter(0)
{
- m_pdxlsctranslator = New (m_pmp) CTranslatorDXLToScalar(m_pmp, m_pmda, m_ulSegments);
+ m_pdxlsctranslator = GPOS_NEW(m_pmp) CTranslatorDXLToScalar(m_pmp, m_pmda, m_ulSegments);
InitTranslators();
}
@@ -148,7 +148,7 @@ CTranslatorDXLToPlStmt::CTranslatorDXLToPlStmt
//---------------------------------------------------------------------------
CTranslatorDXLToPlStmt::~CTranslatorDXLToPlStmt()
{
- delete m_pdxlsctranslator;
+ GPOS_DELETE(m_pdxlsctranslator);
}
//---------------------------------------------------------------------------
@@ -234,7 +234,7 @@ CTranslatorDXLToPlStmt::PplstmtFromDXL
CDXLTranslateContext dxltrctx(m_pmp, false);
- DrgPdxltrctx *pdrgpdxltrctxPrevSiblings = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctxPrevSiblings = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
Plan *pplan = PplFromDXL(pdxln, &dxltrctx, NULL, pdrgpdxltrctxPrevSiblings);
pdrgpdxltrctxPrevSiblings->Release();
@@ -1511,7 +1511,7 @@ CTranslatorDXLToPlStmt::TranslateIndexConditions
)
{
// array of index qual info
- DrgPindexqualinfo *pdrgpindexqualinfo = New(m_pmp) DrgPindexqualinfo(m_pmp);
+ DrgPindexqualinfo *pdrgpindexqualinfo = GPOS_NEW(m_pmp) DrgPindexqualinfo(m_pmp);
// build colid->var mapping
CMappingColIdVarPlStmt mapcidvarplstmt(m_pmp, pdxltrctxbt, pdrgpdxltrctxPrevSiblings, pdxltrctxOut, m_pctxdxltoplstmt, pplanParent);
@@ -1565,7 +1565,7 @@ CTranslatorDXLToPlStmt::TranslateIndexConditions
GPOS_ASSERT(!fRecheck);
// create index qual
- pdrgpindexqualinfo->Append(New(m_pmp) CIndexQualInfo(iAttno, (OpExpr *)pexprIndexCond, (OpExpr *)pexprOrigIndexCond, (StrategyNumber) iSN, oidIndexSubtype));
+ pdrgpindexqualinfo->Append(GPOS_NEW(m_pmp) CIndexQualInfo(iAttno, (OpExpr *)pexprIndexCond, (OpExpr *)pexprOrigIndexCond, (StrategyNumber) iSN, oidIndexSubtype));
}
// the index quals much be ordered by attribute number
@@ -1665,7 +1665,7 @@ CTranslatorDXLToPlStmt::PlimitFromDXLLimit
// NOTE: Limit node has only the left plan while the right plan is left empty
Plan *pplanLeft = PplFromDXL(pdxlnChildPlan, &dxltrctxLeft, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(&dxltrctxLeft);
pplan->targetlist = PlTargetListFromProjList
@@ -1760,12 +1760,12 @@ CTranslatorDXLToPlStmt::PhjFromDXLHJ
Plan *pplanLeft = PplFromDXL(pdxlnLeft, &dxltrctxLeft, pplan, pdrgpdxltrctxPrevSiblings);
// the right side of the join is the one where the hash phase is done
- DrgPdxltrctx *pdrgpdxltrctxWithSiblings = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctxWithSiblings = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctxWithSiblings->Append(&dxltrctxLeft);
pdrgpdxltrctxWithSiblings->AppendArray(pdrgpdxltrctxPrevSiblings);
Plan *pplanRight = (Plan*) PhhashFromDXL(pdxlnRight, &dxltrctxRight, pplan, pdrgpdxltrctxWithSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxLeft));
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxRight));
// translate proj list and filter
@@ -2114,7 +2114,7 @@ CTranslatorDXLToPlStmt::PnljFromDXLNLJ
// because inner child depends on variables coming from outer child
pj->prefetch_inner = !pdxlnlj->FIndexNLJ();
- DrgPdxltrctx *pdrgpdxltrctxWithSiblings = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctxWithSiblings = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
Plan *pplanLeft = NULL;
Plan *pplanRight = NULL;
if (pdxlnlj->FIndexNLJ())
@@ -2141,7 +2141,7 @@ CTranslatorDXLToPlStmt::PnljFromDXLNLJ
// translate left child after right child translation is complete
pplanLeft = PplFromDXL(pdxlnLeft, &dxltrctxLeft, pplan, pdrgpdxltrctxWithSiblings);
}
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(&dxltrctxLeft);
pdrgpdxltrctx->Append(&dxltrctxRight);
@@ -2237,13 +2237,13 @@ CTranslatorDXLToPlStmt::PmjFromDXLMJ
Plan *pplanLeft = PplFromDXL(pdxlnLeft, &dxltrctxLeft, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctxWithSiblings = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctxWithSiblings = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctxWithSiblings->Append(&dxltrctxLeft);
pdrgpdxltrctxWithSiblings->AppendArray(pdrgpdxltrctxPrevSiblings);
Plan *pplanRight = PplFromDXL(pdxlnRight, &dxltrctxRight, pplan, pdrgpdxltrctxWithSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxLeft));
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxRight));
@@ -2438,7 +2438,7 @@ CTranslatorDXLToPlStmt::PplanMotionFromDXLMotion
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list and filter
@@ -2635,7 +2635,7 @@ CTranslatorDXLToPlStmt::PplanResultHashFilters
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list and filter
@@ -2766,7 +2766,7 @@ CTranslatorDXLToPlStmt::PaggFromDXLAgg
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list and filter
@@ -2879,7 +2879,7 @@ CTranslatorDXLToPlStmt::PwindowFromDXLWindow
CDXLTranslateContext dxltrctxChild(m_pmp, true, pdxltrctxOut->PhmColParam());
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list and filter
@@ -2986,7 +2986,7 @@ CTranslatorDXLToPlStmt::Pwindowframe
pwindowframe->exclude = CTranslatorUtils::Windowexclusion(pdxlwf->Edxlfes());
// translate the CDXLNodes representing the leading and trailing edge
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(pdxltrctxChild);
CMappingColIdVarPlStmt mapcidvarplstmt = CMappingColIdVarPlStmt
@@ -3071,7 +3071,7 @@ CTranslatorDXLToPlStmt::PsortFromDXLSort
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list and filter
@@ -3318,7 +3318,7 @@ CTranslatorDXLToPlStmt::PresultFromDXLResult
List *plQuals = NULL;
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list and filter
@@ -3399,8 +3399,8 @@ CTranslatorDXLToPlStmt::PplanPartitionSelector
pplan->nMotionNodes = 0;
CDXLNode *pdxlnChild = NULL;
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
- DrgPdxltrctx *pdrgpdxltrctxWithSiblings = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctxWithSiblings = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
CDXLTranslateContext dxltrctxChild(m_pmp, false, pdxltrctxOut->PhmColParam());
@@ -3631,7 +3631,7 @@ CTranslatorDXLToPlStmt::PappendFromDXLAppend
pplan->targetlist = gpdb::PlAppendElement(pplan->targetlist, pte);
}
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(pdxltrctxOut));
// translate filter
@@ -3700,7 +3700,7 @@ CTranslatorDXLToPlStmt::PmatFromDXLMaterialize
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list and filter
@@ -3792,7 +3792,7 @@ CTranslatorDXLToPlStmt::PshscanFromDXLSharedScan
{
// translate shared scan child
CDXLNode *pdxlnChild = (*pdxlnSharedScan)[EdxlshscanIndexChild];
- pdxltrctxChild = New(m_pmp) CDXLTranslateContext(m_pmp, false, pdxltrctxOut->PhmColParam());
+ pdxltrctxChild = GPOS_NEW(m_pmp) CDXLTranslateContext(m_pmp, false, pdxltrctxOut->PhmColParam());
Plan *pplanChild = PplFromDXL(pdxlnChild, pdxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
@@ -3814,7 +3814,7 @@ CTranslatorDXLToPlStmt::PshscanFromDXLSharedScan
CDXLNode *pdxlnPrL = (*pdxlnSharedScan)[EdxlshscanIndexProjList];
CDXLNode *pdxlnFilter = (*pdxlnSharedScan)[EdxlshscanIndexFilter];
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(pdxltrctxChild);
// translate proj list and filter
@@ -3886,7 +3886,7 @@ CTranslatorDXLToPlStmt::PshscanFromDXLCTEProducer
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
GPOS_ASSERT(NULL != pplanChild && "child plan cannot be NULL");
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(&dxltrctxChild);
// translate proj list
pplan->targetlist = PlTargetListFromProjList
@@ -4188,7 +4188,7 @@ CTranslatorDXLToPlStmt::PplanSequence
CDXLNode *pdxlnPrL = (*pdxlnSequence)[0];
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list
@@ -4446,19 +4446,19 @@ CTranslatorDXLToPlStmt::PplanDML
switch (pdxlop->EdxlDmlOpType())
{
- case Edxldmldelete:
+ case gpdxl::Edxldmldelete:
{
m_cmdtype = CMD_DELETE;
aclmode = ACL_DELETE;
break;
}
- case Edxldmlupdate:
+ case gpdxl::Edxldmlupdate:
{
m_cmdtype = CMD_UPDATE;
aclmode = ACL_UPDATE;
break;
}
- case Edxldmlinsert:
+ case gpdxl::Edxldmlinsert:
{
m_cmdtype = CMD_INSERT;
aclmode = ACL_INSERT;
@@ -4497,7 +4497,7 @@ CTranslatorDXLToPlStmt::PplanDML
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(&dxltrctxChild);
// translate proj list
@@ -4678,7 +4678,7 @@ CTranslatorDXLToPlStmt::PplanSplit
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(&dxltrctxChild);
// translate proj list and filter
@@ -4805,7 +4805,7 @@ CTranslatorDXLToPlStmt::PplanAssert
List *plQuals = NULL;
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(const_cast<CDXLTranslateContext*>(&dxltrctxChild));
// translate proj list
@@ -4866,7 +4866,7 @@ CTranslatorDXLToPlStmt::PplanRowTrigger
Plan *pplanChild = PplFromDXL(pdxlnChild, &dxltrctxChild, pplan, pdrgpdxltrctxPrevSiblings);
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(&dxltrctxChild);
// translate proj list and filter
@@ -5458,7 +5458,7 @@ CTranslatorDXLToPlStmt::TranslateHashExprList
List *plHashExpr = NIL;
List *plHashExprTypes = NIL;
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(pdxltrctxChild);
const ULONG ulArity = pdxlnHashExprList->UlArity();
@@ -5745,7 +5745,7 @@ CTranslatorDXLToPlStmt::PplanCTAS
Plan *pplan = PplFromDXL(pdxlnChild, &dxltrctxChild, pplanParent, pdrgpdxltrctxPrevSiblings);
// fix target list to match the required column names
- DrgPdxltrctx *pdrgpdxltrctx = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctx = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
pdrgpdxltrctx->Append(&dxltrctxChild);
List *plTargetList = PlTargetListFromProjList
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CTranslatorDXLToQuery.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CTranslatorDXLToQuery.cpp b/src/backend/gpopt/translate/CTranslatorDXLToQuery.cpp
index 8cee1d3..260fe63 100644
--- a/src/backend/gpopt/translate/CTranslatorDXLToQuery.cpp
+++ b/src/backend/gpopt/translate/CTranslatorDXLToQuery.cpp
@@ -79,7 +79,7 @@ CTranslatorDXLToQuery::CTranslatorDXLToQuery
m_ulSortgrouprefCounter(0),
m_ulSegments(ulSegments)
{
- m_pdxlsctranslator = New (m_pmp) CTranslatorDXLToScalar(m_pmp, m_pmda, m_ulSegments);
+ m_pdxlsctranslator = GPOS_NEW(m_pmp) CTranslatorDXLToScalar(m_pmp, m_pmda, m_ulSegments);
}
//---------------------------------------------------------------------------
@@ -92,7 +92,7 @@ CTranslatorDXLToQuery::CTranslatorDXLToQuery
//---------------------------------------------------------------------------
CTranslatorDXLToQuery::~CTranslatorDXLToQuery()
{
- delete m_pdxlsctranslator;
+ GPOS_DELETE(m_pdxlsctranslator);
}
//---------------------------------------------------------------------------
@@ -114,7 +114,7 @@ CTranslatorDXLToQuery::PqueryFromDXL
)
{
// initialize the colid->var mapping
- CMappingColIdVarQuery *pmapcidvarquery = New (m_pmp) CMappingColIdVarQuery(m_pmp, ptemap, ulQueryLevel);
+ CMappingColIdVarQuery *pmapcidvarquery = GPOS_NEW(m_pmp) CMappingColIdVarQuery(m_pmp, ptemap, ulQueryLevel);
GPOS_ASSERT(NULL != pdxln);
@@ -152,7 +152,7 @@ CTranslatorDXLToQuery::PqueryFromDXL
// TODO: venky; June 14 2011, We currently assume that all queries are of the type select.
pquery->commandType = CMD_SELECT;
- delete pmapcidvarquery;
+ GPOS_DELETE(pmapcidvarquery);
if (m_pdxlsctranslator->FHasSubqueries())
{
@@ -182,7 +182,7 @@ CTranslatorDXLToQuery::PqueryFromDXLSubquery
{
// initialize the colid->var mapping
- CMappingColIdVarQuery *pmapcidvarquery = New (m_pmp) CMappingColIdVarQuery(m_pmp, ptemap, ulQueryLevel);
+ CMappingColIdVarQuery *pmapcidvarquery = GPOS_NEW (m_pmp) CMappingColIdVarQuery(m_pmp, ptemap, ulQueryLevel);
GPOS_ASSERT(NULL != pdxln);
@@ -201,7 +201,7 @@ CTranslatorDXLToQuery::PqueryFromDXLSubquery
pquery->commandType = CMD_SELECT;
- delete pmapcidvarquery;
+ GPOS_DELETE(pmapcidvarquery);
if (m_pdxlsctranslator->FHasSubqueries())
{
@@ -229,7 +229,7 @@ CTranslatorDXLToQuery::SetSubqueryOutput
)
{
GPOS_ASSERT(NULL != pquery);
- CStateDXLToQuery *pstatedxltoqueryOutput = New(m_pmp) CStateDXLToQuery(m_pmp);
+ CStateDXLToQuery *pstatedxltoqueryOutput = GPOS_NEW(m_pmp) CStateDXLToQuery(m_pmp);
List *plTE = NIL;
ULONG ulResno = 1;
@@ -279,7 +279,7 @@ CTranslatorDXLToQuery::SetSubqueryOutput
}
pstatedxltoquery->Reload(pstatedxltoqueryOutput);
- delete pstatedxltoqueryOutput;
+ GPOS_DELETE(pstatedxltoqueryOutput);
pquery->targetList = plTE;
}
@@ -303,7 +303,7 @@ CTranslatorDXLToQuery::SetQueryOutput
{
GPOS_ASSERT(NULL != pdrgpdxlnQueryOutput && NULL != pquery);
- CStateDXLToQuery *pstatedxltoqueryOutput = New(m_pmp) CStateDXLToQuery(m_pmp);
+ CStateDXLToQuery *pstatedxltoqueryOutput = GPOS_NEW(m_pmp) CStateDXLToQuery(m_pmp);
List *plTE = NIL;
@@ -366,7 +366,7 @@ CTranslatorDXLToQuery::SetQueryOutput
}
pstatedxltoquery->Reload(pstatedxltoqueryOutput);
- delete pstatedxltoqueryOutput;
+ GPOS_DELETE(pstatedxltoqueryOutput);
pquery->targetList = plTE;
}
@@ -566,10 +566,10 @@ CTranslatorDXLToQuery::TranslateSetOp
{
CDXLNode *pdxlnChild = (*pdxln)[ul];
- CStateDXLToQuery *pstatedxltoqueryChild = New(m_pmp) CStateDXLToQuery(m_pmp);
+ CStateDXLToQuery *pstatedxltoqueryChild = GPOS_NEW(m_pmp) CStateDXLToQuery(m_pmp);
RangeTblRef *prtrefChild = PrtrefFromDXLLgOp(pdxlnChild, pquery, pstatedxltoqueryChild, pmapcidvarquery);
MarkUnusedColumns(pquery, prtrefChild, pstatedxltoqueryChild, pdxlop->Pdrgpul(ul) /*array of colids of the first child*/);
- delete pstatedxltoqueryChild;
+ GPOS_DELETE(pstatedxltoqueryChild);
if (0 == ul)
{
@@ -632,7 +632,7 @@ CTranslatorDXLToQuery::MarkUnusedColumns
Query *pqueryDerTbl = prte->subquery;
// maintain the list of used columns in a bit set
- CBitSet *pds = New(m_pmp) CBitSet(m_pmp);
+ CBitSet *pds = GPOS_NEW(m_pmp) CBitSet(m_pmp);
const ULONG ulLen = pdrgpulColids->UlLength();
for (ULONG ul = 0; ul < ulLen; ul++)
{
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CTranslatorDXLToScalar.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CTranslatorDXLToScalar.cpp b/src/backend/gpopt/translate/CTranslatorDXLToScalar.cpp
index db086b8..7d0b0ce 100644
--- a/src/backend/gpopt/translate/CTranslatorDXLToScalar.cpp
+++ b/src/backend/gpopt/translate/CTranslatorDXLToScalar.cpp
@@ -634,7 +634,7 @@ CTranslatorDXLToScalar::PparamFromDXLNodeScInitPlan
// Since an init plan is not a scalar node, we create a new DXLTranslator to handle its translation
CContextDXLToPlStmt *pctxdxltoplstmt = (dynamic_cast<CMappingColIdVarPlStmt*>(pmapcidvar))->Pctxdxltoplstmt();
CTranslatorDXLToPlStmt trdxltoplstmt(m_pmp, m_pmda, pctxdxltoplstmt, m_ulSegments);
- DrgPdxltrctx *pdrgpdxltrctxPrevSiblings = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctxPrevSiblings = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
Plan *pplanChild = trdxltoplstmt.PplFromDXL(pdxlnChild, pdxltrctxOut, pplan, pdrgpdxltrctxPrevSiblings);
pdrgpdxltrctxPrevSiblings->Release();
@@ -711,7 +711,7 @@ CTranslatorDXLToScalar::PsubplanFromDXLNodeScSubPlan
if (NULL == dxltrctxSubplan.Pmecolidparamid(ulColid))
{
// keep outer reference mapping to the original column for subsequent subplans
- CMappingElementColIdParamId *pmecolidparamid = New (m_pmp) CMappingElementColIdParamId(ulColid, pctxdxltoplstmt->UlNextParamId(), pmdid);
+ CMappingElementColIdParamId *pmecolidparamid = GPOS_NEW(m_pmp) CMappingElementColIdParamId(ulColid, pctxdxltoplstmt->UlNextParamId(), pmdid);
#ifdef GPOS_DEBUG
BOOL fInserted =
@@ -744,7 +744,7 @@ CTranslatorDXLToScalar::PsubplanFromDXLNodeScSubPlan
(dynamic_cast<CMappingColIdVarPlStmt*>(pmapcidvar))->Pctxdxltoplstmt(),
m_ulSegments
);
- DrgPdxltrctx *pdrgpdxltrctxPrevSiblings = New(m_pmp) DrgPdxltrctx(m_pmp);
+ DrgPdxltrctx *pdrgpdxltrctxPrevSiblings = GPOS_NEW(m_pmp) DrgPdxltrctx(m_pmp);
Plan *pplanChild = trdxltoplstmt.PplFromDXL(pdxlnChild, &dxltrctxSubplan, pplan, pdrgpdxltrctxPrevSiblings);
pdrgpdxltrctxPrevSiblings->Release();
@@ -891,7 +891,7 @@ CTranslatorDXLToScalar::TranslateSubplanParams
IMDId *pmdidType = pmecolidparamid->PmdidType();
pmdidType->AddRef();
- CDXLScalarIdent *pdxlopIdent = New(m_pmp) CDXLScalarIdent(m_pmp, pdxlcr, pmdidType);
+ CDXLScalarIdent *pdxlopIdent = GPOS_NEW(m_pmp) CDXLScalarIdent(m_pmp, pdxlcr, pmdidType);
Expr *parg = (Expr *) pmapcidvar->PvarFromDXLNodeScId(pdxlopIdent);
// not found in mapping, it must be an external parameter
@@ -951,7 +951,7 @@ CTranslatorDXLToScalar::SzSubplanAlias
ULONG ulPlanId
)
{
- CWStringDynamic *pstr = New (m_pmp) CWStringDynamic(m_pmp);
+ CWStringDynamic *pstr = GPOS_NEW(m_pmp) CWStringDynamic(m_pmp);
pstr->AppendFormat(GPOS_WSZ_LIT("SubPlan %d"), ulPlanId);
const WCHAR *wsz = pstr->Wsz();
@@ -959,7 +959,7 @@ CTranslatorDXLToScalar::SzSubplanAlias
CHAR *sz = (CHAR *) gpdb::GPDBAlloc(ulMaxLength);
gpos::clib::LWcsToMbs(sz, const_cast<WCHAR *>(wsz), ulMaxLength);
sz[ulMaxLength - 1] = '\0';
- delete pstr;
+ GPOS_DELETE(pstr);
return sz;
}
@@ -1026,10 +1026,10 @@ CTranslatorDXLToScalar::PsublinkFromDXLNodeSubqueryExists
CDXLNode *pdxlnChild = (*pdxlnSubqueryExists)[0];
CTranslatorDXLToQuery trdxlquery(m_pmp, m_pmda, m_ulSegments);
- CStateDXLToQuery *pstatedxltoquery = New(m_pmp) CStateDXLToQuery(m_pmp);
+ CStateDXLToQuery *pstatedxltoquery = GPOS_NEW(m_pmp) CStateDXLToQuery(m_pmp);
// empty list of output columns
- DrgPdxln *pdrgpdxlnOutputCols = New(m_pmp) DrgPdxln(m_pmp);
+ DrgPdxln *pdrgpdxlnOutputCols = GPOS_NEW(m_pmp) DrgPdxln(m_pmp);
CMappingColIdVarQuery *pmapcidvarquery = dynamic_cast<CMappingColIdVarQuery *>(pmapcidvar);
TEMap *ptemapCopy = CTranslatorUtils::PtemapCopy(m_pmp, pmapcidvarquery->Ptemap());
@@ -1044,7 +1044,7 @@ CTranslatorDXLToScalar::PsublinkFromDXLNodeSubqueryExists
// clean up
pdrgpdxlnOutputCols->Release();
- delete pstatedxltoquery;
+ GPOS_DELETE(pstatedxltoquery);
CRefCount::SafeRelease(ptemapCopy);
SubLink *psublink = MakeNode(SubLink);
@@ -1106,7 +1106,7 @@ CTranslatorDXLToScalar::PsublinkFromDXLNodeQuantifiedSubquery
CTranslatorDXLToQuery trdxlquery(m_pmp, m_pmda, m_ulSegments);
CMappingColIdVarQuery *pmapcidvarquery = dynamic_cast<CMappingColIdVarQuery *>(pmapcidvar);
- CStateDXLToQuery *pstatedxltoquery = New(m_pmp) CStateDXLToQuery(m_pmp);
+ CStateDXLToQuery *pstatedxltoquery = GPOS_NEW(m_pmp) CStateDXLToQuery(m_pmp);
TEMap *ptemapCopy = CTranslatorUtils::PtemapCopy(m_pmp, pmapcidvarquery->Ptemap());
@@ -1143,7 +1143,7 @@ CTranslatorDXLToScalar::PsublinkFromDXLNodeQuantifiedSubquery
// clean up
ptemapCopy->Release();
- delete pstatedxltoquery;
+ GPOS_DELETE(pstatedxltoquery);
return psublink;
}
@@ -1168,7 +1168,7 @@ CTranslatorDXLToScalar::PsublinkFromDXLNodeScalarSubquery
CDXLNode *pdxlnChild = (*pdxlnSubquery)[0];
CTranslatorDXLToQuery trdxlquery(m_pmp, m_pmda, m_ulSegments);
- CStateDXLToQuery *pstatedxltoquery = New(m_pmp) CStateDXLToQuery(m_pmp);
+ CStateDXLToQuery *pstatedxltoquery = GPOS_NEW(m_pmp) CStateDXLToQuery(m_pmp);
CMappingColIdVarQuery *pmapcidvarquery = dynamic_cast<CMappingColIdVarQuery *>(pmapcidvar);
TEMap *ptemapCopy = CTranslatorUtils::PtemapCopy(m_pmp, pmapcidvarquery->Ptemap());
@@ -1184,7 +1184,7 @@ CTranslatorDXLToScalar::PsublinkFromDXLNodeScalarSubquery
// clean up
CRefCount::SafeRelease(ptemapCopy);
- delete pstatedxltoquery;
+ GPOS_DELETE(pstatedxltoquery);
SubLink *psublink = MakeNode(SubLink);
psublink->subLinkType = EXPR_SUBLINK;
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CTranslatorPlStmtToDXL.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CTranslatorPlStmtToDXL.cpp b/src/backend/gpopt/translate/CTranslatorPlStmtToDXL.cpp
index e81b069..7657d4d 100644
--- a/src/backend/gpopt/translate/CTranslatorPlStmtToDXL.cpp
+++ b/src/backend/gpopt/translate/CTranslatorPlStmtToDXL.cpp
@@ -87,7 +87,7 @@ CTranslatorPlStmtToDXL::CTranslatorPlStmtToDXL
m_pparammapping(pmapps)
{
GPOS_ASSERT(NULL != m_pplstmt);
- m_psctranslator = New(m_pmp)
+ m_psctranslator = GPOS_NEW(m_pmp)
CTranslatorScalarToDXL
(
m_pmp,
@@ -101,7 +101,7 @@ CTranslatorPlStmtToDXL::CTranslatorPlStmtToDXL
NULL, // CTE Mapping
NULL // pdrgpdxlnCTE
);
- m_phmuldxlnSharedScanProjLists = New(m_pmp) HMUlPdxln(m_pmp);
+ m_phmuldxlnSharedScanProjLists = GPOS_NEW(m_pmp) HMUlPdxln(m_pmp);
}
//---------------------------------------------------------------------------
@@ -115,7 +115,7 @@ CTranslatorPlStmtToDXL::CTranslatorPlStmtToDXL
CTranslatorPlStmtToDXL::~CTranslatorPlStmtToDXL()
{
m_phmuldxlnSharedScanProjLists->Release();
- delete m_psctranslator;
+ GPOS_DELETE(m_psctranslator);
}
//---------------------------------------------------------------------------
@@ -271,10 +271,10 @@ CTranslatorPlStmtToDXL::PdxlnHashjoinFromPlan
EdxlJoinType edxljt = CTranslatorUtils::EdxljtFromJoinType((phj->join).jointype);
// construct hash join operator
- CDXLPhysicalHashJoin *pdxlopHj = New(m_pmp) CDXLPhysicalHashJoin(m_pmp, edxljt);
+ CDXLPhysicalHashJoin *pdxlopHj = GPOS_NEW(m_pmp) CDXLPhysicalHashJoin(m_pmp, edxljt);
// construct hash join operator node
- CDXLNode *pdxlnHJ = New(m_pmp) CDXLNode(m_pmp, pdxlopHj);
+ CDXLNode *pdxlnHJ = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopHj);
pdxlnHJ->SetProperties(pdxlprop);
// translate left and right child
@@ -298,7 +298,7 @@ CTranslatorPlStmtToDXL::PdxlnHashjoinFromPlan
GPOS_ASSERT(pdxlnPrLRight->Pdxlop()->Edxlop() == EdxlopScalarProjectList);
// translate hash condition
- CDXLNode *pdxlnHashCondList = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarHashCondList(m_pmp));
+ CDXLNode *pdxlnHashCondList = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarHashCondList(m_pmp));
List *plHashClauses = NIL;
@@ -409,10 +409,10 @@ CTranslatorPlStmtToDXL::PdxlnNLJoinFromPlan
BOOL fIndexNLJ = IsA(pplan->righttree, IndexScan);
// construct nested loop join operator
- CDXLPhysicalNLJoin *pdxlnlj = New(m_pmp) CDXLPhysicalNLJoin(m_pmp, edxljt, fIndexNLJ);
+ CDXLPhysicalNLJoin *pdxlnlj = GPOS_NEW(m_pmp) CDXLPhysicalNLJoin(m_pmp, edxljt, fIndexNLJ);
// construct nested loop join operator node
- CDXLNode *pdxlnNLJ = New(m_pmp) CDXLNode(m_pmp, pdxlnlj);
+ CDXLNode *pdxlnNLJ = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlnlj);
pdxlnNLJ->SetProperties(pdxlprop);
// translate left and right child
@@ -497,10 +497,10 @@ CTranslatorPlStmtToDXL::PdxlnMergeJoinFromPlan
EdxlJoinType edxljt = CTranslatorUtils::EdxljtFromJoinType((pmj->join).jointype);
// construct hash join operator
- CDXLPhysicalMergeJoin *pdxlopMj = New(m_pmp) CDXLPhysicalMergeJoin(m_pmp, edxljt, pmj->unique_outer);
+ CDXLPhysicalMergeJoin *pdxlopMj = GPOS_NEW(m_pmp) CDXLPhysicalMergeJoin(m_pmp, edxljt, pmj->unique_outer);
// construct merge join operator node
- CDXLNode *pdxlnMJ = New(m_pmp) CDXLNode(m_pmp, pdxlopMj);
+ CDXLNode *pdxlnMJ = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopMj);
pdxlnMJ->SetProperties(pdxlprop);
// translate left and right child
@@ -524,7 +524,7 @@ CTranslatorPlStmtToDXL::PdxlnMergeJoinFromPlan
GPOS_ASSERT(pdxlnPrLRight->Pdxlop()->Edxlop() == EdxlopScalarProjectList);
// translate hash condition
- CDXLNode *pdxlnMergeCondList = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarMergeCondList(m_pmp));
+ CDXLNode *pdxlnMergeCondList = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarMergeCondList(m_pmp));
m_psctranslator->SetCallingPhysicalOpType(EpspotMergeJoin);
@@ -616,7 +616,7 @@ CTranslatorPlStmtToDXL::PdxlnResultFromPlan
GPOS_ASSERT(NULL != pdxlprop);
// construct result operator
- CDXLPhysicalResult *pdxlopResult = New(m_pmp) CDXLPhysicalResult(m_pmp);
+ CDXLPhysicalResult *pdxlopResult = GPOS_NEW(m_pmp) CDXLPhysicalResult(m_pmp);
GPOS_ASSERT(innerPlan(pnresult) == NULL && "Result node cannot have right child");
@@ -668,7 +668,7 @@ CTranslatorPlStmtToDXL::PdxlnResultFromPlan
);
// construct motion operator node
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopResult);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopResult);
pdxln->SetProperties(pdxlprop);
// add children in the right order
@@ -719,20 +719,20 @@ CTranslatorPlStmtToDXL::PdxlnMotionFromPlan
{
if (0 == pmotion->numOutputSegs)
{
- pdxlopMotion = New(m_pmp) CDXLPhysicalBroadcastMotion(m_pmp);
+ pdxlopMotion = GPOS_NEW(m_pmp) CDXLPhysicalBroadcastMotion(m_pmp);
}
else
{
- pdxlopMotion = New(m_pmp) CDXLPhysicalGatherMotion(m_pmp);
+ pdxlopMotion = GPOS_NEW(m_pmp) CDXLPhysicalGatherMotion(m_pmp);
}
}
else
{
- pdxlopMotion = New(m_pmp) CDXLPhysicalRedistributeMotion(m_pmp, false /*fDuplicateSensitive*/);
+ pdxlopMotion = GPOS_NEW(m_pmp) CDXLPhysicalRedistributeMotion(m_pmp, false /*fDuplicateSensitive*/);
}
- DrgPi *pdrgpiInputSegIds = New(m_pmp) DrgPi(m_pmp);
- DrgPi *pdrgpiOutputSegIds = New(m_pmp) DrgPi(m_pmp);
+ DrgPi *pdrgpiInputSegIds = GPOS_NEW(m_pmp) DrgPi(m_pmp);
+ DrgPi *pdrgpiOutputSegIds = GPOS_NEW(m_pmp) DrgPi(m_pmp);
TranslateMotionSegmentInfo(pmotion, pdrgpiInputSegIds, pdrgpiOutputSegIds);
@@ -740,7 +740,7 @@ CTranslatorPlStmtToDXL::PdxlnMotionFromPlan
pdxlopMotion->SetOutputSegIds(pdrgpiOutputSegIds);
// construct motion operator node
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopMotion);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopMotion);
pdxln->SetProperties(pdxlprop);
// translate child of motion node
@@ -844,7 +844,7 @@ CTranslatorPlStmtToDXL::PdxlnAggFromPlan
}
BOOL fStreamSafe = pagg->streaming;
- CDXLPhysicalAgg *pdxlopAgg = New(m_pmp) CDXLPhysicalAgg(m_pmp, edxlaggstr, fStreamSafe);
+ CDXLPhysicalAgg *pdxlopAgg = GPOS_NEW(m_pmp) CDXLPhysicalAgg(m_pmp, edxlaggstr, fStreamSafe);
// translate child of aggregate operator
Plan *pplanChild = (pagg->plan).lefttree;
@@ -881,7 +881,7 @@ CTranslatorPlStmtToDXL::PdxlnAggFromPlan
(0 < pagg->numCols && NULL != pagg->grpColIdx));
// translate output segment cols
- DrgPul *pdrgpulGroupingCols = New(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulGroupingCols = GPOS_NEW(m_pmp) DrgPul(m_pmp);
for(ULONG ul = 0; ul < (ULONG) pagg->numCols; ul++)
{
@@ -891,14 +891,14 @@ CTranslatorPlStmtToDXL::PdxlnAggFromPlan
CDXLNode *pdxlnGroupingCol = (*pdxlnPrLChild)[ulColIdx-1];
CDXLScalarProjElem *pdxlopPrEl = (CDXLScalarProjElem *) pdxlnGroupingCol->Pdxlop();
- ULONG *pulGroupingColId = New(m_pmp) ULONG(pdxlopPrEl->UlId());
+ ULONG *pulGroupingColId = GPOS_NEW(m_pmp) ULONG(pdxlopPrEl->UlId());
pdrgpulGroupingCols->Append(pulGroupingColId);
}
pdxlopAgg->SetGroupingCols(pdrgpulGroupingCols);
// construct aggregate operator node
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopAgg);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopAgg);
pdxln->SetProperties(pdxlprop);
// add children in the right order
@@ -962,7 +962,7 @@ CTranslatorPlStmtToDXL::PdxlnWindowFromPlan
const ULONG ulSize = (ULONG) pwindow->numPartCols;
// translate partition columns
- DrgPul *pdrgpulPartCols = New(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulPartCols = GPOS_NEW(m_pmp) DrgPul(m_pmp);
for(ULONG ul = 0; ul < ulSize; ul++)
{
ULONG ulColIdx = (ULONG) pwindow->partColIdx[ul];
@@ -971,17 +971,17 @@ CTranslatorPlStmtToDXL::PdxlnWindowFromPlan
CDXLNode *pdxlnPartCol = (*pdxlnPrLChild)[ulColIdx-1];
CDXLScalarProjElem *pdxlopPrEl = (CDXLScalarProjElem *) pdxlnPartCol->Pdxlop();
- ULONG *pulPartColId = New(m_pmp) ULONG(pdxlopPrEl->UlId());
+ ULONG *pulPartColId = GPOS_NEW(m_pmp) ULONG(pdxlopPrEl->UlId());
pdrgpulPartCols->Append(pulPartColId);
}
// add the window keys
- DrgPdxlwk *pdrgpdxlwk = New(m_pmp) DrgPdxlwk(m_pmp);
+ DrgPdxlwk *pdrgpdxlwk = GPOS_NEW(m_pmp) DrgPdxlwk(m_pmp);
ListCell *plcWindowKey = NULL;
ForEach (plcWindowKey, pwindow->windowKeys)
{
WindowKey *pwindowkey = (WindowKey *) lfirst(plcWindowKey);
- CDXLWindowKey *pdxlWindowKey = New(m_pmp) CDXLWindowKey(m_pmp);
+ CDXLWindowKey *pdxlWindowKey = GPOS_NEW(m_pmp) CDXLWindowKey(m_pmp);
CDXLNode *pdxlnSortColList = PdxlnSortingColListFromPlan
(
@@ -1010,8 +1010,8 @@ CTranslatorPlStmtToDXL::PdxlnWindowFromPlan
}
// construct window operator node
- CDXLPhysicalWindow *pdxlopWindow = New(m_pmp) CDXLPhysicalWindow(m_pmp, pdrgpulPartCols, pdrgpdxlwk);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopWindow);
+ CDXLPhysicalWindow *pdxlopWindow = GPOS_NEW(m_pmp) CDXLPhysicalWindow(m_pmp, pdrgpulPartCols, pdrgpdxlwk);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopWindow);
// extract plan properties
CDXLPhysicalProperties *pdxlprop = PdxlpropFromPlan(pplan);
@@ -1108,7 +1108,7 @@ CTranslatorPlStmtToDXL::PdxlnSortFromPlan
// TODO: antovl - Jan 19, 2011; currently GPDB supports only nullsLast behavior
GPOS_ASSERT(NULL == psort->nullsFirst);
- CDXLPhysicalSort *pdxlopSort = New(m_pmp) CDXLPhysicalSort(m_pmp, psort->noduplicates);
+ CDXLPhysicalSort *pdxlopSort = GPOS_NEW(m_pmp) CDXLPhysicalSort(m_pmp, psort->noduplicates);
// translate child of sort operator
Plan *pplanChild = (psort->plan).lefttree;
@@ -1147,8 +1147,8 @@ CTranslatorPlStmtToDXL::PdxlnSortFromPlan
// translate limit information
- CDXLNode *pdxlnLimitCount = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarLimitCount(m_pmp));
- CDXLNode *pdxlnLimitOffset = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarLimitOffset(m_pmp));
+ CDXLNode *pdxlnLimitCount = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarLimitCount(m_pmp));
+ CDXLNode *pdxlnLimitOffset = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarLimitOffset(m_pmp));
if (NULL != psort->limitCount)
{
@@ -1179,7 +1179,7 @@ CTranslatorPlStmtToDXL::PdxlnSortFromPlan
// construct sort operator node
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopSort);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopSort);
pdxln->SetProperties(pdxlprop);
// add children in the right order
@@ -1224,11 +1224,11 @@ CTranslatorPlStmtToDXL::PdxlnSubqueryScanFromPlan
CWStringDynamic *pstrSubqName = CDXLUtils::PstrFromSz(m_pmp, szSubqName);
// copy table name
- CMDName *pmdnameSubqScan = New(m_pmp) CMDName(m_pmp, pstrSubqName);
- delete pstrSubqName;
+ CMDName *pmdnameSubqScan = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrSubqName);
+ GPOS_DELETE(pstrSubqName);
// construct DXL subquery scan operator
- CDXLPhysicalSubqueryScan *pdxlopSubqScan = New(m_pmp) CDXLPhysicalSubqueryScan(m_pmp, pmdnameSubqScan);
+ CDXLPhysicalSubqueryScan *pdxlopSubqScan = GPOS_NEW(m_pmp) CDXLPhysicalSubqueryScan(m_pmp, pmdnameSubqScan);
// translate child of subquery operator
Plan *pplanChild = psubqscan->subplan;
@@ -1245,11 +1245,11 @@ CTranslatorPlStmtToDXL::PdxlnSubqueryScanFromPlan
// construct a fake table descriptor for the subquery scan
// since the project list and filter refer to the rtable rather than OUTER
// construct projection list and filter
- CDXLTableDescr *pdxltabdesc = New(m_pmp) CDXLTableDescr
+ CDXLTableDescr *pdxltabdesc = GPOS_NEW(m_pmp) CDXLTableDescr
(
m_pmp,
- New(m_pmp) CMDIdGPDB(CMDIdGPDB::m_mdidInvalidKey.OidObjectId()),
- New(m_pmp) CMDName(pmdnameSubqScan->Pstr()),
+ GPOS_NEW(m_pmp) CMDIdGPDB(CMDIdGPDB::m_mdidInvalidKey.OidObjectId()),
+ GPOS_NEW(m_pmp) CMDName(pmdnameSubqScan->Pstr()),
prte->checkAsUser
);
@@ -1273,22 +1273,22 @@ CTranslatorPlStmtToDXL::PdxlnSubqueryScanFromPlan
CWStringDynamic *pstrColName = CDXLUtils::PstrFromSz(m_pmp, szColName);
// copy string into column name
- CMDName *pmdnameColName = New(m_pmp) CMDName(m_pmp, pstrColName);
+ CMDName *pmdnameColName = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrColName);
- delete pstrColName;
+ GPOS_DELETE(pstrColName);
// get column id from the subplan's target list
CDXLNode *pdxlnPrEl = (*pdxlnPrLChild)[ulAttno-1];
ULONG ulId = ((CDXLScalarProjElem *) pdxlnPrEl->Pdxlop())->UlId();
// create a column descriptor for the column
- CDXLColDescr *pdxlcd = New(m_pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(m_pmp) CDXLColDescr
(
m_pmp,
pmdnameColName,
ulId,
ulAttno,
- New(m_pmp) CMDIdGPDB(CMDIdGPDB::m_mdidInvalidKey.OidObjectId()),
+ GPOS_NEW(m_pmp) CMDIdGPDB(CMDIdGPDB::m_mdidInvalidKey.OidObjectId()),
fColDropped
);
@@ -1315,7 +1315,7 @@ CTranslatorPlStmtToDXL::PdxlnSubqueryScanFromPlan
);
// construct sort operator node
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopSubqScan);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopSubqScan);
pdxln->SetProperties(pdxlprop);
// add children in the right order
@@ -1358,9 +1358,9 @@ CTranslatorPlStmtToDXL::PdxlnAppendFromPlan
GPOS_ASSERT(NULL != pdxlprop);
// construct DXL Append operator
- CDXLPhysicalAppend *pdxlopAppend = New(m_pmp) CDXLPhysicalAppend(m_pmp, pappend->isTarget, pappend->isZapped);
+ CDXLPhysicalAppend *pdxlopAppend = GPOS_NEW(m_pmp) CDXLPhysicalAppend(m_pmp, pappend->isTarget, pappend->isZapped);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopAppend);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopAppend);
pdxln->SetProperties(pdxlprop);
// translate first child of append operator so we can translate the project list
@@ -1427,33 +1427,33 @@ CTranslatorPlStmtToDXL::PdxlnResultFromFoldedFuncExpr
CMappingVarColId *pmapvarcolid
)
{
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
// construct a scalar operator for the expression
CDXLNode *pdxlnChild = m_psctranslator->PdxlnScOpFromExpr(pexpr, pmapvarcolid);
ULONG ulPrElId = m_pidgtor->UlNextId();
- CMDName *pmdnameAlias = New(m_pmp) CMDName(m_pmp, pstrAlias);
+ CMDName *pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
- CDXLNode *pdxlnPrEl = New(m_pmp) CDXLNode
+ CDXLNode *pdxlnPrEl = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarProjElem(m_pmp, ulPrElId, pmdnameAlias)
+ GPOS_NEW(m_pmp) CDXLScalarProjElem(m_pmp, ulPrElId, pmdnameAlias)
);
pdxlnPrEl->AddChild(pdxlnChild);
// add proj elem to proj list
pdxlnPrL->AddChild(pdxlnPrEl);
- CDXLPhysicalResult *pdxlopResult = New(m_pmp) CDXLPhysicalResult(m_pmp);
+ CDXLPhysicalResult *pdxlopResult = GPOS_NEW(m_pmp) CDXLPhysicalResult(m_pmp);
- CDXLNode *pdxlnFilter = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarFilter(m_pmp));
+ CDXLNode *pdxlnFilter = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarFilter(m_pmp));
pmapvarcolid->LoadProjectElements(DEFAULT_QUERY_LEVEL, OUTER, pdxlnPrL);
- CDXLNode *pdxlnOneTimeFilter = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarOneTimeFilter(m_pmp));
+ CDXLNode *pdxlnOneTimeFilter = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarOneTimeFilter(m_pmp));
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopResult);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopResult);
pdxln->SetProperties(pdxlprop);
pdxln->AddChild(pdxlnPrL);
@@ -1507,7 +1507,7 @@ CTranslatorPlStmtToDXL::PdxlnFunctionScanFromPlan
pdxlprop,
&mapvarcolid
);
- delete pstrAlias;
+ GPOS_DELETE(pstrAlias);
return pdxln;
}
@@ -1516,11 +1516,11 @@ CTranslatorPlStmtToDXL::PdxlnFunctionScanFromPlan
CMDIdGPDB *pmdidFunc = CTranslatorUtils::PmdidWithVersion(m_pmp, pfuncexpr->funcid);
CMDIdGPDB *pmdidRetType = CTranslatorUtils::PmdidWithVersion(m_pmp, pfuncexpr->funcresulttype);
- CWStringConst *pstrFunc = New(m_pmp) CWStringConst(m_pmp, pstrAlias->Wsz());
- delete pstrAlias;
- CDXLPhysicalTVF *pdxlop = New(m_pmp) CDXLPhysicalTVF(m_pmp, pmdidFunc, pmdidRetType, pstrFunc);
+ CWStringConst *pstrFunc = GPOS_NEW(m_pmp) CWStringConst(m_pmp, pstrAlias->Wsz());
+ GPOS_DELETE(pstrAlias);
+ CDXLPhysicalTVF *pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalTVF(m_pmp, pmdidFunc, pmdidRetType, pstrFunc);
- CDXLNode *pdxlnTVF = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxlnTVF = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// add properties
pdxlnTVF->SetProperties(pdxlprop);
@@ -1582,9 +1582,9 @@ CTranslatorPlStmtToDXL::PdxlnTblScanFromPlan
// get plan costs
CDXLPhysicalProperties *pdxlprop = PdxlpropFromPlan(pplan);
- CDXLPhysicalTableScan *pdxlopTS = New(m_pmp) CDXLPhysicalTableScan(m_pmp, pdxltabdesc);
+ CDXLPhysicalTableScan *pdxlopTS = GPOS_NEW(m_pmp) CDXLPhysicalTableScan(m_pmp, pdxltabdesc);
- CDXLNode *pdxlnTblScan = New(m_pmp) CDXLNode(m_pmp, pdxlopTS);
+ CDXLNode *pdxlnTblScan = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopTS);
pdxlnTblScan->SetProperties(pdxlprop);
// construct projection list and filter
@@ -1679,14 +1679,14 @@ CTranslatorPlStmtToDXL::PdxlnIndexScanFromGPDBIndexScan
GPOS_ASSERT(!fIndexOnlyScan);
//{
- // pdxlop = New(m_pmp) CDXLPhysicalIndexOnlyScan(m_pmp, pdxltabdesc, pdxlid, edxlissd);
+ // pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalIndexOnlyScan(m_pmp, pdxltabdesc, pdxlid, edxlissd);
//}
//else
//{
- pdxlop = New(m_pmp) CDXLPhysicalIndexScan(m_pmp, pdxltabdesc, pdxlid, edxlissd);
+ pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalIndexScan(m_pmp, pdxltabdesc, pdxlid, edxlissd);
//}
- CDXLNode *pdxlnIndexScan = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxlnIndexScan = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// get plan costs
CDXLPhysicalProperties *pdxlprop = PdxlpropFromPlan((Plan *)pindexscan);
@@ -1701,7 +1701,7 @@ CTranslatorPlStmtToDXL::PdxlnIndexScanFromGPDBIndexScan
}
// translate index condition
- CDXLNode *pdxlnIdxCondList = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarIndexCondList(m_pmp));
+ CDXLNode *pdxlnIdxCondList = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarIndexCondList(m_pmp));
ListCell *plcQual = NULL;
ForEach (plcQual, pindexscan->indexqual)
@@ -1763,8 +1763,8 @@ CTranslatorPlStmtToDXL::PdxlnLimitFromPlan
// get plan costs
CDXLPhysicalProperties *pdxlprop = PdxlpropFromPlan(pplan);
- CDXLPhysicalLimit *pdxlopLimit = New(m_pmp) CDXLPhysicalLimit(m_pmp);
- CDXLNode *pdxlnLimit = New(m_pmp) CDXLNode(m_pmp, pdxlopLimit);
+ CDXLPhysicalLimit *pdxlopLimit = GPOS_NEW(m_pmp) CDXLPhysicalLimit(m_pmp);
+ CDXLNode *pdxlnLimit = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopLimit);
pdxlnLimit->SetProperties(pdxlprop);
Plan *pplanChildPlan = outerPlan(plimit);
@@ -1787,8 +1787,8 @@ CTranslatorPlStmtToDXL::PdxlnLimitFromPlan
pdxlnLimit->AddChild(pdxlnPrL); // project list
pdxlnLimit->AddChild(pdxlnChildPlan);
- CDXLScalarLimitCount *pdxlopLimitCount = New(m_pmp) CDXLScalarLimitCount(m_pmp);
- CDXLNode *pdxlnLimitCount = New(m_pmp) CDXLNode(m_pmp, pdxlopLimitCount);
+ CDXLScalarLimitCount *pdxlopLimitCount = GPOS_NEW(m_pmp) CDXLScalarLimitCount(m_pmp);
+ CDXLNode *pdxlnLimitCount = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopLimitCount);
if(NULL != plimit->limitCount)
{
@@ -1801,8 +1801,8 @@ CTranslatorPlStmtToDXL::PdxlnLimitFromPlan
}
pdxlnLimit->AddChild(pdxlnLimitCount);
- CDXLScalarLimitOffset *pdxlopLimitOffset = New(m_pmp) CDXLScalarLimitOffset(m_pmp);
- CDXLNode *pdxlnLimitOffset = New(m_pmp) CDXLNode(m_pmp, pdxlopLimitOffset);
+ CDXLScalarLimitOffset *pdxlopLimitOffset = GPOS_NEW(m_pmp) CDXLScalarLimitOffset(m_pmp);
+ CDXLNode *pdxlnLimitOffset = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopLimitOffset);
if(NULL != plimit->limitOffset)
{
@@ -1843,15 +1843,15 @@ CTranslatorPlStmtToDXL::PdxlnMaterializeFromPlan
if (SHARE_NOTSHARED == pmat->share_type)
{
// materialize node is not shared
- pdxlopMat = New(m_pmp) CDXLPhysicalMaterialize(m_pmp, pmat->cdb_strict);
+ pdxlopMat = GPOS_NEW(m_pmp) CDXLPhysicalMaterialize(m_pmp, pmat->cdb_strict);
}
else
{
// create a shared materialize node
- pdxlopMat = New(m_pmp) CDXLPhysicalMaterialize(m_pmp, pmat->cdb_strict, pmat->share_id, pmat->driver_slice, pmat->nsharer_xslice);
+ pdxlopMat = GPOS_NEW(m_pmp) CDXLPhysicalMaterialize(m_pmp, pmat->cdb_strict, pmat->share_id, pmat->driver_slice, pmat->nsharer_xslice);
}
- CDXLNode *pdxlnMaterialize = New(m_pmp) CDXLNode(m_pmp, pdxlopMat);
+ CDXLNode *pdxlnMaterialize = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopMat);
pdxlnMaterialize->SetProperties(pdxlprop);
Plan *pplanChildPlan = outerPlan(pmat);
@@ -1910,8 +1910,8 @@ CTranslatorPlStmtToDXL::PdxlnSharedScanFromPlan
CDXLPhysicalSharedScan *pdxlopShScan = NULL;
CDXLSpoolInfo *pspoolinfo = PspoolinfoFromSharedScan(pshscan);
- pdxlopShScan = New(m_pmp) CDXLPhysicalSharedScan(m_pmp, pspoolinfo);
- CDXLNode *pdxlnSharedScan = New(m_pmp) CDXLNode(m_pmp, pdxlopShScan);
+ pdxlopShScan = GPOS_NEW(m_pmp) CDXLPhysicalSharedScan(m_pmp, pspoolinfo);
+ CDXLNode *pdxlnSharedScan = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopShScan);
pdxlnSharedScan->SetProperties(pdxlprop);
Plan *pplanChildPlan = outerPlan(pshscan);
@@ -1958,7 +1958,7 @@ CTranslatorPlStmtToDXL::PdxlnSharedScanFromPlan
if (NULL != pplanChildPlan)
{
// first encounter of this shared scan id: store the translated proj list
- ULONG *pulSharedScanId = New(m_pmp) ULONG(pshscan->share_id);
+ ULONG *pulSharedScanId = GPOS_NEW(m_pmp) ULONG(pshscan->share_id);
pdxlnPrL->AddRef();
#ifdef GPOS_DEBUG
@@ -2007,9 +2007,9 @@ CTranslatorPlStmtToDXL::PdxlnSequence
GPOS_ASSERT(NULL != pdxlprop);
// construct DXL sequence operator
- CDXLPhysicalSequence *pdxlop = New(m_pmp) CDXLPhysicalSequence(m_pmp);
+ CDXLPhysicalSequence *pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalSequence(m_pmp);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
pdxln->SetProperties(pdxlprop);
// translate last child of sequence operator so we can translate the project list
@@ -2082,9 +2082,9 @@ CTranslatorPlStmtToDXL::PdxlnDynamicTableScan
CDXLTableDescr *pdxltabdesc = CTranslatorUtils::Pdxltabdesc(m_pmp, m_pmda, m_pidgtor, prte);
- CDXLPhysicalDynamicTableScan *pdxlop = New(m_pmp) CDXLPhysicalDynamicTableScan(m_pmp, pdxltabdesc, pdts->partIndex, pdts->partIndexPrintable);
+ CDXLPhysicalDynamicTableScan *pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalDynamicTableScan(m_pmp, pdxltabdesc, pdts->partIndex, pdts->partIndexPrintable);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
pdxln->SetProperties(pdxlprop);
// construct projection list
@@ -2188,7 +2188,7 @@ CTranslatorPlStmtToDXL::PdxlnPrLFromTL
CMappingVarColId *pmapvarcolid
)
{
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
ListCell *plcte = NULL;
// construct a proj list node for each entry in the target list
@@ -2208,9 +2208,9 @@ CTranslatorPlStmtToDXL::PdxlnPrLFromTL
if (NULL != pte->resname)
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(m_pmp, pte->resname);
- pmdnameAlias = New(m_pmp) CMDName(m_pmp, pstrAlias);
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
// CName constructor copies string
- delete pstrAlias;
+ GPOS_DELETE(pstrAlias);
}
if (IsA(pte->expr, Var))
@@ -2223,7 +2223,7 @@ CTranslatorPlStmtToDXL::PdxlnPrLFromTL
if (NULL == pte->resname)
{
// no alias provided - create a copy of the original column name
- pmdnameAlias = New(m_pmp) CMDName
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName
(
m_pmp,
pdxlopIdent->Pdxlcr()->Pmdname()->Pstr()
@@ -2239,17 +2239,17 @@ CTranslatorPlStmtToDXL::PdxlnPrLFromTL
{
// no column name - make up one
CWStringConst strUnnamedCol(GPOS_WSZ_LIT("?column?"));
- pmdnameAlias = New(m_pmp) CMDName(m_pmp, &strUnnamedCol);
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, &strUnnamedCol);
}
}
GPOS_ASSERT(NULL != pmdnameAlias);
// construct a projection element operator
- pdxlopPrEl = New(m_pmp) CDXLScalarProjElem(m_pmp, ulPrElId, pmdnameAlias);
+ pdxlopPrEl = GPOS_NEW(m_pmp) CDXLScalarProjElem(m_pmp, ulPrElId, pmdnameAlias);
// create the DXL node holding the proj elem
- CDXLNode *pdxlnPrEl = New(m_pmp) CDXLNode(m_pmp, pdxlopPrEl);
+ CDXLNode *pdxlnPrEl = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopPrEl);
pdxlnPrEl->AddChild(pdxlnChild);
// add proj elem to proj list
@@ -2276,10 +2276,10 @@ CTranslatorPlStmtToDXL::PdxlpropFromPlan
const Plan *pplan
)
{
- CWStringDynamic *pstrTotalCost = New(m_pmp) CWStringDynamic(m_pmp);
- CWStringDynamic *pstrStartupCost = New(m_pmp) CWStringDynamic(m_pmp);
- CWStringDynamic *pstrRows = New(m_pmp) CWStringDynamic(m_pmp);
- CWStringDynamic *pstrWidth = New(m_pmp) CWStringDynamic(m_pmp);
+ CWStringDynamic *pstrTotalCost = GPOS_NEW(m_pmp) CWStringDynamic(m_pmp);
+ CWStringDynamic *pstrStartupCost = GPOS_NEW(m_pmp) CWStringDynamic(m_pmp);
+ CWStringDynamic *pstrRows = GPOS_NEW(m_pmp) CWStringDynamic(m_pmp);
+ CWStringDynamic *pstrWidth = GPOS_NEW(m_pmp) CWStringDynamic(m_pmp);
const WCHAR wszFormat[] = GPOS_WSZ_LIT("%.2f");
pstrTotalCost->AppendFormat(wszFormat, pplan->total_cost);
@@ -2287,14 +2287,14 @@ CTranslatorPlStmtToDXL::PdxlpropFromPlan
pstrStartupCost->AppendFormat(wszFormat, pplan->startup_cost);
pstrRows->AppendFormat(wszFormat, pplan->plan_rows);
- CDXLOperatorCost *pdxlopcost = New(m_pmp) CDXLOperatorCost
+ CDXLOperatorCost *pdxlopcost = GPOS_NEW(m_pmp) CDXLOperatorCost
(
pstrStartupCost,
pstrTotalCost,
pstrRows,
pstrWidth
);
- CDXLPhysicalProperties *pdxlprop = New(m_pmp) CDXLPhysicalProperties(pdxlopcost);
+ CDXLPhysicalProperties *pdxlprop = GPOS_NEW(m_pmp) CDXLPhysicalProperties(pdxlopcost);
return pdxlprop;
}
@@ -2321,7 +2321,7 @@ CTranslatorPlStmtToDXL::PdxlnHashExprLFromList
GPOS_ASSERT(NULL != plHashExprTypes);
GPOS_ASSERT(gpdb::UlListLength(plHashExpr) == gpdb::UlListLength(plHashExprTypes));
- CDXLNode *pdxlnHashExprList = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarHashExprList(m_pmp));
+ CDXLNode *pdxlnHashExprList = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarHashExprList(m_pmp));
ListCell *plcHashExpr = NULL;
ListCell *plcHashExprType = NULL;
@@ -2335,7 +2335,7 @@ CTranslatorPlStmtToDXL::PdxlnHashExprLFromList
// construct a DXL hash expression node from the hash expression type id and the translated expression
CMDIdGPDB *pmdidExprType = CTranslatorUtils::PmdidWithVersion(m_pmp, oid);
- CDXLNode *pdxlnHashExpr = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarHashExpr(m_pmp, pmdidExprType));
+ CDXLNode *pdxlnHashExpr = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarHashExpr(m_pmp, pmdidExprType));
CMappingVarColId mapvarcolid(m_pmp);
@@ -2371,8 +2371,8 @@ CTranslatorPlStmtToDXL::PdxlnSortingColListFromPlan
const CDXLNode *pdxlnPrL
)
{
- CDXLScalarSortColList *pdxlopSortColList = New(m_pmp) CDXLScalarSortColList(m_pmp);
- CDXLNode *pdxlnSortColList = New(m_pmp) CDXLNode(m_pmp, pdxlopSortColList);
+ CDXLScalarSortColList *pdxlopSortColList = GPOS_NEW(m_pmp) CDXLScalarSortColList(m_pmp);
+ CDXLNode *pdxlnSortColList = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopSortColList);
if (0 == ulNumCols)
{
@@ -2404,16 +2404,16 @@ CTranslatorPlStmtToDXL::PdxlnSortingColListFromPlan
// TODO: antovl - Jan 19, 2011; read nullsFirst from the plan node;
// currently GPDB does not support this
- CDXLScalarSortCol *pdxlopSortCol = New(m_pmp) CDXLScalarSortCol
+ CDXLScalarSortCol *pdxlopSortCol = GPOS_NEW(m_pmp) CDXLScalarSortCol
(
m_pmp,
ulSortColId,
pmdidSortOp,
- New(m_pmp) CWStringConst(pstrSortOpName->Wsz()),
+ GPOS_NEW(m_pmp) CWStringConst(pstrSortOpName->Wsz()),
false // nullsFirst
);
- CDXLNode *pdxlnSortCol = New(m_pmp) CDXLNode(m_pmp, pdxlopSortCol);
+ CDXLNode *pdxlnSortCol = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopSortCol);
pdxlnSortColList->AddChild(pdxlnSortCol);
}
@@ -2447,7 +2447,7 @@ CTranslatorPlStmtToDXL::TranslateMotionSegmentInfo
if (pChildFlow->flotype == FLOW_SINGLETON)
{
// only one segment sends data
- INT *piInputSegId = New(m_pmp) INT(pChildFlow->segindex);
+ INT *piInputSegId = GPOS_NEW(m_pmp) INT(pChildFlow->segindex);
pdrgpiInputSegIds->Append(piInputSegId);
}
else
@@ -2455,7 +2455,7 @@ CTranslatorPlStmtToDXL::TranslateMotionSegmentInfo
// all segments send data
for (ULONG ul = 0; ul < ulSegmentCount; ul++)
{
- INT *piInputSegId = New(m_pmp) INT(ul);
+ INT *piInputSegId = GPOS_NEW(m_pmp) INT(ul);
pdrgpiInputSegIds->Append(piInputSegId );
}
}
@@ -2468,7 +2468,7 @@ CTranslatorPlStmtToDXL::TranslateMotionSegmentInfo
for(ULONG ul = 0; ul < (ULONG) pmotion->numOutputSegs; ul++)
{
- INT *piSegId = New(m_pmp) INT(pmotion->outputSegIdx[ul]);
+ INT *piSegId = GPOS_NEW(m_pmp) INT(pmotion->outputSegIdx[ul]);
pdrgpiOutputSegIds->Append(piSegId);
}
}
@@ -2477,7 +2477,7 @@ CTranslatorPlStmtToDXL::TranslateMotionSegmentInfo
// gather motion
GPOS_ASSERT(1 == pmotion->numOutputSegs);
- INT *piOutputSegId = New(m_pmp) INT(pmotion->outputSegIdx[0]);
+ INT *piOutputSegId = GPOS_NEW(m_pmp) INT(pmotion->outputSegIdx[0]);
pdrgpiOutputSegIds->Append(piOutputSegId);
}
else
@@ -2485,7 +2485,7 @@ CTranslatorPlStmtToDXL::TranslateMotionSegmentInfo
// broadcast motion
for (ULONG ul = 0; ul < ulSegmentCount; ul++)
{
- INT *piOutputSegId = New(m_pmp) INT(ul);
+ INT *piOutputSegId = GPOS_NEW(m_pmp) INT(ul);
pdrgpiOutputSegIds->Append(piOutputSegId);
}
}
@@ -2534,7 +2534,7 @@ CTranslatorPlStmtToDXL::PspoolinfoFromSharedScan
fMultiSlice = true;
}
- CDXLSpoolInfo *pspoolinfo = New(m_pmp) CDXLSpoolInfo(pshscan->share_id, edxlsptype, fMultiSlice, pshscan->driver_slice);
+ CDXLSpoolInfo *pspoolinfo = GPOS_NEW(m_pmp) CDXLSpoolInfo(pshscan->share_id, edxlsptype, fMultiSlice, pshscan->driver_slice);
return pspoolinfo;
}
[3/4] incubator-hawq git commit: HAWQ-246. Refactor and cleanup of
memory management of the new optimizer.
Posted by en...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/9b65a5ad/src/backend/gpopt/translate/CTranslatorQueryToDXL.cpp
----------------------------------------------------------------------
diff --git a/src/backend/gpopt/translate/CTranslatorQueryToDXL.cpp b/src/backend/gpopt/translate/CTranslatorQueryToDXL.cpp
index 292a98b..946e0ae 100644
--- a/src/backend/gpopt/translate/CTranslatorQueryToDXL.cpp
+++ b/src/backend/gpopt/translate/CTranslatorQueryToDXL.cpp
@@ -173,9 +173,9 @@ CTranslatorQueryToDXL::CTranslatorQueryToDXL
GPOS_ASSERT(NULL != pquery);
CheckSupportedCmdType(pquery);
- m_phmulCTEEntries = New(m_pmp) HMUlCTEListEntry(m_pmp);
- m_pdrgpdxlnCTE = New(m_pmp) DrgPdxln(m_pmp);
- m_phmulfCTEProducers = New(m_pmp) HMUlF(m_pmp);
+ m_phmulCTEEntries = GPOS_NEW(m_pmp) HMUlCTEListEntry(m_pmp);
+ m_pdrgpdxlnCTE = GPOS_NEW(m_pmp) DrgPdxln(m_pmp);
+ m_phmulfCTEProducers = GPOS_NEW(m_pmp) HMUlF(m_pmp);
if (NULL != phmulCTEEntries)
{
@@ -209,7 +209,7 @@ CTranslatorQueryToDXL::CTranslatorQueryToDXL
#ifdef GPOS_DEBUG
BOOL fRes =
#endif
- m_phmulCTEEntries->FInsert(New(pmp) ULONG(ulCTEQueryLevel), pctelistentry);
+ m_phmulCTEEntries->FInsert(GPOS_NEW(pmp) ULONG(ulCTEQueryLevel), pctelistentry);
GPOS_ASSERT(fRes);
}
}
@@ -229,7 +229,7 @@ CTranslatorQueryToDXL::CTranslatorQueryToDXL
ConstructCTEProducerList(m_pquery->cteList, ulQueryLevel);
}
- m_psctranslator = New(m_pmp) CTranslatorScalarToDXL
+ m_psctranslator = GPOS_NEW(m_pmp) CTranslatorScalarToDXL
(
m_pmp,
m_pmda,
@@ -266,7 +266,7 @@ CTranslatorQueryToDXL::PtrquerytodxlInstance
HMUlCTEListEntry *phmulCTEEntries
)
{
- return New(pmp) CTranslatorQueryToDXL
+ return GPOS_NEW(pmp) CTranslatorQueryToDXL
(
pmp,
pmda,
@@ -290,8 +290,8 @@ CTranslatorQueryToDXL::PtrquerytodxlInstance
//---------------------------------------------------------------------------
CTranslatorQueryToDXL::~CTranslatorQueryToDXL()
{
- delete m_psctranslator;
- delete m_pmapvarcolid;
+ GPOS_DELETE(m_psctranslator);
+ GPOS_DELETE(m_pmapvarcolid);
gpdb::GPDBFree(m_pquery);
m_phmulCTEEntries->Release();
m_pdrgpdxlnCTE->Release();
@@ -504,8 +504,8 @@ CTranslatorQueryToDXL::PdxlnFromQueryInternal()
CTranslatorUtils::CheckRTEPermissions(m_pquery->rtable);
CDXLNode *pdxlnChild = NULL;
- HMIUl *phmiulSortGroupColsColId = New(m_pmp) HMIUl(m_pmp);
- HMIUl *phmiulOutputCols = New(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulSortGroupColsColId = GPOS_NEW(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulOutputCols = GPOS_NEW(m_pmp) HMIUl(m_pmp);
// construct CTEAnchor operators for the CTEs defined at the top level
CDXLNode *pdxlnCTEAnchorTop = NULL;
@@ -561,7 +561,7 @@ CTranslatorQueryToDXL::PdxlnFromQueryInternal()
if (NULL == m_pquery->targetList)
{
- m_pdrgpdxlnQueryOutput = New(m_pmp) DrgPdxln(m_pmp);
+ m_pdrgpdxlnQueryOutput = GPOS_NEW(m_pmp) DrgPdxln(m_pmp);
}
else
{
@@ -714,10 +714,10 @@ CTranslatorQueryToDXL::PdxlnInsert()
if (ulLenNonDroppedCols > ulLenTL)
{
// missing target list entries
- pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
}
- DrgPul *pdrgpulSource = New(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulSource = GPOS_NEW(m_pmp) DrgPul(m_pmp);
ULONG ulPosTL = 0;
for (ULONG ul = 0; ul < ulLenTblCols; ul++)
@@ -741,7 +741,7 @@ CTranslatorQueryToDXL::PdxlnInsert()
{
CDXLNode *pdxlnCol = (*m_pdrgpdxlnQueryOutput)[ulPosTL];
CDXLScalarIdent *pdxlopIdent = CDXLScalarIdent::PdxlopConvert(pdxlnCol->Pdxlop());
- pdrgpulSource->Append(New(m_pmp) ULONG(pdxlopIdent->Pdxlcr()->UlID()));
+ pdrgpulSource->Append(GPOS_NEW(m_pmp) ULONG(pdxlopIdent->Pdxlcr()->UlID()));
ulPosTL++;
continue;
}
@@ -752,22 +752,22 @@ CTranslatorQueryToDXL::PdxlnInsert()
CDXLNode *pdxlnPrE = CTranslatorUtils::PdxlnPrElNull(m_pmp, m_pmda, m_pidgtorCol, pmdcol);
ULONG ulColId = CDXLScalarProjElem::PdxlopConvert(pdxlnPrE->Pdxlop())->UlId();
pdxlnPrL->AddChild(pdxlnPrE);
- pdrgpulSource->Append(New(m_pmp) ULONG(ulColId));
+ pdrgpulSource->Append(GPOS_NEW(m_pmp) ULONG(ulColId));
}
- CDXLLogicalInsert *pdxlopInsert = New(m_pmp) CDXLLogicalInsert(m_pmp, pdxltabdesc, pdrgpulSource);
+ CDXLLogicalInsert *pdxlopInsert = GPOS_NEW(m_pmp) CDXLLogicalInsert(m_pmp, pdxltabdesc, pdrgpulSource);
if (NULL != pdxlnPrL)
{
GPOS_ASSERT(0 < pdxlnPrL->UlArity());
- CDXLNode *pdxlnProject = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalProject(m_pmp));
+ CDXLNode *pdxlnProject = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp));
pdxlnProject->AddChild(pdxlnPrL);
pdxlnProject->AddChild(pdxlnQuery);
pdxlnQuery = pdxlnProject;
}
- return New(m_pmp) CDXLNode(m_pmp, pdxlopInsert, pdxlnQuery);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopInsert, pdxlnQuery);
}
//---------------------------------------------------------------------------
@@ -791,12 +791,12 @@ CTranslatorQueryToDXL::PdxlnCTAS()
CMDName *pmdnameRel = CDXLUtils::PmdnameFromSz(m_pmp, pintocl->rel->relname);
- DrgPdxlcd *pdrgpdxlcd = New(m_pmp) DrgPdxlcd(m_pmp);
+ DrgPdxlcd *pdrgpdxlcd = GPOS_NEW(m_pmp) DrgPdxlcd(m_pmp);
const ULONG ulColumns = gpdb::UlListLength(m_pquery->targetList);
- DrgPul *pdrgpulSource = New(m_pmp) DrgPul(m_pmp);
- DrgPi* pdrgpiVarTypMod = New(m_pmp) DrgPi(m_pmp);
+ DrgPul *pdrgpulSource = GPOS_NEW(m_pmp) DrgPul(m_pmp);
+ DrgPi* pdrgpiVarTypMod = GPOS_NEW(m_pmp) DrgPi(m_pmp);
List *plColnames = pintocl->colNames;
for (ULONG ul = 0; ul < ulColumns; ul++)
@@ -808,11 +808,11 @@ CTranslatorQueryToDXL::PdxlnCTAS()
}
AttrNumber iResno = pte->resno;
int iVarTypMod = gpdb::IExprTypeMod((Node*)pte->expr);
- pdrgpiVarTypMod->Append(New(m_pmp) INT(iVarTypMod));
+ pdrgpiVarTypMod->Append(GPOS_NEW(m_pmp) INT(iVarTypMod));
CDXLNode *pdxlnCol = (*m_pdrgpdxlnQueryOutput)[ul];
CDXLScalarIdent *pdxlopIdent = CDXLScalarIdent::PdxlopConvert(pdxlnCol->Pdxlop());
- pdrgpulSource->Append(New(m_pmp) ULONG(pdxlopIdent->Pdxlcr()->UlID()));
+ pdrgpulSource->Append(GPOS_NEW(m_pmp) ULONG(pdxlopIdent->Pdxlcr()->UlID()));
CMDName *pmdnameCol = NULL;
if (NULL != plColnames && ul < gpdb::UlListLength(plColnames))
@@ -822,13 +822,13 @@ CTranslatorQueryToDXL::PdxlnCTAS()
}
else
{
- pmdnameCol = New(m_pmp) CMDName(m_pmp, pdxlopIdent->Pdxlcr()->Pmdname()->Pstr());
+ pmdnameCol = GPOS_NEW(m_pmp) CMDName(m_pmp, pdxlopIdent->Pdxlcr()->Pmdname()->Pstr());
}
GPOS_ASSERT(NULL != pmdnameCol);
IMDId *pmdid = pdxlopIdent->PmdidType();
pmdid->AddRef();
- CDXLColDescr *pdxlcd = New(m_pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(m_pmp) CDXLColDescr
(
m_pmp,
pmdnameCol,
@@ -849,13 +849,13 @@ CTranslatorQueryToDXL::PdxlnCTAS()
if (IMDRelation::EreldistrHash == ereldistrpolicy)
{
- pdrgpulDistr = New(m_pmp) DrgPul(m_pmp);
+ pdrgpulDistr = GPOS_NEW(m_pmp) DrgPul(m_pmp);
for (ULONG ul = 0; ul < (ULONG) m_pquery->intoPolicy->nattrs; ul++)
{
AttrNumber attno = m_pquery->intoPolicy->attrs[ul];
GPOS_ASSERT(0 < attno);
- pdrgpulDistr->Append(New(m_pmp) ULONG(attno - 1));
+ pdrgpulDistr->Append(GPOS_NEW(m_pmp) ULONG(attno - 1));
}
}
}
@@ -869,7 +869,7 @@ CTranslatorQueryToDXL::PdxlnCTAS()
// TODO: antova - Mar 5, 2014; reserve an OID
OID oid = 1;
- CMDIdGPDB *pmdid = New(m_pmp) CMDIdGPDBCtas(oid);
+ CMDIdGPDB *pmdid = GPOS_NEW(m_pmp) CMDIdGPDBCtas(oid);
CMDName *pmdnameTableSpace = NULL;
if (NULL != pintocl->tableSpaceName)
@@ -889,14 +889,14 @@ CTranslatorQueryToDXL::PdxlnCTAS()
CDXLCtasStorageOptions::DrgPctasOpt *pdrgpctasopt = Pdrgpctasopt(pintocl->options, &erelstorage);
BOOL fHasOids = gpdb::FInterpretOidsOption(pintocl->options);
- CDXLLogicalCTAS *pdxlopCTAS = New(m_pmp) CDXLLogicalCTAS
+ CDXLLogicalCTAS *pdxlopCTAS = GPOS_NEW(m_pmp) CDXLLogicalCTAS
(
m_pmp,
pmdid,
pmdnameSchema,
pmdnameRel,
pdrgpdxlcd,
- New(m_pmp) CDXLCtasStorageOptions(pmdnameTableSpace, ectascommit, pdrgpctasopt),
+ GPOS_NEW(m_pmp) CDXLCtasStorageOptions(pmdnameTableSpace, ectascommit, pdrgpctasopt),
ereldistrpolicy,
pdrgpulDistr,
pintocl->rel->istemp,
@@ -906,7 +906,7 @@ CTranslatorQueryToDXL::PdxlnCTAS()
pdrgpiVarTypMod
);
- return New(m_pmp) CDXLNode(m_pmp, pdxlopCTAS, pdxlnQuery);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopCTAS, pdxlnQuery);
}
//---------------------------------------------------------------------------
@@ -931,7 +931,7 @@ CTranslatorQueryToDXL::Pdrgpctasopt
GPOS_ASSERT(NULL != perelstoragetype);
- CDXLCtasStorageOptions::DrgPctasOpt *pdrgpctasopt = New(m_pmp) CDXLCtasStorageOptions::DrgPctasOpt(m_pmp);
+ CDXLCtasStorageOptions::DrgPctasOpt *pdrgpctasopt = GPOS_NEW(m_pmp) CDXLCtasStorageOptions::DrgPctasOpt(m_pmp);
ListCell *plc = NULL;
BOOL fAO = false;
BOOL fAOCO = false;
@@ -954,7 +954,7 @@ CTranslatorQueryToDXL::Pdrgpctasopt
if (fNullArg)
{
// we represent null options as an empty arg string and set the IsNull flag on
- pstrValue = New(m_pmp) CWStringDynamic(m_pmp);
+ pstrValue = GPOS_NEW(m_pmp) CWStringDynamic(m_pmp);
}
else
{
@@ -985,7 +985,7 @@ CTranslatorQueryToDXL::Pdrgpctasopt
}
CDXLCtasStorageOptions::CDXLCtasOption *pdxlctasopt =
- New(m_pmp) CDXLCtasStorageOptions::CDXLCtasOption(argType, pstrName, pstrValue, fNullArg);
+ GPOS_NEW(m_pmp) CDXLCtasStorageOptions::CDXLCtasOption(argType, pstrName, pstrValue, fNullArg);
pdrgpctasopt->Append(pdxlctasopt);
}
if (fAOCO)
@@ -1107,7 +1107,7 @@ CTranslatorQueryToDXL::PdxlnDelete()
ULONG ulSegmentId = 0;
GetCtidAndSegmentId(&ulCtid, &ulSegmentId);
- DrgPul *pdrgpulDelete = New(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulDelete = GPOS_NEW(m_pmp) DrgPul(m_pmp);
const ULONG ulRelColumns = pmdrel->UlColumns();
for (ULONG ul = 0; ul < ulRelColumns; ul++)
@@ -1119,12 +1119,12 @@ CTranslatorQueryToDXL::PdxlnDelete()
}
ULONG ulColId = CTranslatorUtils::UlColId(m_ulQueryLevel, m_pquery->resultRelation, pmdcol->IAttno(), pmdcol->PmdidType(), m_pmapvarcolid);
- pdrgpulDelete->Append(New(m_pmp) ULONG(ulColId));
+ pdrgpulDelete->Append(GPOS_NEW(m_pmp) ULONG(ulColId));
}
- CDXLLogicalDelete *pdxlopdelete = New(m_pmp) CDXLLogicalDelete(m_pmp, pdxltabdesc, ulCtid, ulSegmentId, pdrgpulDelete);
+ CDXLLogicalDelete *pdxlopdelete = GPOS_NEW(m_pmp) CDXLLogicalDelete(m_pmp, pdxltabdesc, ulCtid, ulSegmentId, pdrgpulDelete);
- return New(m_pmp) CDXLNode(m_pmp, pdxlopdelete, pdxlnQuery);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopdelete, pdxlnQuery);
}
//---------------------------------------------------------------------------
@@ -1174,8 +1174,8 @@ CTranslatorQueryToDXL::PdxlnUpdate()
HMIUl *phmiulUpdateCols = PhmiulUpdateCols();
const ULONG ulRelColumns = pmdrel->UlColumns();
- DrgPul *pdrgpulInsert = New(m_pmp) DrgPul(m_pmp);
- DrgPul *pdrgpulDelete = New(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulInsert = GPOS_NEW(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulDelete = GPOS_NEW(m_pmp) DrgPul(m_pmp);
for (ULONG ul = 0; ul < ulRelColumns; ul++)
{
@@ -1194,20 +1194,20 @@ CTranslatorQueryToDXL::PdxlnUpdate()
// otherwise get the column id created by the child query
if (NULL != pulColId)
{
- pdrgpulInsert->Append(New(m_pmp) ULONG(*pulColId));
+ pdrgpulInsert->Append(GPOS_NEW(m_pmp) ULONG(*pulColId));
}
else
{
- pdrgpulInsert->Append(New(m_pmp) ULONG(ulColId));
+ pdrgpulInsert->Append(GPOS_NEW(m_pmp) ULONG(ulColId));
}
- pdrgpulDelete->Append(New(m_pmp) ULONG(ulColId));
+ pdrgpulDelete->Append(GPOS_NEW(m_pmp) ULONG(ulColId));
}
phmiulUpdateCols->Release();
- CDXLLogicalUpdate *pdxlopupdate = New(m_pmp) CDXLLogicalUpdate(m_pmp, pdxltabdesc, ulCtidColId, ulSegmentIdColId, pdrgpulDelete, pdrgpulInsert, fHasOids, ulTupleOidColId);
+ CDXLLogicalUpdate *pdxlopupdate = GPOS_NEW(m_pmp) CDXLLogicalUpdate(m_pmp, pdxltabdesc, ulCtidColId, ulSegmentIdColId, pdrgpulDelete, pdrgpulInsert, fHasOids, ulTupleOidColId);
- return New(m_pmp) CDXLNode(m_pmp, pdxlopupdate, pdxlnQuery);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopupdate, pdxlnQuery);
}
//---------------------------------------------------------------------------
@@ -1222,7 +1222,7 @@ HMIUl *
CTranslatorQueryToDXL::PhmiulUpdateCols()
{
GPOS_ASSERT((ULONG)gpdb::UlListLength(m_pquery->targetList) == m_pdrgpdxlnQueryOutput->UlLength());
- HMIUl *phmiulUpdateCols = New(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulUpdateCols = GPOS_NEW(m_pmp) HMIUl(m_pmp);
ListCell *plc = NULL;
ULONG ul = 0;
@@ -1352,8 +1352,8 @@ CTranslatorQueryToDXL::PdxlwfLeadLag
CDXLNode *pdxlnTrailEdge = NULL;
if (NULL == pdxlnOffset)
{
- pdxlnLeadEdge = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, true /* fLeading */, edxlfbLead));
- pdxlnTrailEdge = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, false /* fLeading */, edxlfbTrail));
+ pdxlnLeadEdge = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, true /* fLeading */, edxlfbLead));
+ pdxlnTrailEdge = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, false /* fLeading */, edxlfbTrail));
pdxlnLeadEdge->AddChild(CTranslatorUtils::PdxlnInt4Const(m_pmp, m_pmda, 1 /*iVal*/));
pdxlnTrailEdge->AddChild(CTranslatorUtils::PdxlnInt4Const(m_pmp, m_pmda, 1 /*iVal*/));
@@ -1374,8 +1374,8 @@ CTranslatorQueryToDXL::PdxlwfLeadLag
edxlfbTrail = EdxlfbDelayedBoundedPreceding;
}
}
- pdxlnLeadEdge = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, true /* fLeading */, edxlfbLead));
- pdxlnTrailEdge = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, false /* fLeading */, edxlfbTrail));
+ pdxlnLeadEdge = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, true /* fLeading */, edxlfbLead));
+ pdxlnTrailEdge = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarWindowFrameEdge(m_pmp, false /* fLeading */, edxlfbTrail));
pdxlnOffset->AddRef();
pdxlnLeadEdge->AddChild(pdxlnOffset);
@@ -1384,7 +1384,7 @@ CTranslatorQueryToDXL::PdxlwfLeadLag
}
// manufacture a frame for LEAD/LAG function
- return New(m_pmp) CDXLWindowFrame
+ return GPOS_NEW(m_pmp) CDXLWindowFrame
(
m_pmp,
EdxlfsRow, // frame specification
@@ -1433,7 +1433,7 @@ CTranslatorQueryToDXL::UpdateLeadLagWinSpecPos
CMDName *pmdname = NULL;
if (NULL != pdxlws->Pmdname())
{
- pmdname = New(m_pmp) CMDName(m_pmp, pdxlws->Pmdname()->Pstr());
+ pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, pdxlws->Pmdname()->Pstr());
}
// find if an offset is specified
@@ -1450,7 +1450,7 @@ CTranslatorQueryToDXL::UpdateLeadLagWinSpecPos
pdxlws->PdrgulPartColList()->AddRef();
pdxlws->PdxlnSortColList()->AddRef();
CDXLWindowSpec *pdxlwsNew =
- New(m_pmp) CDXLWindowSpec
+ GPOS_NEW(m_pmp) CDXLWindowSpec
(
m_pmp,
pdxlws->PdrgulPartColList(),
@@ -1487,7 +1487,7 @@ CTranslatorQueryToDXL::Pdrgpdxlws
GPOS_ASSERT(NULL != phmiulSortColsColId);
GPOS_ASSERT(NULL != pdxlnScPrL);
- DrgPdxlws *pdrgpdxlws = New(m_pmp) DrgPdxlws(m_pmp);
+ DrgPdxlws *pdrgpdxlws = GPOS_NEW(m_pmp) DrgPdxlws(m_pmp);
// translate window specification
ListCell *plcWindowSpec = NULL;
@@ -1503,14 +1503,14 @@ CTranslatorQueryToDXL::Pdrgpdxlws
if (NULL != pwindowspec->name)
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(m_pmp, pwindowspec->name);
- pmdname = New(m_pmp) CMDName(m_pmp, pstrAlias);
- delete pstrAlias;
+ pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
+ GPOS_DELETE(pstrAlias);
}
if (0 < gpdb::UlListLength(pwindowspec->order))
{
// create a sorting col list
- pdxlnSortColList = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarSortColList(m_pmp));
+ pdxlnSortColList = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarSortColList(m_pmp));
DrgPdxln *pdrgpdxlnSortCol = PdrgpdxlnSortCol(pwindowspec->order, phmiulSortColsColId);
const ULONG ulSize = pdrgpdxlnSortCol->UlLength();
@@ -1528,7 +1528,7 @@ CTranslatorQueryToDXL::Pdrgpdxlws
pdxlwf = m_psctranslator->Pdxlwf((Expr *) pwindowspec->frame, m_pmapvarcolid, pdxlnScPrL, &m_fHasDistributedTables);
}
- CDXLWindowSpec *pdxlws = New(m_pmp) CDXLWindowSpec(m_pmp, pdrgppulPartCol, pmdname, pdxlnSortColList, pdxlwf);
+ CDXLWindowSpec *pdxlws = GPOS_NEW(m_pmp) CDXLWindowSpec(m_pmp, pdrgppulPartCol, pmdname, pdxlnSortColList, pdxlwf);
pdrgpdxlws->Append(pdxlws);
}
@@ -1561,9 +1561,9 @@ CTranslatorQueryToDXL::PdxlnWindow
}
// translate target list entries
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
- CDXLNode *pdxlnNewChildScPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnNewChildScPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
ListCell *plcTE = NULL;
ULONG ulResno = 1;
@@ -1603,28 +1603,28 @@ CTranslatorQueryToDXL::PdxlnWindow
// construct a scalar identifier that points to the computed column and
// add it to the project list of the window operator
- CMDName *pmdnameAlias = New(m_pmp) CMDName
+ CMDName *pmdnameAlias = GPOS_NEW(m_pmp) CMDName
(
m_pmp,
CDXLScalarProjElem::PdxlopConvert(pdxlnPrEl->Pdxlop())->PmdnameAlias()->Pstr()
);
- CDXLNode *pdxlnPrElNew = New(m_pmp) CDXLNode
+ CDXLNode *pdxlnPrElNew = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarProjElem(m_pmp, ulColId, pmdnameAlias)
+ GPOS_NEW(m_pmp) CDXLScalarProjElem(m_pmp, ulColId, pmdnameAlias)
);
CMDIdGPDB *pmdidExprType = CTranslatorUtils::PmdidWithVersion(m_pmp, gpdb::OidExprType((Node*) pte->expr));
- CDXLNode *pdxlnPrElNewChild = New(m_pmp) CDXLNode
+ CDXLNode *pdxlnPrElNewChild = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarIdent
+ GPOS_NEW(m_pmp) CDXLScalarIdent
(
m_pmp,
- New(m_pmp) CDXLColRef
+ GPOS_NEW(m_pmp) CDXLColRef
(
m_pmp,
- New(m_pmp) CMDName(m_pmp, pmdnameAlias->Pstr()), ulColId
+ GPOS_NEW(m_pmp) CMDName(m_pmp, pmdnameAlias->Pstr()), ulColId
),
pmdidExprType
)
@@ -1700,7 +1700,7 @@ CTranslatorQueryToDXL::PdxlnWindow
if (0 < pdxlnNewChildScPrL->UlArity())
{
// create a project list for the computed columns used in the window specification
- pdxlnNewChild = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalProject(m_pmp));
+ pdxlnNewChild = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp));
pdxlnNewChild->AddChild(pdxlnNewChildScPrL);
pdxlnNewChild->AddChild(pdxlnChild);
pdxlnChild = pdxlnNewChild;
@@ -1722,8 +1722,8 @@ CTranslatorQueryToDXL::PdxlnWindow
// update window spec positions of LEAD/LAG functions
UpdateLeadLagWinSpecPos(pdxlnPrL, pdrgpdxlws);
- CDXLLogicalWindow *pdxlopWindow = New(m_pmp) CDXLLogicalWindow(m_pmp, pdrgpdxlws);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopWindow);
+ CDXLLogicalWindow *pdxlopWindow = GPOS_NEW(m_pmp) CDXLLogicalWindow(m_pmp, pdrgpdxlws);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopWindow);
pdxln->AddChild(pdxlnPrL);
pdxln->AddChild(pdxlnChild);
@@ -1747,7 +1747,7 @@ CTranslatorQueryToDXL::PdrgpulPartCol
)
const
{
- DrgPul *pdrgpul = New(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpul = GPOS_NEW(m_pmp) DrgPul(m_pmp);
ListCell *plcPartCl = NULL;
ForEach (plcPartCl, plPartCl)
@@ -1761,7 +1761,7 @@ CTranslatorQueryToDXL::PdrgpulPartCol
// get the colid of the partition-by column
ULONG ulColId = CTranslatorUtils::UlColId((INT) psortcl->tleSortGroupRef, phmiulColColId);
- pdrgpul->Append(New(m_pmp) ULONG(ulColId));
+ pdrgpul->Append(GPOS_NEW(m_pmp) ULONG(ulColId));
}
return pdrgpul;
@@ -1783,7 +1783,7 @@ CTranslatorQueryToDXL::PdrgpdxlnSortCol
)
const
{
- DrgPdxln *pdrgpdxln = New(m_pmp) DrgPdxln(m_pmp);
+ DrgPdxln *pdrgpdxln = GPOS_NEW(m_pmp) DrgPdxln(m_pmp);
ListCell *plcSortCl = NULL;
ForEach (plcSortCl, plSortCl)
@@ -1807,17 +1807,17 @@ CTranslatorQueryToDXL::PdrgpdxlnSortCol
const CWStringConst *pstr = pmdscop->Mdname().Pstr();
GPOS_ASSERT(NULL != pstr);
- CDXLScalarSortCol *pdxlop = New(m_pmp) CDXLScalarSortCol
+ CDXLScalarSortCol *pdxlop = GPOS_NEW(m_pmp) CDXLScalarSortCol
(
m_pmp,
ulColId,
pmdidScOp,
- New(m_pmp) CWStringConst(pstr->Wsz()),
+ GPOS_NEW(m_pmp) CWStringConst(pstr->Wsz()),
false
);
// create the DXL node holding the sorting col
- CDXLNode *pdxlnSortCol = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxlnSortCol = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
pdrgpdxln->Append(pdxlnSortCol);
}
@@ -1853,10 +1853,10 @@ CTranslatorQueryToDXL::PdxlnLgLimit
// otherwise we may increase the storage size because there are less opportunities for compression
BOOL fTopLevelLimit = (m_fTopDMLQuery && 1 == m_ulQueryLevel) || (m_fCTASQuery && 0 == m_ulQueryLevel);
CDXLNode *pdxlnLimit =
- New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalLimit(m_pmp, fTopLevelLimit));
+ GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalLimit(m_pmp, fTopLevelLimit));
// create a sorting col list
- CDXLNode *pdxlnSortColList = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarSortColList(m_pmp));
+ CDXLNode *pdxlnSortColList = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarSortColList(m_pmp));
DrgPdxln *pdrgpdxlnSortCol = PdrgpdxlnSortCol(plSortCl, phmiulGrpColsColId);
const ULONG ulSize = pdrgpdxlnSortCol->UlLength();
@@ -1869,10 +1869,10 @@ CTranslatorQueryToDXL::PdxlnLgLimit
pdrgpdxlnSortCol->Release();
// create limit count
- CDXLNode *pdxlnLimitCount = New(m_pmp) CDXLNode
+ CDXLNode *pdxlnLimitCount = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarLimitCount(m_pmp)
+ GPOS_NEW(m_pmp) CDXLScalarLimitCount(m_pmp)
);
if (NULL != pnodeLimitCount)
@@ -1881,10 +1881,10 @@ CTranslatorQueryToDXL::PdxlnLgLimit
}
// create limit offset
- CDXLNode *pdxlnLimitOffset = New(m_pmp) CDXLNode
+ CDXLNode *pdxlnLimitOffset = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarLimitOffset(m_pmp)
+ GPOS_NEW(m_pmp) CDXLScalarLimitOffset(m_pmp)
);
if (NULL != pnodeLimitOffset)
@@ -1919,8 +1919,8 @@ CTranslatorQueryToDXL::AddSortingGroupingColumn
{
if (0 < pte->ressortgroupref)
{
- INT *piKey = New(m_pmp) INT(pte->ressortgroupref);
- ULONG *pulValue = New(m_pmp) ULONG(ulColId);
+ INT *piKey = GPOS_NEW(m_pmp) INT(pte->ressortgroupref);
+ ULONG *pulValue = GPOS_NEW(m_pmp) ULONG(ulColId);
// insert idx-colid mapping in the hash map
#ifdef GPOS_DEBUG
@@ -1967,7 +1967,7 @@ CTranslatorQueryToDXL::PdxlnSimpleGroupBy
#ifdef GPOS_DEBUG
BOOL fResult =
#endif // GPOS_DEBUG
- phmiulOutputCols->FInsert(New(m_pmp) INT(*(mi.Pk())), New(m_pmp) ULONG(*(mi.Pt())));
+ phmiulOutputCols->FInsert(GPOS_NEW(m_pmp) INT(*(mi.Pk())), GPOS_NEW(m_pmp) ULONG(*(mi.Pt())));
GPOS_ASSERT(fResult);
}
}
@@ -1981,7 +1981,7 @@ CTranslatorQueryToDXL::PdxlnSimpleGroupBy
List *plDQA = NIL;
// construct the project list of the group-by operator
- CDXLNode *pdxlnPrLGrpBy = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrLGrpBy = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
ListCell *plcTE = NULL;
ULONG ulDQAs = 0;
@@ -2042,10 +2042,10 @@ CTranslatorQueryToDXL::PdxlnSimpleGroupBy
gpdb::FreeList(plDQA);
}
- return New(m_pmp) CDXLNode
+ return GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLLogicalGroupBy(m_pmp, pdrgpul),
+ GPOS_NEW(m_pmp) CDXLLogicalGroupBy(m_pmp, pdrgpul),
pdxlnPrLGrpBy,
pdxlnChild
);
@@ -2111,14 +2111,14 @@ CTranslatorQueryToDXL::PdxlnGroupingSets
if (NULL == plGroupClause)
{
- HMIUl *phmiulChild = New(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulChild = GPOS_NEW(m_pmp) HMIUl(m_pmp);
CDXLNode *pdxlnSPJ = PdxlnSPJ(plTargetList, pfromexpr, phmiulSortgrouprefColId, phmiulChild, plGroupClause);
CBitSet *pbs = NULL;
if (fHasAggs)
{
- pbs = New(m_pmp) CBitSet(m_pmp);
+ pbs = GPOS_NEW(m_pmp) CBitSet(m_pmp);
}
// in case of aggregates, construct a group by operator
@@ -2143,8 +2143,8 @@ CTranslatorQueryToDXL::PdxlnGroupingSets
// grouping functions refer to grouping col positions, so construct a map pos->grouping column
// while processing the grouping clause
- HMUlUl *phmululGrpColPos = New(m_pmp) HMUlUl(m_pmp);
- CBitSet *pbsUniqueueGrpCols = New(m_pmp) CBitSet(m_pmp, ulCols);
+ HMUlUl *phmululGrpColPos = GPOS_NEW(m_pmp) HMUlUl(m_pmp);
+ CBitSet *pbsUniqueueGrpCols = GPOS_NEW(m_pmp) CBitSet(m_pmp, ulCols);
DrgPbs *pdrgpbs = CTranslatorUtils::PdrgpbsGroupBy(m_pmp, plGroupClause, ulCols, phmululGrpColPos, pbsUniqueueGrpCols);
const ULONG ulGroupingSets = pdrgpbs->UlLength();
@@ -2152,7 +2152,7 @@ CTranslatorQueryToDXL::PdxlnGroupingSets
if (1 == ulGroupingSets)
{
// simple group by
- HMIUl *phmiulChild = New(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulChild = GPOS_NEW(m_pmp) HMIUl(m_pmp);
CDXLNode *pdxlnSPJ = PdxlnSPJ(plTargetList, pfromexpr, phmiulSortgrouprefColId, phmiulChild, plGroupClause);
// translate the groupby clauses into a logical group by operator
@@ -2239,8 +2239,8 @@ CTranslatorQueryToDXL::PdxlnUnionAllForGroupingSets
const ULONG ulCTEId = m_pidgtorCTE->UlNextId();
// construct a CTE producer on top of the SPJ query
- HMIUl *phmiulSPJ = New(m_pmp) HMIUl(m_pmp);
- HMIUl *phmiulSortgrouprefColIdProducer = New(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulSPJ = GPOS_NEW(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulSortgrouprefColIdProducer = GPOS_NEW(m_pmp) HMIUl(m_pmp);
CDXLNode *pdxlnSPJ = PdxlnSPJForGroupingSets(plTargetList, pfromexpr, phmiulSortgrouprefColIdProducer, phmiulSPJ, plGroupClause);
// construct output colids
@@ -2248,8 +2248,8 @@ CTranslatorQueryToDXL::PdxlnUnionAllForGroupingSets
GPOS_ASSERT (NULL != m_pdrgpdxlnCTE);
- CDXLLogicalCTEProducer *pdxlopCTEProducer = New(m_pmp) CDXLLogicalCTEProducer(m_pmp, ulCTEId, pdrgpulCTEProducer);
- CDXLNode *pdxlnCTEProducer = New(m_pmp) CDXLNode(m_pmp, pdxlopCTEProducer, pdxlnSPJ);
+ CDXLLogicalCTEProducer *pdxlopCTEProducer = GPOS_NEW(m_pmp) CDXLLogicalCTEProducer(m_pmp, ulCTEId, pdrgpulCTEProducer);
+ CDXLNode *pdxlnCTEProducer = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopCTEProducer, pdxlnSPJ);
m_pdrgpdxlnCTE->Append(pdxlnCTEProducer);
CMappingVarColId *pmapvarcolidOriginal = m_pmapvarcolid->PmapvarcolidCopy(m_pmp);
@@ -2262,16 +2262,16 @@ CTranslatorQueryToDXL::PdxlnUnionAllForGroupingSets
DrgPul *pdrgpulCTEConsumer = PdrgpulGenerateColIds(m_pmp, pdrgpulCTEProducer->UlLength());
// reset col mapping with new consumer columns
- delete m_pmapvarcolid;
+ GPOS_DELETE(m_pmapvarcolid);
m_pmapvarcolid = pmapvarcolidOriginal->PmapvarcolidRemap(m_pmp, pdrgpulCTEProducer, pdrgpulCTEConsumer);
HMIUl *phmiulSPJConsumer = PhmiulRemapColIds(m_pmp, phmiulSPJ, pdrgpulCTEProducer, pdrgpulCTEConsumer);
HMIUl *phmiulSortgrouprefColIdConsumer = PhmiulRemapColIds(m_pmp, phmiulSortgrouprefColIdProducer, pdrgpulCTEProducer, pdrgpulCTEConsumer);
// construct a CTE consumer
- CDXLNode *pdxlnCTEConsumer = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalCTEConsumer(m_pmp, ulCTEId, pdrgpulCTEConsumer));
+ CDXLNode *pdxlnCTEConsumer = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalCTEConsumer(m_pmp, ulCTEId, pdrgpulCTEConsumer));
- HMIUl *phmiulGroupBy = New(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulGroupBy = GPOS_NEW(m_pmp) HMIUl(m_pmp);
CDXLNode *pdxlnGroupBy = PdxlnSimpleGroupBy
(
plTargetList,
@@ -2296,12 +2296,12 @@ CTranslatorQueryToDXL::PdxlnUnionAllForGroupingSets
pdrgpulColIdsOuter->AddRef();
- DrgPdrgPul *pdrgpdrgulInputColIds = New(m_pmp) DrgPdrgPul(m_pmp);
+ DrgPdrgPul *pdrgpdrgulInputColIds = GPOS_NEW(m_pmp) DrgPdrgPul(m_pmp);
pdrgpdrgulInputColIds->Append(pdrgpulColIdsOuter);
pdrgpdrgulInputColIds->Append(pdrgpulColIdsInner);
- CDXLLogicalSetOp *pdxlopSetop = New(m_pmp) CDXLLogicalSetOp(m_pmp, EdxlsetopUnionAll, pdrgpdxlcd, pdrgpdrgulInputColIds, false);
- pdxlnUnionAll = New(m_pmp) CDXLNode(m_pmp, pdxlopSetop, pdxlnProject, pdxlnUnionAll);
+ CDXLLogicalSetOp *pdxlopSetop = GPOS_NEW(m_pmp) CDXLLogicalSetOp(m_pmp, EdxlsetopUnionAll, pdrgpdxlcd, pdrgpdrgulInputColIds, false);
+ pdxlnUnionAll = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopSetop, pdxlnProject, pdxlnUnionAll);
}
else
{
@@ -2339,7 +2339,7 @@ CTranslatorQueryToDXL::PdxlnUnionAllForGroupingSets
// cleanup
phmiulSPJ->Release();
phmiulSortgrouprefColIdProducer->Release();
- delete pmapvarcolidOriginal;
+ GPOS_DELETE(pmapvarcolidOriginal);
pdrgpulColIdsInner->Release();
// compute output columns
@@ -2371,7 +2371,7 @@ CTranslatorQueryToDXL::PdxlnUnionAllForGroupingSets
pdrgpbs->Release();
// construct a CTE anchor operator on top of the union all
- return New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalCTEAnchor(m_pmp, ulCTEId), pdxlnUnionAll);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalCTEAnchor(m_pmp, ulCTEId), pdxlnUnionAll);
}
//---------------------------------------------------------------------------
@@ -2387,15 +2387,15 @@ CTranslatorQueryToDXL::PdxlnConstTableGet() const
{
// construct the schema of the const table
- DrgPdxlcd *pdrgpdxlcd = New(m_pmp) DrgPdxlcd(m_pmp);
+ DrgPdxlcd *pdrgpdxlcd = GPOS_NEW(m_pmp) DrgPdxlcd(m_pmp);
const CMDTypeBoolGPDB *pmdtypeBool = dynamic_cast<const CMDTypeBoolGPDB *>(m_pmda->PtMDType<IMDTypeBool>(m_sysid));
const CMDIdGPDB *pmdid = CMDIdGPDB::PmdidConvert(pmdtypeBool->Pmdid());
// empty column name
CWStringConst strUnnamedCol(GPOS_WSZ_LIT(""));
- CMDName *pmdname = New(m_pmp) CMDName(m_pmp, &strUnnamedCol);
- CDXLColDescr *pdxlcd = New(m_pmp) CDXLColDescr
+ CMDName *pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, &strUnnamedCol);
+ CDXLColDescr *pdxlcd = GPOS_NEW(m_pmp) CDXLColDescr
(
m_pmp,
pmdname,
@@ -2407,10 +2407,10 @@ CTranslatorQueryToDXL::PdxlnConstTableGet() const
pdrgpdxlcd->Append(pdxlcd);
// create the array of datum arrays
- DrgPdrgPdxldatum *pdrgpdrgpdxldatum = New(m_pmp) DrgPdrgPdxldatum(m_pmp);
+ DrgPdrgPdxldatum *pdrgpdrgpdxldatum = GPOS_NEW(m_pmp) DrgPdrgPdxldatum(m_pmp);
// create a datum array
- DrgPdxldatum *pdrgpdxldatum = New(m_pmp) DrgPdxldatum(m_pmp);
+ DrgPdxldatum *pdrgpdxldatum = GPOS_NEW(m_pmp) DrgPdxldatum(m_pmp);
Const *pconst = (Const*) gpdb::PnodeMakeBoolConst(true /*value*/, false /*isnull*/);
CDXLDatum *pdxldatum = m_psctranslator->Pdxldatum(pconst);
@@ -2419,9 +2419,9 @@ CTranslatorQueryToDXL::PdxlnConstTableGet() const
pdrgpdxldatum->Append(pdxldatum);
pdrgpdrgpdxldatum->Append(pdrgpdxldatum);
- CDXLLogicalConstTable *pdxlop = New(m_pmp) CDXLLogicalConstTable(m_pmp, pdrgpdxlcd, pdrgpdrgpdxldatum);
+ CDXLLogicalConstTable *pdxlop = GPOS_NEW(m_pmp) CDXLLogicalConstTable(m_pmp, pdrgpdxlcd, pdrgpdrgpdxldatum);
- return New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
}
//---------------------------------------------------------------------------
@@ -2447,17 +2447,17 @@ CTranslatorQueryToDXL::PdxlnFromSetOp
EdxlSetOpType edxlsetop = CTranslatorUtils::Edxlsetop(psetopstmt->op, psetopstmt->all);
// translate the left and right child
- DrgPul *pdrgpulLeft = New (m_pmp) DrgPul(m_pmp);
- DrgPul *pdrgpulRight = New (m_pmp) DrgPul(m_pmp);
- DrgPmdid *pdrgpmdidLeft = New (m_pmp) DrgPmdid(m_pmp);
- DrgPmdid *pdrgpmdidRight = New (m_pmp) DrgPmdid(m_pmp);
+ DrgPul *pdrgpulLeft = GPOS_NEW(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulRight = GPOS_NEW(m_pmp) DrgPul(m_pmp);
+ DrgPmdid *pdrgpmdidLeft = GPOS_NEW(m_pmp) DrgPmdid(m_pmp);
+ DrgPmdid *pdrgpmdidRight = GPOS_NEW(m_pmp) DrgPmdid(m_pmp);
CDXLNode *pdxlnLeftChild = PdxlnSetOpChild(psetopstmt->larg, pdrgpulLeft, pdrgpmdidLeft, plTargetList);
CDXLNode *pdxlnRightChild = PdxlnSetOpChild(psetopstmt->rarg, pdrgpulRight, pdrgpmdidRight, plTargetList);
// mark outer references in input columns from left child
- ULONG *pulColId = New(m_pmp) ULONG[pdrgpulLeft->UlLength()];
- BOOL *pfOuterRef = New(m_pmp) BOOL[pdrgpulLeft->UlLength()];
+ ULONG *pulColId = GPOS_NEW_ARRAY(m_pmp, ULONG, pdrgpulLeft->UlLength());
+ BOOL *pfOuterRef = GPOS_NEW_ARRAY(m_pmp, BOOL, pdrgpulLeft->UlLength());
const ULONG ulSize = pdrgpulLeft->UlLength();
for (ULONG ul = 0; ul < ulSize; ul++)
{
@@ -2466,19 +2466,27 @@ CTranslatorQueryToDXL::PdxlnFromSetOp
}
CTranslatorUtils::MarkOuterRefs(pulColId, pfOuterRef, ulSize, pdxlnLeftChild);
- DrgPdrgPul *pdrgpdrgulInputColIds = New(m_pmp) DrgPdrgPul(m_pmp);
+ DrgPdrgPul *pdrgpdrgulInputColIds = GPOS_NEW(m_pmp) DrgPdrgPul(m_pmp);
pdrgpdrgulInputColIds->Append(pdrgpulLeft);
pdrgpdrgulInputColIds->Append(pdrgpulRight);
- DrgPul *pdrgpulOutput = CTranslatorUtils::PdrgpulGenerateColIds(m_pmp, plTargetList, pdrgpmdidLeft, pdrgpulLeft, pfOuterRef, m_pidgtorCol);
+ DrgPul *pdrgpulOutput = CTranslatorUtils::PdrgpulGenerateColIds
+ (
+ m_pmp,
+ plTargetList,
+ pdrgpmdidLeft,
+ pdrgpulLeft,
+ pfOuterRef,
+ m_pidgtorCol
+ );
GPOS_ASSERT(pdrgpulOutput->UlLength() == pdrgpulLeft->UlLength());
- delete [] pulColId;
- delete [] pfOuterRef;
+ GPOS_DELETE_ARRAY(pulColId);
+ GPOS_DELETE_ARRAY(pfOuterRef);
BOOL fCastAcrossInput = FCast(plTargetList, pdrgpmdidLeft) || FCast(plTargetList, pdrgpmdidRight);
- DrgPdxln *pdrgpdxlnChildren = New(m_pmp) DrgPdxln(m_pmp);
+ DrgPdxln *pdrgpdxlnChildren = GPOS_NEW(m_pmp) DrgPdxln(m_pmp);
pdrgpdxlnChildren->Append(pdxlnLeftChild);
pdrgpdxlnChildren->Append(pdxlnRightChild);
@@ -2557,13 +2565,13 @@ CTranslatorQueryToDXL::PdxlnSetOp
GPOS_ASSERT(ulCols == pdrgpulInputFirstChild->UlLength());
GPOS_ASSERT(ulCols == pdrgpulOutput->UlLength());
- CBitSet *pbs = New(m_pmp) CBitSet(m_pmp);
+ CBitSet *pbs = GPOS_NEW(m_pmp) CBitSet(m_pmp);
// project list to maintain the casting of the duplicate input columns
- CDXLNode *pdxlnNewChildScPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnNewChildScPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
- DrgPul *pdrgpulInputFirstChildNew = New(m_pmp) DrgPul (m_pmp);
- DrgPdxlcd *pdrgpdxlcdOutput = New(m_pmp) DrgPdxlcd(m_pmp);
+ DrgPul *pdrgpulInputFirstChildNew = GPOS_NEW(m_pmp) DrgPul (m_pmp);
+ DrgPdxlcd *pdrgpdxlcdOutput = GPOS_NEW(m_pmp) DrgPdxlcd(m_pmp);
for (ULONG ul = 0; ul < ulCols; ul++)
{
ULONG ulColIdOutput = *(*pdrgpulOutput)[ul];
@@ -2580,7 +2588,7 @@ CTranslatorQueryToDXL::PdxlnSetOp
if (!fColExists)
{
pbs->FExchangeSet(ulColIdInput);
- pdrgpulInputFirstChildNew->Append(New(m_pmp) ULONG(ulColIdInput));
+ pdrgpulInputFirstChildNew->Append(GPOS_NEW(m_pmp) ULONG(ulColIdInput));
pdxlcdOutput = CTranslatorUtils::Pdxlcd(m_pmp, pte, ulColIdOutput, ul + 1);
}
@@ -2588,7 +2596,7 @@ CTranslatorQueryToDXL::PdxlnSetOp
{
// we add a dummy-cast to distinguish between the output columns of the union
ULONG ulColIdNew = m_pidgtorCol->UlNextId();
- pdrgpulInputFirstChildNew->Append(New(m_pmp) ULONG(ulColIdNew));
+ pdrgpulInputFirstChildNew->Append(GPOS_NEW(m_pmp) ULONG(ulColIdNew));
ULONG ulColIdUnionOutput = ulColIdNew;
if (fCastedCol)
@@ -2613,7 +2621,7 @@ CTranslatorQueryToDXL::PdxlnSetOp
// create a project node for the dummy casted columns
CDXLNode *pdxlnFirstChild = (*pdrgpdxlnChildren)[0];
pdxlnFirstChild->AddRef();
- CDXLNode *pdxlnNewChild = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalProject(m_pmp));
+ CDXLNode *pdxlnNewChild = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp));
pdxlnNewChild->AddChild(pdxlnNewChildScPrL);
pdxlnNewChild->AddChild(pdxlnFirstChild);
@@ -2624,7 +2632,7 @@ CTranslatorQueryToDXL::PdxlnSetOp
pdxlnNewChildScPrL->Release();
}
- CDXLLogicalSetOp *pdxlop = New(m_pmp) CDXLLogicalSetOp
+ CDXLLogicalSetOp *pdxlop = GPOS_NEW(m_pmp) CDXLLogicalSetOp
(
m_pmp,
edxlsetop,
@@ -2632,7 +2640,7 @@ CTranslatorQueryToDXL::PdxlnSetOp
pdrgpdrgulInputColIds,
fCastAcrossInput
);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop, pdrgpdxlnChildren);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop, pdrgpdxlnChildren);
pbs->Release();
pdrgpulTLPos->Release();
@@ -2741,7 +2749,7 @@ CTranslatorQueryToDXL::PdxlnSetOpChild
{
CDXLNode *pdxlnCurr = (*pdrgpdxln)[ul];
CDXLScalarIdent *pdxlnIdent = CDXLScalarIdent::PdxlopConvert(pdxlnCurr->Pdxlop());
- ULONG *pulColId = New(m_pmp) ULONG(pdxlnIdent->Pdxlcr()->UlID());
+ ULONG *pulColId = GPOS_NEW(m_pmp) ULONG(pdxlnIdent->Pdxlcr()->UlID());
pdrgpul->Append(pulColId);
IMDId *pmdidCol = pdxlnIdent->PmdidType();
@@ -2755,7 +2763,7 @@ CTranslatorQueryToDXL::PdxlnSetOpChild
}
else if (IsA(pnodeChild, SetOperationStmt))
{
- HMIUl *phmiulOutputCols = New(m_pmp) HMIUl(m_pmp);
+ HMIUl *phmiulOutputCols = GPOS_NEW(m_pmp) HMIUl(m_pmp);
CDXLNode *pdxln = PdxlnFromSetOp(pnodeChild, plTargetList, phmiulOutputCols);
// cleanup
@@ -2767,7 +2775,7 @@ CTranslatorQueryToDXL::PdxlnSetOpChild
for (ULONG ul = 0; ul < ulLen; ul++)
{
const CDXLColDescr *pdxlcd = (*pdrgpdxlcd)[ul];
- ULONG *pulColId = New(m_pmp) ULONG(pdxlcd->UlID());
+ ULONG *pulColId = GPOS_NEW(m_pmp) ULONG(pdxlcd->UlID());
pdrgpul->Append(pulColId);
IMDId *pmdidCol = pdxlcd->PmdidType();
@@ -2821,7 +2829,7 @@ CTranslatorQueryToDXL::PdxlnFromGPDBFromExpr
// The join conditions represented in the FromExpr->quals is translated
// into a CDXLLogicalSelect on top of the CDXLLogicalJoin
- pdxln = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalJoin(m_pmp, EdxljtInner));
+ pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalJoin(m_pmp, EdxljtInner));
ListCell *plc = NULL;
ForEach (plc, pfromexpr->fromlist)
@@ -2845,7 +2853,7 @@ CTranslatorQueryToDXL::PdxlnFromGPDBFromExpr
{
if (NULL != pdxlnCond)
{
- CDXLNode *pdxlnSelect = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalSelect(m_pmp));
+ CDXLNode *pdxlnSelect = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalSelect(m_pmp));
pdxlnSelect->AddChild(pdxlnCond);
pdxlnSelect->AddChild(pdxln);
@@ -3004,14 +3012,14 @@ CTranslatorQueryToDXL::PdxlnFromRelation
const IMDRelation *pmdrel = m_pmda->Pmdrel(pdxltabdesc->Pmdid());
if (IMDRelation::ErelstorageExternal == pmdrel->Erelstorage())
{
- pdxlop = New(m_pmp) CDXLLogicalExternalGet(m_pmp, pdxltabdesc);
+ pdxlop = GPOS_NEW(m_pmp) CDXLLogicalExternalGet(m_pmp, pdxltabdesc);
}
else
{
- pdxlop = New(m_pmp) CDXLLogicalGet(m_pmp, pdxltabdesc);
+ pdxlop = GPOS_NEW(m_pmp) CDXLLogicalGet(m_pmp, pdxltabdesc);
}
- CDXLNode *pdxlnGet = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLNode *pdxlnGet = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// make note of new columns from base relation
m_pmapvarcolid->LoadTblColumns(m_ulQueryLevel, ulRTIndex, pdxltabdesc);
@@ -3042,13 +3050,13 @@ CTranslatorQueryToDXL::PdxlnFromValues
GPOS_ASSERT(0 < ulValues);
// children of the UNION ALL
- DrgPdxln *pdrgpdxln = New(m_pmp) DrgPdxln(m_pmp);
+ DrgPdxln *pdrgpdxln = GPOS_NEW(m_pmp) DrgPdxln(m_pmp);
// array of input colid arrays
- DrgPdrgPul *pdrgpdrgulInputColIds = New(m_pmp) DrgPdrgPul(m_pmp);
+ DrgPdrgPul *pdrgpdrgulInputColIds = GPOS_NEW(m_pmp) DrgPdrgPul(m_pmp);
// array of column descriptor for the UNION ALL operator
- DrgPdxlcd *pdrgpdxlcd = New(m_pmp) DrgPdxlcd(m_pmp);
+ DrgPdxlcd *pdrgpdxlcd = GPOS_NEW(m_pmp) DrgPdxlcd(m_pmp);
// translate the tuples in the value scan
ULONG ulTuplePos = 0;
@@ -3060,16 +3068,16 @@ CTranslatorQueryToDXL::PdxlnFromValues
GPOS_ASSERT(IsA(plTuple, List));
// array of column colids
- DrgPul *pdrgpulColIds = New(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulColIds = GPOS_NEW(m_pmp) DrgPul(m_pmp);
// array of project elements (for expression elements)
- DrgPdxln *pdrgpdxlnPrEl = New(m_pmp) DrgPdxln(m_pmp);
+ DrgPdxln *pdrgpdxlnPrEl = GPOS_NEW(m_pmp) DrgPdxln(m_pmp);
// array of datum (for datum constant values)
- DrgPdxldatum *pdrgpdxldatum = New(m_pmp) DrgPdxldatum(m_pmp);
+ DrgPdxldatum *pdrgpdxldatum = GPOS_NEW(m_pmp) DrgPdxldatum(m_pmp);
// array of column descriptors for the CTG containing the datum array
- DrgPdxlcd *pdrgpdxlcdCTG = New(m_pmp) DrgPdxlcd(m_pmp);
+ DrgPdxlcd *pdrgpdxlcdCTG = GPOS_NEW(m_pmp) DrgPdxlcd(m_pmp);
List *plColnames = prte->eref->colnames;
GPOS_ASSERT(NULL != plColnames);
@@ -3094,10 +3102,10 @@ CTranslatorQueryToDXL::PdxlnFromValues
ulColId = m_pidgtorCol->UlNextId();
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(m_pmp, szColName);
- CMDName *pmdname = New(m_pmp) CMDName(m_pmp, pstrAlias);
- delete pstrAlias;
+ CMDName *pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
+ GPOS_DELETE(pstrAlias);
- CDXLColDescr *pdxlcd = New(m_pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(m_pmp) CDXLColDescr
(
m_pmp,
pmdname,
@@ -3124,10 +3132,10 @@ CTranslatorQueryToDXL::PdxlnFromValues
if (0 == ulTuplePos)
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(m_pmp, szColName);
- CMDName *pmdname = New(m_pmp) CMDName(m_pmp, pstrAlias);
- delete pstrAlias;
+ CMDName *pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
+ GPOS_DELETE(pstrAlias);
- CDXLColDescr *pdxlcd = New(m_pmp) CDXLColDescr
+ CDXLColDescr *pdxlcd = GPOS_NEW(m_pmp) CDXLColDescr
(
m_pmp,
pmdname,
@@ -3142,7 +3150,7 @@ CTranslatorQueryToDXL::PdxlnFromValues
GPOS_ASSERT(ULONG_MAX != ulColId);
- pdrgpulColIds->Append(New(m_pmp) ULONG(ulColId));
+ pdrgpulColIds->Append(GPOS_NEW(m_pmp) ULONG(ulColId));
ulColPos++;
}
@@ -3161,8 +3169,8 @@ CTranslatorQueryToDXL::PdxlnFromValues
if (1 < ulValues)
{
// create a UNION ALL operator
- CDXLLogicalSetOp *pdxlop = New(m_pmp) CDXLLogicalSetOp(m_pmp, EdxlsetopUnionAll, pdrgpdxlcd, pdrgpdrgulInputColIds, false);
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlop, pdrgpdxln);
+ CDXLLogicalSetOp *pdxlop = GPOS_NEW(m_pmp) CDXLLogicalSetOp(m_pmp, EdxlsetopUnionAll, pdrgpdxlcd, pdrgpdrgulInputColIds, false);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop, pdrgpdxln);
// make note of new columns from UNION ALL
m_pmapvarcolid->LoadColumns(m_ulQueryLevel, ulRTIndex, pdxlop->Pdrgpdxlcd());
@@ -3217,15 +3225,15 @@ CTranslatorQueryToDXL::PdxlnFromColumnValues
else
{
// create the array of datum arrays
- DrgPdrgPdxldatum *pdrgpdrgpdxldatumCTG = New(m_pmp) DrgPdrgPdxldatum(m_pmp);
+ DrgPdrgPdxldatum *pdrgpdrgpdxldatumCTG = GPOS_NEW(m_pmp) DrgPdrgPdxldatum(m_pmp);
pdrgpdxldatumCTG->AddRef();
pdrgpdrgpdxldatumCTG->Append(pdrgpdxldatumCTG);
pdrgpdxlcdCTG->AddRef();
- CDXLLogicalConstTable *pdxlop = New(m_pmp) CDXLLogicalConstTable(m_pmp, pdrgpdxlcdCTG, pdrgpdrgpdxldatumCTG);
+ CDXLLogicalConstTable *pdxlop = GPOS_NEW(m_pmp) CDXLLogicalConstTable(m_pmp, pdrgpdxlcdCTG, pdrgpdrgpdxldatumCTG);
- pdxlnCTG = New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ pdxlnCTG = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
}
if (0 == pdrgpdxlnPrEl->UlLength())
@@ -3235,17 +3243,17 @@ CTranslatorQueryToDXL::PdxlnFromColumnValues
// create a project node for the list of project elements
pdrgpdxlnPrEl->AddRef();
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLScalarProjList(m_pmp),
+ GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp),
pdrgpdxlnPrEl
);
- CDXLNode *pdxlnProject = New(m_pmp) CDXLNode
+ CDXLNode *pdxlnProject = GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
- New(m_pmp) CDXLLogicalProject(m_pmp),
+ GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp),
pdxlnPrL,
pdxlnCTG
);
@@ -3275,12 +3283,12 @@ CTranslatorQueryToDXL::PdxlnFromTVF
{
CDXLNode *pdxlnCTG = PdxlnConstTableGet();
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
CDXLNode *pdxlnPrEl = PdxlnPrEFromGPDBExpr((Expr *) prte->funcexpr, prte->eref->aliasname, true /* fInsistNewColIds */);
pdxlnPrL->AddChild(pdxlnPrEl);
- CDXLNode *pdxlnProject = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalProject(m_pmp));
+ CDXLNode *pdxlnProject = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp));
pdxlnProject->AddChild(pdxlnPrL);
pdxlnProject->AddChild(pdxlnCTG);
@@ -3290,7 +3298,7 @@ CTranslatorQueryToDXL::PdxlnFromTVF
}
CDXLLogicalTVF *pdxlopTVF = CTranslatorUtils::Pdxltvf(m_pmp, m_pmda, m_pidgtorCol, prte);
- CDXLNode *pdxlnTVF = New(m_pmp) CDXLNode(m_pmp, pdxlopTVF);
+ CDXLNode *pdxlnTVF = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopTVF);
// make note of new columns from function
m_pmapvarcolid->LoadColumns(m_ulQueryLevel, ulRTIndex, pdxlopTVF->Pdrgpdxlcd());
@@ -3371,8 +3379,8 @@ CTranslatorQueryToDXL::PdxlnFromCTE
// load the new columns from the CTE
m_pmapvarcolid->LoadCTEColumns(ulCurrQueryLevel, ulRTIndex, pdrgpulCTEConsumer, const_cast<List *>(plCTEProducerTargetList));
- CDXLLogicalCTEConsumer *pdxlopCTEConsumer = New(m_pmp) CDXLLogicalCTEConsumer(m_pmp, ulCTEId, pdrgpulCTEConsumer);
- CDXLNode *pdxlnCTE = New(m_pmp) CDXLNode(m_pmp, pdxlopCTEConsumer);
+ CDXLLogicalCTEConsumer *pdxlopCTEConsumer = GPOS_NEW(m_pmp) CDXLLogicalCTEConsumer(m_pmp, ulCTEId, pdrgpulCTEConsumer);
+ CDXLNode *pdxlnCTE = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopCTEConsumer);
return pdxlnCTE;
}
@@ -3468,7 +3476,7 @@ CTranslatorQueryToDXL::PdxlnLgJoinFromGPDBJoinExpr
CDXLNode *pdxlnLeftChild = PdxlnFromGPDBFromClauseEntry(pjoinexpr->larg);
CDXLNode *pdxlnRightChild = PdxlnFromGPDBFromClauseEntry(pjoinexpr->rarg);
EdxlJoinType edxljt = CTranslatorUtils::EdxljtFromJoinType(pjoinexpr->jointype);
- CDXLNode *pdxlnJoin = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalJoin(m_pmp, edxljt));
+ CDXLNode *pdxlnJoin = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalJoin(m_pmp, edxljt));
GPOS_ASSERT(NULL != pdxlnLeftChild && NULL != pdxlnRightChild);
@@ -3501,8 +3509,8 @@ CTranslatorQueryToDXL::PdxlnLgJoinFromGPDBJoinExpr
GPOS_ASSERT(NULL != palias->colnames && 0 < gpdb::UlListLength(palias->colnames));
GPOS_ASSERT(gpdb::UlListLength(prte->joinaliasvars) == gpdb::UlListLength(palias->colnames));
- CDXLNode *pdxlnPrLComputedColumns = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrLComputedColumns = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
// construct a proj element node for each entry in the joinaliasvars
ListCell *plcNode = NULL;
@@ -3535,7 +3543,7 @@ CTranslatorQueryToDXL::PdxlnLgJoinFromGPDBJoinExpr
return pdxlnJoin;
}
- CDXLNode *pdxlnProject = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalProject(m_pmp));
+ CDXLNode *pdxlnProject = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp));
pdxlnProject->AddChild(pdxlnPrLComputedColumns);
pdxlnProject->AddChild(pdxlnJoin);
@@ -3564,7 +3572,7 @@ CTranslatorQueryToDXL::PdxlnLgProjectFromGPDBTL
{
BOOL fGroupBy = (0 != gpdb::UlListLength(m_pquery->groupClause) || m_pquery->hasAggs);
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
// construct a proj element node for each entry in the target list
ListCell *plcTE = NULL;
@@ -3661,7 +3669,7 @@ CTranslatorQueryToDXL::PdxlnLgProjectFromGPDBTL
{
// create a node with the CDXLLogicalProject operator and add as its children:
// the CDXLProjectList node and the node representing the input to the project node
- CDXLNode *pdxlnProject = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalProject(m_pmp));
+ CDXLNode *pdxlnProject = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp));
pdxlnProject->AddChild(pdxlnPrL);
pdxlnProject->AddChild(pdxlnChild);
GPOS_ASSERT(NULL != pdxlnProject);
@@ -3693,7 +3701,7 @@ CTranslatorQueryToDXL::PdxlnProjectNullsForGroupingSets
)
const
{
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
// construct a proj element node for those non-aggregate entries in the target list which
// are not included in the grouping set
@@ -3717,15 +3725,15 @@ CTranslatorQueryToDXL::PdxlnProjectNullsForGroupingSets
if (NULL == pte->resname)
{
CWStringConst strUnnamedCol(GPOS_WSZ_LIT("grouping"));
- pmdnameAlias = New(m_pmp) CMDName(m_pmp, &strUnnamedCol);
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, &strUnnamedCol);
}
else
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(m_pmp, pte->resname);
- pmdnameAlias = New(m_pmp) CMDName(m_pmp, pstrAlias);
- delete pstrAlias;
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
+ GPOS_DELETE(pstrAlias);
}
- CDXLNode *pdxlnPrEl = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjElem(m_pmp, ulColId, pmdnameAlias), pdxlnGroupingFunc);
+ CDXLNode *pdxlnPrEl = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjElem(m_pmp, ulColId, pmdnameAlias), pdxlnGroupingFunc);
pdxlnPrL->AddChild(pdxlnPrEl);
StoreAttnoColIdMapping(phmiulOutputCols, ulResno, ulColId);
}
@@ -3760,7 +3768,7 @@ CTranslatorQueryToDXL::PdxlnProjectNullsForGroupingSets
return pdxlnChild;
}
- return New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalProject(m_pmp), pdxlnPrL, pdxlnChild);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp), pdxlnPrL, pdxlnChild);
}
//---------------------------------------------------------------------------
@@ -3784,7 +3792,7 @@ CTranslatorQueryToDXL::PdxlnProjectGroupingFuncs
)
const
{
- CDXLNode *pdxlnPrL = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjList(m_pmp));
+ CDXLNode *pdxlnPrL = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjList(m_pmp));
// construct a proj element node for those non-aggregate entries in the target list which
// are not included in the grouping set
@@ -3806,15 +3814,15 @@ CTranslatorQueryToDXL::PdxlnProjectGroupingFuncs
if (NULL == pte->resname)
{
CWStringConst strUnnamedCol(GPOS_WSZ_LIT("grouping"));
- pmdnameAlias = New(m_pmp) CMDName(m_pmp, &strUnnamedCol);
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, &strUnnamedCol);
}
else
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(m_pmp, pte->resname);
- pmdnameAlias = New(m_pmp) CMDName(m_pmp, pstrAlias);
- delete pstrAlias;
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
+ GPOS_DELETE(pstrAlias);
}
- CDXLNode *pdxlnPrEl = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjElem(m_pmp, ulColId, pmdnameAlias), pdxlnGroupingFunc);
+ CDXLNode *pdxlnPrEl = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjElem(m_pmp, ulColId, pmdnameAlias), pdxlnGroupingFunc);
pdxlnPrL->AddChild(pdxlnPrEl);
StoreAttnoColIdMapping(phmiulOutputCols, ulResno, ulColId);
AddSortingGroupingColumn(pte, phmiulSortgrouprefColId, ulColId);
@@ -3828,7 +3836,7 @@ CTranslatorQueryToDXL::PdxlnProjectGroupingFuncs
return pdxlnChild;
}
- return New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalProject(m_pmp), pdxlnPrL, pdxlnChild);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalProject(m_pmp), pdxlnPrL, pdxlnChild);
}
//---------------------------------------------------------------------------
@@ -3853,7 +3861,7 @@ CTranslatorQueryToDXL::StoreAttnoColIdMapping
#ifdef GPOS_DEBUG
BOOL fResult =
#endif // GPOS_DEBUG
- phmiul->FInsert(New(m_pmp) INT(iAttno), New(m_pmp) ULONG(ulColId));
+ phmiul->FInsert(GPOS_NEW(m_pmp) INT(iAttno), GPOS_NEW(m_pmp) ULONG(ulColId));
GPOS_ASSERT(fResult);
}
@@ -3877,7 +3885,7 @@ CTranslatorQueryToDXL::PdrgpdxlnConstructOutputCols
GPOS_ASSERT(NULL != plTargetList);
GPOS_ASSERT(NULL != phmiulAttnoColId);
- DrgPdxln *pdrgpdxln = New(m_pmp) DrgPdxln(m_pmp);
+ DrgPdxln *pdrgpdxln = GPOS_NEW(m_pmp) DrgPdxln(m_pmp);
ListCell *plc = NULL;
ForEach (plc, plTargetList)
@@ -3896,25 +3904,24 @@ CTranslatorQueryToDXL::PdrgpdxlnConstructOutputCols
if (NULL == pte->resname)
{
CWStringConst strUnnamedCol(GPOS_WSZ_LIT("?column?"));
- pmdname = New(m_pmp) CMDName(m_pmp, &strUnnamedCol);
+ pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, &strUnnamedCol);
}
else
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(m_pmp, pte->resname);
- pmdname = New(m_pmp) CMDName(m_pmp, pstrAlias);
+ pmdname = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
// CName constructor copies string
- delete pstrAlias;
+ GPOS_DELETE(pstrAlias);
}
const ULONG ulColId = CTranslatorUtils::UlColId(ulResNo, phmiulAttnoColId);
// create a column reference
- CDXLColRef *pdxlcr = New(m_pmp) CDXLColRef(m_pmp, pmdname, ulColId);
+ CDXLColRef *pdxlcr = GPOS_NEW(m_pmp) CDXLColRef(m_pmp, pmdname, ulColId);
CMDIdGPDB *pmdidExprType = CTranslatorUtils::PmdidWithVersion(m_pmp, gpdb::OidExprType( (Node*) pte->expr));
- CDXLScalarIdent *pdxlopIdent = New(m_pmp) CDXLScalarIdent(m_pmp, pdxlcr, pmdidExprType);
-
+ CDXLScalarIdent *pdxlopIdent = GPOS_NEW(m_pmp) CDXLScalarIdent(m_pmp, pdxlcr, pmdidExprType);
// create the DXL node holding the scalar ident operator
- CDXLNode *pdxln = New(m_pmp) CDXLNode(m_pmp, pdxlopIdent);
+ CDXLNode *pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlopIdent);
pdrgpdxln->Append(pdxln);
}
@@ -3951,13 +3958,13 @@ CTranslatorQueryToDXL::PdxlnPrEFromGPDBExpr
if (NULL == szAliasName)
{
CWStringConst strUnnamedCol(GPOS_WSZ_LIT("?column?"));
- pmdnameAlias = New(m_pmp) CMDName(m_pmp, &strUnnamedCol);
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, &strUnnamedCol);
}
else
{
CWStringDynamic *pstrAlias = CDXLUtils::PstrFromSz(m_pmp, szAliasName);
- pmdnameAlias = New(m_pmp) CMDName(m_pmp, pstrAlias);
- delete pstrAlias;
+ pmdnameAlias = GPOS_NEW(m_pmp) CMDName(m_pmp, pstrAlias);
+ GPOS_DELETE(pstrAlias);
}
if (IsA(pexpr, Var) && !fInsistNewColIds)
@@ -3973,7 +3980,7 @@ CTranslatorQueryToDXL::PdxlnPrEFromGPDBExpr
ulPrElId = m_pidgtorCol->UlNextId();
}
- CDXLNode *pdxlnPrEl = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLScalarProjElem(m_pmp, ulPrElId, pmdnameAlias));
+ CDXLNode *pdxlnPrEl = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarProjElem(m_pmp, ulPrElId, pmdnameAlias));
pdxlnPrEl->AddChild(pdxlnChild);
return pdxlnPrEl;
@@ -4042,11 +4049,11 @@ CTranslatorQueryToDXL::PdxlnGroupingFunc
const IMDType *pmdtype = m_pmda->PtMDType<IMDTypeInt8>(m_sysid);
CMDIdGPDB *pmdidMDC = CMDIdGPDB::PmdidConvert(pmdtype->Pmdid());
- CMDIdGPDB *pmdid = New(m_pmp) CMDIdGPDB(*pmdidMDC);
+ CMDIdGPDB *pmdid = GPOS_NEW(m_pmp) CMDIdGPDB(*pmdidMDC);
- CDXLDatum *pdxldatum = New(m_pmp) CDXLDatumInt8(m_pmp, pmdid, false /* fNull */, lValue);
- CDXLScalarConstValue *pdxlop = New(m_pmp) CDXLScalarConstValue(m_pmp, pdxldatum);
- return New(m_pmp) CDXLNode(m_pmp, pdxlop);
+ CDXLDatum *pdxldatum = GPOS_NEW(m_pmp) CDXLDatumInt8(m_pmp, pmdid, false /* fNull */, lValue);
+ CDXLScalarConstValue *pdxlop = GPOS_NEW(m_pmp) CDXLScalarConstValue(m_pmp, pdxldatum);
+ return GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
}
//---------------------------------------------------------------------------
@@ -4110,35 +4117,35 @@ CTranslatorQueryToDXL::ConstructCTEProducerList
// append any nested CTE
CUtils::AddRefAppend(m_pdrgpdxlnCTE, pdrgpdxlnCTE);
- DrgPul *pdrgpulColIds = New(m_pmp) DrgPul(m_pmp);
+ DrgPul *pdrgpulColIds = GPOS_NEW(m_pmp) DrgPul(m_pmp);
const ULONG ulOutputCols = pdrgpdxlnQueryOutputCte->UlLength();
for (ULONG ul = 0; ul < ulOutputCols; ul++)
{
CDXLNode *pdxlnOutputCol = (*pdrgpdxlnQueryOutputCte)[ul];
CDXLScalarIdent *pdxlnIdent = CDXLScalarIdent::PdxlopConvert(pdxlnOutputCol->Pdxlop());
- pdrgpulColIds->Append(New(m_pmp) ULONG(pdxlnIdent->Pdxlcr()->UlID()));
+ pdrgpulColIds->Append(GPOS_NEW(m_pmp) ULONG(pdxlnIdent->Pdxlcr()->UlID()));
}
- CDXLLogicalCTEProducer *pdxlop = New(m_pmp) CDXLLogicalCTEProducer(m_pmp, m_pidgtorCTE->UlNextId(), pdrgpulColIds);
- CDXLNode *pdxlnCTEProducer = New(m_pmp) CDXLNode(m_pmp, pdxlop, pdxlnCteChild);
+ CDXLLogicalCTEProducer *pdxlop = GPOS_NEW(m_pmp) CDXLLogicalCTEProducer(m_pmp, m_pidgtorCTE->UlNextId(), pdrgpulColIds);
+ CDXLNode *pdxlnCTEProducer = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop, pdxlnCteChild);
m_pdrgpdxlnCTE->Append(pdxlnCTEProducer);
#ifdef GPOS_DEBUG
BOOL fResult =
#endif
- m_phmulfCTEProducers->FInsert(New(m_pmp) ULONG(pdxlop->UlId()), New(m_pmp) BOOL(true));
+ m_phmulfCTEProducers->FInsert(GPOS_NEW(m_pmp) ULONG(pdxlop->UlId()), GPOS_NEW(m_pmp) BOOL(true));
GPOS_ASSERT(fResult);
// update CTE producer mappings
CCTEListEntry *pctelistentry = m_phmulCTEEntries->PtLookup(&ulCteQueryLevel);
if (NULL == pctelistentry)
{
- pctelistentry = New (m_pmp) CCTEListEntry (m_pmp, ulCteQueryLevel, pcte, pdxlnCTEProducer);
+ pctelistentry = GPOS_NEW(m_pmp) CCTEListEntry (m_pmp, ulCteQueryLevel, pcte, pdxlnCTEProducer);
#ifdef GPOS_DEBUG
BOOL fRes =
#endif
- m_phmulCTEEntries->FInsert(New(m_pmp) ULONG(ulCteQueryLevel), pctelistentry);
+ m_phmulCTEEntries->FInsert(GPOS_NEW(m_pmp) ULONG(ulCteQueryLevel), pctelistentry);
GPOS_ASSERT(fRes);
}
else
@@ -4187,7 +4194,7 @@ CTranslatorQueryToDXL::ConstructCTEAnchors
continue;
}
- CDXLNode *pdxlnCTEAnchorNew = New(m_pmp) CDXLNode(m_pmp, New(m_pmp) CDXLLogicalCTEAnchor(m_pmp, ulCTEProducerId));
+ CDXLNode *pdxlnCTEAnchorNew = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalCTEAnchor(m_pmp, ulCTEProducerId));
if (NULL == *ppdxlnCTEAnchorBottom)
{
@@ -4218,11 +4225,11 @@ CTranslatorQueryToDXL::PdrgpulGenerateColIds
)
const
{
- DrgPul *pdrgpul = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpul = GPOS_NEW(pmp) DrgPul(pmp);
for (ULONG ul = 0; ul < ulSize; ul++)
{
- pdrgpul->Append(New(pmp) ULONG(m_pidgtorCol->UlNextId()));
+ pdrgpul->Append(GPOS_NEW(pmp) ULONG(m_pidgtorCol->UlNextId()));
}
return pdrgpul;
@@ -4244,9 +4251,9 @@ CTranslatorQueryToDXL::PdrgpulExtractColIds
)
const
{
- HMUlUl *phmulul = New(pmp) HMUlUl(pmp);
+ HMUlUl *phmulul = GPOS_NEW(pmp) HMUlUl(pmp);
- DrgPul *pdrgpul = New(pmp) DrgPul(pmp);
+ DrgPul *pdrgpul = GPOS_NEW(pmp) DrgPul(pmp);
HMIUlIter mi(phmiul);
while (mi.FAdvance())
@@ -4256,8 +4263,8 @@ CTranslatorQueryToDXL::PdrgpulExtractColIds
// do not insert colid if already inserted
if (NULL == phmulul->PtLookup(&ulColId))
{
- pdrgpul->Append(New(m_pmp) ULONG(ulColId));
- phmulul->FInsert(New(m_pmp) ULONG(ulColId), New(m_pmp) ULONG(ulColId));
+ pdrgpul->Append(GPOS_NEW(m_pmp) ULONG(ulColId));
+ phmulul->FInsert(GPOS_NEW(m_pmp) ULONG(ulColId), GPOS_NEW(m_pmp) ULONG(ulColId));
}
}
@@ -4289,26 +4296,26 @@ CTranslatorQueryToDXL::PhmiulRemapColIds
GPOS_ASSERT(pdrgpulFrom->UlLength() == pdrgpulTo->UlLength());
// compute a map of the positions in the from array
- HMUlUl *phmulul = New(pmp) HMUlUl(pmp);
+ HMUlUl *phmulul = GPOS_NEW(pmp) HMUlUl(pmp);
const ULONG ulSize = pdrgpulFrom->UlLength();
for (ULONG ul = 0; ul < ulSize; ul++)
{
#ifdef GPOS_DEBUG
BOOL fResult =
#endif // GPOS_DEBUG
- phmulul->FInsert(New(pmp) ULONG(*((*pdrgpulFrom)[ul])), New(pmp) ULONG(*((*pdrgpulTo)[ul])));
+ phmulul->FInsert(GPOS_NEW(pmp) ULONG(*((*pdrgpulFrom)[ul])), GPOS_NEW(pmp) ULONG(*((*pdrgpulTo)[ul])));
GPOS_ASSERT(fResult);
}
- HMIUl *phmiulResult = New(pmp) HMIUl(pmp);
+ HMIUl *phmiulResult = GPOS_NEW(pmp) HMIUl(pmp);
HMIUlIter mi(phmiul);
while (mi.FAdvance())
{
- INT *piKey = New(pmp) INT(*(mi.Pk()));
+ INT *piKey = GPOS_NEW(pmp) INT(*(mi.Pk()));
const ULONG *pulValue = mi.Pt();
GPOS_ASSERT(NULL != pulValue);
- ULONG *pulValueRemapped = New(pmp) ULONG(*(phmulul->PtLookup(pulValue)));
+ ULONG *pulValueRemapped = GPOS_NEW(pmp) ULONG(*(phmulul->PtLookup(pulValue)));
phmiulResult->FInsert(piKey, pulValueRemapped);
}