mdbhtindex.cpp

一个自行开发的内存数据管理的包

			{
				if(strcasecmp(szFieldNames[j],psColumnMeta->m_szColName) == 0)
				{
					break;
				}
			}
			if(j == nFieldCnt)
			{
				throwException(MDB_EC_NORMAL,MDB_ET_LOGIC_ERROR,"CMdbHtIndex::query Logic Error,Idx:%s\n",m_psIndexMeta->m_szIndexName);
			}
			//进行单字段值匹配
			int nFieldType;
			UVal uVal;
			CRecordNode *psRecordNode = psIndexNode->m_psRecord;
			m_pcTable->getAutoFieldValByMeta(psRecordNode,psColumnMeta,nFieldType,(void *)&uVal);
//			if(compareKey(nFieldType,ppVals[j],psColumnMeta->m_szColName,psColumnMeta->m_nInternalType,&uVal) == false)
                        if(compareKey(pnFieldTypes[j],ppVals[j],psColumnMeta->m_szColName,psColumnMeta->m_nInternalType,&uVal) == false)
			{
				bFound = false;
				break; //单字段值不同
			}
			else
			{
				//cerr << "one fieldMatch" << endl;
				continue;  //单字段值通过
			}
		}
		if(bFound)
		{
			break;  //所有字段都匹配
		}
		else
		{
			continue; //失败，下一个比较
		}
	}
	if(!psIndexNode)
	{
			bHit = true;
			return NULL;
	}
	else
	{
		bHit = true;
		return (CRecordNode *)(psIndexNode->m_psRecord);
	}
}

/*
//----------------------------------------------------------------------------
// 函数原型： CWorkFlow::CWorkFlow(int nBucketNum)
// 函数功能： CWorkFlow    构造函数
// 传入参数： 无
// 传出参数： 无
// 函数返回： 无
// 注意事项： 无
//---------------------------------------------------------------------------- 
bool CMdbHtIndex::compareKey(int nFieldType,void *pFieldVal,const char *pColName,int nColInternalType,void *pColVal)
{
	long long nColVal = 0;
	bool bColNum = false;
	if(nColInternalType == CIT_INT8)
	{
		bColNum = true;
		nColVal = *(char *)pColVal;
	}
	else if(nColInternalType == CIT_INT16)
	{
		bColNum = true;
		nColVal = *(short *)pColVal;
	}
	else if(nColInternalType == CIT_INT32)
	{
		bColNum = true;
		nColVal = *(int *)pColVal;
	}
	else if(nColInternalType == CIT_INT64)
	{
		bColNum = true;
		nColVal = *(long long *)pColVal;
		LOG4CPLUS_DEBUG(logger, "nColVal: " << nColVal);
	}
	else if(nColInternalType !=  CIT_CHARARRAY && nColInternalType !=  CIT_STRING)
	{
		throwException(MDB_EC_NORMAL,MDB_ET_INVALID_COL_INTERNAL_TYPE,"CMdbHtIndex::compareKey Error,Invalid nColInternalType,Idx:%s,Col:%d,ColInternalType:%d\n",m_psIndexMeta->m_szIndexName,pColName,nColInternalType);
	}
	
	long long nFieldVal = 0;
	bool bFieldNum = false;
	if(nFieldType == FT_INT8)
	{
		bFieldNum = true;
		nFieldVal = *(char *)pColVal;
	}
	else if(nFieldType == FT_INT16)
	{
		bFieldNum = true;
		nFieldVal = *(short *)pColVal;
	}
	else if(nFieldType == FT_INT32)
	{
		bFieldNum = true;
		nFieldVal = *(int *)pColVal;
	}
	else if(nFieldType == FT_INT64)
	{
		bFieldNum = true;
		nFieldVal = *(long long *)pColVal;
		LOG4CPLUS_DEBUG(logger, "nFieldVal: " << nFieldVal);
	}
	else if(nFieldType !=  FT_STRING)
	{
		throwException(MDB_EC_NORMAL,MDB_ET_INVALID_FIELD_TYPE,"CMdbHtIndex::compareKey Error,Invalid nFieldType,Tbl:%s,Col:%d,FieldType:%d\n",m_psIndexMeta->m_szIndexName,pColName,nFieldType);
	}
	
	if(bFieldNum)
	{
		//cerr << "FieldNum:" << nFieldVal << ",ColNum:" << nColVal << endl;
	}
	else
	{
		//cerr << "FieldStr:" << (char *)pFieldVal << ",ColStr:" << *((char **)pColVal) << endl;
	}
	if(bFieldNum && bColNum && nFieldVal == nColVal)
	{
		return true;
	}
	else if(nFieldType == FT_STRING && (nColInternalType == CIT_CHARARRAY || nColInternalType == CIT_STRING) && strcmp((char *)pFieldVal,*((char **)pColVal)) == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}
*/

