// PD_TRACE_DECLARE_FUNCTION ( SDB_DPSLOCKBUCKET_LOCKID, "dpsLockBucket::lockId" )
void dpsLockBucket::release( _pmdEDUCB *eduCB,
const dpsTransLockId &lockId )
{
SDB_ASSERT( eduCB, "eduCB can't be null" ) ;
dpsTransLockUnit *pLockUnit = NULL;
{
ossScopedLock _lock( &_lstMutex );
dpsTransLockUnitList::iterator iterLst
= _lockLst.find( lockId );
if ( _lockLst.end() == iterLst )
{
goto done ;
}
pLockUnit = iterLst->second ;
removeFromRun( eduCB, pLockUnit );
if ( NULL == pLockUnit->_pWaitCB
&& pLockUnit->_runList.size() == 0 )
{
SDB_OSS_DEL( pLockUnit );
_lockLst.erase( iterLst );
}
}
done:
PD_TRACE_EXIT ( SDB_DPSLOCKBUCKET_LOCKID );
return ;
}
static inline void freeRecordArray(RecordArray** recordArray)
{
SDB_ASSERT(NULL != recordArray, "recordArray can't be NULL");
SDB_OSS_DEL(*recordArray);
*recordArray = NULL;
}
dpsLockBucket::~dpsLockBucket()
{
dpsTransLockUnitList::iterator iterLst = _lockLst.begin();
while( iterLst != _lockLst.end() )
{
SDB_OSS_DEL( iterLst->second );
_lockLst.erase( iterLst++ );
}
}
_mongoSession::~_mongoSession()
{
if ( NULL != _converter )
{
SDB_OSS_DEL( _converter ) ;
_converter = NULL ;
}
_resource = NULL ;
}
dpsTransLock::~dpsTransLock()
{
UINT32 i = 0;
for ( ; i < MAX_LOCKBUCKET_NUM; i++ )
{
if ( _bucketLst[i] != NULL )
{
SDB_OSS_DEL( _bucketLst[i] );
}
}
}
void _mongoSession::resetBuffers()
{
if ( 0 != _contextBuff.size() )
{
_contextBuff.release() ;
}
if ( !_outBuffer.empty() )
{
_outBuffer.zero() ;
}
std::vector< msgBuffer * >::iterator it = _inBufferVec.begin() ;
for ( ; it != _inBufferVec.end(); ++it )
{
SDB_OSS_DEL (*it) ;
(*it) = NULL ;
}
_inBufferVec.clear() ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_CLSCATAMATCHER_PARSEANOBJ, "clsCatalogMatcher::parseAnObj" )
INT32 clsCatalogMatcher::parseAnObj( const BSONObj &matcher,
clsCatalogPredicateTree &predicateSet )
{
INT32 rc = SDB_OK;
PD_TRACE_ENTRY ( SDB_CLSCATAMATCHER_PARSEANOBJ ) ;
clsCatalogPredicateTree *pPredicateSet = NULL;
BOOLEAN isNew = FALSE ;
try
{
BSONObjIterator i( matcher ) ;
while ( i.more() )
{
BSONElement beTmp = i.next();
const CHAR *pFieldName = beTmp.fieldName() ;
if ( predicateSet.getLogicType() == CLS_CATA_LOGIC_OR )
{
pPredicateSet = SDB_OSS_NEW
clsCatalogPredicateTree( _shardingKey ) ;
PD_CHECK( pPredicateSet != NULL, SDB_OOM, error, PDERROR,
"malloc failed" ) ;
isNew = TRUE ;
}
else
{
pPredicateSet = &predicateSet ;
}
if ( MTH_OPERATOR_EYECATCHER == pFieldName[0] )
{
rc = parseLogicOp( beTmp, *pPredicateSet );
}
else
{
rc = parseCmpOp( beTmp, *pPredicateSet );
}
PD_RC_CHECK( rc, PDERROR, "Failed to parse the field(rc=%d)",
rc ) ;
if ( isNew )
{
predicateSet.addChild( pPredicateSet ) ;
}
if ( predicateSet.getLogicType() == CLS_CATA_LOGIC_OR &&
predicateSet.isUniverse() )
{
goto done ;
}
}
}
catch ( std::exception &e )
{
rc = SDB_INVALIDARG ;
PD_RC_CHECK( rc, PDERROR, "Failed to parse the matcher(%s), "
"occured unexpected error:%s",
matcher.toString( false, false ).c_str(),
e.what() ) ;
}
done:
PD_TRACE_EXITRC ( SDB_CLSCATAMATCHER_PARSEANOBJ, rc ) ;
return rc;
error:
if ( isNew )
{
SDB_OSS_DEL( pPredicateSet );
pPredicateSet = NULL;
}
goto done;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_CLSCATAMATCHER_PARSELOGICOP, "clsCatalogMatcher::parseLogicOp" )
INT32 clsCatalogMatcher::parseLogicOp( const BSONElement & beField,
clsCatalogPredicateTree & predicateSet )
{
INT32 rc = SDB_OK;
PD_TRACE_ENTRY ( SDB_CLSCATAMATCHER_PARSELOGICOP ) ;
clsCatalogPredicateTree *pPredicateSet = NULL ;
BOOLEAN isNew = FALSE ;
CLS_CATA_LOGIC_TYPE logicType = CLS_CATA_LOGIC_INVALID ;
try
{
const CHAR *pFieldName = beField.fieldName() ;
if ( beField.type() == Array )
{
if ( 'a' == pFieldName[1] && 'n' == pFieldName[2] &&
'd' == pFieldName[3] && 0 == pFieldName[4] )
{
logicType = CLS_CATA_LOGIC_AND ;
predicateSet.setLogicType( CLS_CATA_LOGIC_AND ) ;
pPredicateSet = &predicateSet;
}
else if( 'o' == pFieldName[1] && 'r' == pFieldName[2] &&
0 == pFieldName[3] )
{
if ( predicateSet.getLogicType() != CLS_CATA_LOGIC_INVALID )
{
pPredicateSet =
SDB_OSS_NEW clsCatalogPredicateTree( _shardingKey );
PD_CHECK( pPredicateSet != NULL, SDB_OOM, error, PDERROR,
"malloc failed" ) ;
pPredicateSet->setLogicType( CLS_CATA_LOGIC_OR ) ;
isNew = TRUE ;
}
else
{
predicateSet.setLogicType( CLS_CATA_LOGIC_OR ) ;
pPredicateSet = &predicateSet ;
}
logicType = CLS_CATA_LOGIC_OR ;
}
else // parse "$not"
{
}
if ( logicType != CLS_CATA_LOGIC_INVALID )
{
BSONObjIterator iter( beField.embeddedObject() );
while ( iter.more() )
{
BSONElement beTmp = iter.next();
BSONObj boTmp = beTmp.embeddedObject();
rc = parseAnObj( boTmp, *pPredicateSet );
PD_RC_CHECK( rc, PDERROR, "Failed to parse the field(rc=%d)",
rc ) ;
}
if ( isNew )
{
predicateSet.addChild( pPredicateSet ) ;
}
goto done ;
}
}
if ( predicateSet.getLogicType() == CLS_CATA_LOGIC_OR )
{
predicateSet.upgradeToUniverse();
}
}
catch ( std::exception &e )
{
rc = SDB_INVALIDARG;
PD_RC_CHECK( rc, PDERROR, "Failed to parse the field occured "
"unexpected error:%s", e.what() );
}
done:
PD_TRACE_EXITRC ( SDB_CLSCATAMATCHER_PARSELOGICOP, rc ) ;
return rc;
error:
if ( isNew )
{
SDB_OSS_DEL( pPredicateSet );
pPredicateSet = NULL;
}
goto done;
}
void RecordParser::releaseInstance(RecordParser* parser)
{
SDB_ASSERT(NULL != parser, "parser can't be NULL");
SDB_OSS_DEL(parser);
}