//----------------------------------------------------------------------------
// 函数原型： CWorkFlow::CWorkFlow(int nBucketNum)
// 函数功能： CWorkFlow    构造函数
// 传入参数： 无
// 传出参数： 无
// 函数返回： 无
// 注意事项： 无
//---------------------------------------------------------------------------- 
bool CMdbHtIndex::compareKey(int nFieldType,void *pFieldVal,const char *pColName,int nColInternalType,void *pColVal)
{
	long long nColVal = 0;
	bool bColNum = false;
	if(nColInternalType == CIT_INT8)
	{
		bColNum = true;
		nColVal = *(char *)pColVal;
	}
	else if(nColInternalType == CIT_INT16)
	{
		bColNum = true;
		nColVal = *(short *)pColVal;
	}
	else if(nColInternalType == CIT_INT32)
	{
		bColNum = true;
		nColVal = *(int *)pColVal;
	}
	else if(nColInternalType == CIT_INT64)
	{
		bColNum = true;
		nColVal = *(long long *)pColVal;
	}
	else if(nColInternalType !=  CIT_CHARARRAY && nColInternalType !=  CIT_STRING)
	{
		throwException(MDB_EC_NORMAL,MDB_ET_INVALID_COL_INTERNAL_TYPE,"CMdbHtIndex::compareKey Error,Invalid nColInternalType,Idx:%s,Col:%d,ColInternalType:%d\n",m_psIndexMeta->m_szIndexName,pColName,nColInternalType);
	}
	
	long long nFieldVal = 0;
	bool bFieldNum = false;
	if(nFieldType == FT_INT8)
	{
		bFieldNum = true;
		nFieldVal = *(char *)pFieldVal;
	}
	else if(nFieldType == FT_INT16)
	{
		bFieldNum = true;
		nFieldVal = *(short *)pFieldVal;
	}
	else if(nFieldType == FT_INT32)
	{
		bFieldNum = true;
		nFieldVal = *(int *)pFieldVal;
	}
	else if(nFieldType == FT_INT64)
	{
		bFieldNum = true;
		nFieldVal = *(long long *)pFieldVal;
	}
	else if(nFieldType !=  FT_STRING)
	{
		throwException(MDB_EC_NORMAL,MDB_ET_INVALID_FIELD_TYPE,"CMdbHtIndex::compareKey Error,Invalid nFieldType,Idx:%s,Col:%d,FieldType:%d\n",m_psIndexMeta->m_szIndexName,pColName,nFieldType);
	}
	
	/*
	if(bFieldNum)
	{
		//cerr << "FieldNum:" << nFieldVal << ",ColNum:" << nColVal << endl;
	}
	else
	{
		//cerr << "FieldStr:" << (char *)pFieldVal << ",ColStr:" << *((char **)pColVal) << endl;
	}
	*/
	
	if((bFieldNum && !bColNum) || (!bFieldNum && bColNum))
	{
		throwException(MDB_EC_NORMAL,MDB_ET_INVALID_FIELD_TYPE,"CMdbHtIndex::compareKey,InCompatiable FieldType,Idx:%s,Col:%d,nColInternalType:%d,FieldType:%d\n",m_psIndexMeta->m_szIndexName,pColName,nColInternalType,nFieldType);
	}
	
	if(bFieldNum && bColNum && nFieldVal == nColVal)
	{
		return true;
	}
	else if(nFieldType == FT_STRING && (nColInternalType == CIT_CHARARRAY || nColInternalType == CIT_STRING) && strcmp((char *)pFieldVal,*((char **)pColVal)) == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//----------------------------------------------------------------------------
// 函数原型： CWorkFlow::CWorkFlow(int nBucketNum)
// 函数功能： CWorkFlow    构造函数
// 传入参数： 无
// 传出参数： 无
// 函数返回： 无
// 注意事项： 无
//---------------------------------------------------------------------------- 
void CMdbHtIndex::remove(CRecordNode *pRec)
{
	unsigned long nHashVal = 0;
	for(int i=0;i<m_pcDbDict->getIndexColCnt(m_psIndexMeta);i++)
	{
		CDbColumnMeta *psColumnMeta = m_pcDbDict->getIndexColMeta(m_psIndexMeta,i);
		int nFieldType;
		UVal uVal;
		m_pcTable->getAutoFieldValByMeta(pRec,psColumnMeta,nFieldType,(void *)&uVal);
		nHashVal += calcInnerHashVal(nFieldType,&(uVal));
	}
	unsigned long nBucket = nHashVal % HT_BUCKET_CNT;
	CHtIndexNode *psIndexNode = (m_psIndexEntry->m_psHtIndexNodes)[nBucket];
	CHtIndexNode *psPrevIndexNode = NULL;
	while(psIndexNode)
	{
		if((CRecordNode *)psIndexNode->m_psRecord == pRec)
		{
			if(psPrevIndexNode == NULL)
			{
				(m_psIndexEntry->m_psHtIndexNodes)[nBucket] = psIndexNode->m_psNext;
			}
			else
			{
				psPrevIndexNode->m_psNext = psIndexNode->m_psNext;
			}
			m_pcAlloc->free((void *)psIndexNode);
			return;
		}
		else
		{
			psPrevIndexNode = psIndexNode;
			psIndexNode = psIndexNode->m_psNext;
		}
	}
}

//----------------------------------------------------------------------------
// 函数原型： CWorkFlow::CWorkFlow(int nBucketNum)
// 函数功能： CWorkFlow    构造函数
// 传入参数： 无
// 传出参数： 无
// 函数返回： 无
// 注意事项： 无
//---------------------------------------------------------------------------- 
void CMdbHtIndex::update(CRecordNode *pRec,const char *szFieldName,int nFieldType,const void *pVal)
{
	if(m_pcDbDict->fieldIsIndexKey(szFieldName,m_psIndexMeta) == true)
	{
		unsigned long nOrgHashVal = 0;
		unsigned long nDstHashVal = 0;
		unsigned long nFieldHashVal;
		for(int i=0;i<m_pcDbDict->getIndexColCnt(m_psIndexMeta);i++)
		{
			CDbColumnMeta *psColumnMeta = m_pcDbDict->getIndexColMeta(m_psIndexMeta,i);
			int nTmpFieldType;
			UVal uVal;
			
			m_pcTable->getAutoFieldValByMeta(pRec,psColumnMeta,nTmpFieldType,(void *)&uVal);
			
			//cerr << "update char *" << uVal.m_sz << endl;
			
			nFieldHashVal = calcInnerHashVal(nTmpFieldType,&(uVal));
			nOrgHashVal += nFieldHashVal;
			if(strcasecmp(psColumnMeta->m_szColName,szFieldName) == 0)
			{
				nDstHashVal += calcHashVal(nFieldType,pVal);
				//cerr << "pVal:" << (char *)pVal << endl;
				//cerr << "pValHash:" << (char *)pVal << endl;
			}
			else
			{
				nDstHashVal += nFieldHashVal;
			}
			
			//cerr << "colVal:" << uVal.m_sz << endl;
			//cerr << "nFieldHashVal:" << nFieldHashVal << endl;
		}
		//cerr << "nUpdateOrgHashVal:" << nOrgHashVal << endl;
		//cerr << "nUpdateDstHashVal:" << nDstHashVal << endl;
		unsigned long nOrgBucket = nOrgHashVal % HT_BUCKET_CNT;
		CHtIndexNode *psIndexNode = (m_psIndexEntry->m_psHtIndexNodes)[nOrgBucket];
		CHtIndexNode *psPrevIndexNode = NULL;
	     	while(psIndexNode)
		{
			if((CRecordNode *)psIndexNode->m_psRecord == pRec)
			{
				if(psPrevIndexNode == NULL)
				{
					(m_psIndexEntry->m_psHtIndexNodes)[nOrgBucket] = psIndexNode->m_psNext;
				}
				else
				{
					psPrevIndexNode->m_psNext = psIndexNode->m_psNext;
				}
				break;
			}
			else
			{
				psPrevIndexNode = psIndexNode;
				psIndexNode = psIndexNode->m_psNext;
			}
		}
		if(!psIndexNode)
		{
			throwException(MDB_EC_NORMAL,MDB_ET_IDX_NODE_MISSING,"CMdbHtIndex::update Error,Can not Find Index Node,Idx:%s\n",m_psIndexMeta->m_szIndexName);
		}
		unsigned long nDstBucket = nDstHashVal % HT_BUCKET_CNT;
		/*
		if(nFieldType == FT_STRING)
		{
			cerr << "update FieldStr:" << (char *)pVal << endl;
		}
		*/
		//cerr << "update nOrgBucket:" << nOrgBucket << ",update nDstBucket:" << nDstBucket << endl;
		psIndexNode->m_psNext = (m_psIndexEntry->m_psHtIndexNodes)[nDstBucket];
		(m_psIndexEntry->m_psHtIndexNodes)[nDstBucket] = psIndexNode;
	}
}

//----------------------------------------------------------------------------
// 函数原型： CWorkFlow::CWorkFlow(int nBucketNum)
// 函数功能： CWorkFlow    构造函数
// 传入参数： 无
// 传出参数： 无
// 函数返回： 无
// 注意事项： 无
//---------------------------------------------------------------------------- 
void CMdbHtIndex::truncate()
{
	for(int i=0;i<HT_BUCKET_CNT;i++)
	{
		CHtIndexNode *psIndexNode = (m_psIndexEntry->m_psHtIndexNodes)[i];
		while(psIndexNode)
		{
			CHtIndexNode *psNextIndexNode = psIndexNode->m_psNext;
			m_pcAlloc->free((void *)psIndexNode);
			psIndexNode = psNextIndexNode;
		}
	}
	m_pcAlloc->free((void *)m_psIndexEntry);
	m_psIndexMeta->m_psIndexEntry = reinterpret_cast<void *>(NULL);	
}