c_index.cpp

HP共享内存实现,只要将sql语句配置好,装载共享内存即可

/***********************************************************************
 * Module:  c_index.cpp
 * Author:  Administrator
 * Modified: 2005年9月15日 15:40:43
 * Purpose: Implementation of the class c_index
 * Comment: 用于对共享内存中的数据建立索引。 并利用索引进行查询。
 找到所需的数据. 索引是基于共享内存而存在的。
 共享内存在使用时， 只要同索引类打交道即可. 更新索引的时间由各个使用者自行确定。 
 ***********************************************************************/

#include "c_shm_mem.h"
#include "c_index.h"


//表示是全局变量.用于指示字段信息
INDEX_KEY_INFO g_index_key[MAX_INDEX_COUNT];
int index_no = 0;  
int index_count = 0;
c_buf  g_buf[MAX_INDEX_COUNT];
c_buf g_list_buf[MAX_INDEX_COUNT];

int c_list::append(int a ) 
{	
	if( record_count == 0 )	
	{		
//		next = NULL;		
		data = a;	
	}	
	else	
	{		
		c_list* temp_point = (c_list*)g_list_buf[index_no].getSpace();
		temp_point->data = a;
		if( next != NULL )
			temp_point->record_count = next->record_count + 1;
		else
			temp_point->record_count = 1;
		temp_point->next = next;
		next = temp_point;	
	}
	record_count++;	
	return 0;
}

int c_list::del( int seq )
{
	if( seq >= record_count || seq < 0 ) 
	{
		printf("没有这个序号的数据!");
		return -1;
	}
	int i;
	c_list* temp_point;
	c_list* delete_point;
	if( seq == 0 )
	{
		temp_point = next;
		next = temp_point->next;
		data = temp_point->data;
	}
	else if(seq == 1)
	{
		temp_point = next;
		next = temp_point->next;
	}
	else
	{
		temp_point = next;
		for ( i = 1; i < seq - 1; i ++ )
		{
			temp_point = temp_point->next;
		}
		//删除
		delete_point = temp_point->next;
		temp_point->next = delete_point->next;
	}
	//释放内存
	record_count--;	
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_index::createIndex()
// Purpose:    Implementation of c_index::createIndex()
// Return:     int
////////////////////////////////////////////////////////////////////////
void c_index::appendKeySeq(int c, int app)
{
	if( app == 0 )
	{
		for( int i = 0 ; i < keySeq.size(); i++ )
			shm_mem->deleteKey( keySeq[i] );

		keySeq.clear();
		g_index_key[index_no].key_count = 0;
	}

	shm_mem->addKey( c );
//同时更新g_index_key
	memcpy( &(g_index_key[index_no].field_info[g_index_key[index_no].key_count]), &(shm_mem->p_field_info[c]),  sizeof(MEM_FIELD) );
//重置field_pos
	if( g_index_key[index_no].key_count == 0 )
		g_index_key[index_no].field_info[g_index_key[index_no].key_count].field_pos  = 0;
	else
		g_index_key[index_no].field_info[g_index_key[index_no].key_count].field_pos = 
		g_index_key[index_no].field_info[g_index_key[index_no].key_count-1].field_pos + g_index_key[index_no].field_info[g_index_key[index_no].key_count-1].field_size;

//key值大小
	g_index_key[index_no].key_size = g_index_key[index_no].field_info[g_index_key[index_no].key_count].field_pos + g_index_key[index_no].field_info[g_index_key[index_no].key_count].field_size ;
	g_index_key[index_no].key_count++;


//设置buf的参数
	g_index_key[index_no].m_buf.record_size = g_index_key[index_no].key_size;
	g_index_key[index_no].m_buf.unit = 100;

	g_buf[index_no].record_size = g_index_key[index_no].key_size;
	g_buf[index_no].unit = 10;

	keySeq.push_back(c );
}

void c_index::test()
{
	INDEX_VALUE t_index[5800];
	int i;
	char *p_field, *p_element;

	int field_seq;
	int j  = 0;
	for( i = 0; i < shm_mem->p_stShareInfo->real_record_count && i < 5800 ; i ++ )
	{
        p_element = shm_mem->getElement( i );
//测试，　打印出各个字段的值


//构造t_index
		cout<<i<<endl;
		//if( i % 10000  == 0 )  cout<<i<<endl;
		for( field_seq = 0; field_seq< keySeq.size();  field_seq++ )
		{
//			t_index[j].key.setData( field_seq, (char*)p_element + shm_mem->p_field_info[keySeq[field_seq] ].field_pos );
			t_index[j].key.setData( field_seq, p_element + shm_mem->p_field_info[keySeq[field_seq] ].field_pos );
			j++;
		}

		if( i > 579000 )
			break;
	}
	cout<<"索引数组大小为:"<<sizeof(t_index)<<endl;
	cout<<"单个大小为:"<<sizeof(INDEX_VALUE)<<endl;
	cout<<"关键字类大小为:"<<sizeof(c_key_value)<<endl;
	g_buf[index_no].display();
}

void c_index::createIndex( int begin_no, int end_no )
{
	INDEX_VALUE t_index;

	int field_seq;
//先第一条记录
//对共享内存进行遍历一次
	void *p_field, *p_element;
	char out_value[30];

	int i;
//取得记录数
	for( i = begin_no; i < end_no; i ++ )
	{
        p_element = shm_mem->getElement( i );
		if ( p_element == NULL )
		{
			continue;
		}

//构造t_index
		for( field_seq = 0; field_seq< keySeq.size();  field_seq++ )
		{
			t_index.key.setData( field_seq, (char*)p_element + shm_mem->p_field_info[keySeq[field_seq] ].field_pos );
		}

		//要在set中插入一条记录
		pr = index_tree.insert( t_index );
		INDEX_VALUE& ss = (INDEX_VALUE&)(*pr.first);
		ss.record_seq.append(i);
		//pp->append(i);
		//if( i%100000==0 )
		//	cout<<i<<endl;

		if( singal_terminate.isTerminated() )
		{
			g_buf[index_no].recvSpace();
			cout<<"程序终止!"<<endl;
			singal_terminate.kill();
		}
	}
//收回空间
	g_buf[index_no].recvSpace();
}


//创建索引
int c_index::createIndex(void)
{
   // TODO : implement
	index_record_count = shm_mem->getRecordCount();
	cout<<"共享内存记录数为:"<<index_record_count<<endl;
	createIndex( 0, index_record_count );
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_index::find(c_key_value* key)
// Purpose:    Implementation of c_index::find()
// Comment:    返回在共享内存中的一个seq. 即记录序号或位置
// Parameters:
// - key
// Return:     int
////////////////////////////////////////////////////////////////////////

//设置key_v的一些属性
void c_index::getKeyValue( c_key_value& key_v )
{

}

const c_list* c_index::find(c_key_value& key)
{
//更新索引
	updateIndex();
   // TODO : implement
	SET_INDEX_TREE::const_iterator  iter_index;

	INDEX_VALUE t_index;
	t_index.key =  key;   //需增加该函数
	iter_index = index_tree.find( t_index );
	g_buf[index_no].recvSpace();
	
	if( iter_index != index_tree.end() )
	{
//将其序列打印出来
#ifdef _DEBUG
		//cout<<"找到:"<<iter_index->key.buf<<endl;
		const c_list* p_list1 = &(iter_index->record_seq);
		cout<<"tmp "<<p_list1->data<<endl;
		cout<<"序号为:"<<iter_index->record_seq.data<<'\t';
		c_list* p_list = iter_index->record_seq.next;
		
		int i = 0;
		while( p_list != NULL )
		{
			cout<<p_list->data<<'\t';
			p_list = p_list->next;
			i ++;
			if( i >= 30 )
				break;
		}
		cout<<endl;
#endif
		return &(iter_index->record_seq);
		//return iter_index->record_seq.next;
	}
	else
	{
		return NULL;
	}
//空间回收
}


////////////////////////////////////////////////////////////////////////
// Name:       c_index::updateIndex()
// Purpose:    Implementation of c_index::updateIndex()
// Return:     int
////////////////////////////////////////////////////////////////////////

int c_index::updateIndex(void)
{
   // TODO : implement
//当记录数发生改变时， 要进行索引更新
	int t_count = shm_mem->getRecordCount();
	if( t_count != index_record_count )
	{
		createIndex( index_record_count, t_count );
		index_record_count = t_count;
	}

	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_index::nextElement()
// Purpose:    Implementation of c_index::nextElement()
// Return:     void*
// p_data为返回的元素的指针
////////////////////////////////////////////////////////////////////////

const c_list* c_index::nextElement( const c_list* p_list )
{
   // TODO : implement
	if( p_list == NULL )
	{
		return NULL;
	}
	return p_list->next;
}


void* c_index::getField( int record_no, int field_seq )
{
	if( shm_mem->p_field_info[field_seq].field_size == -1 )
	{
		void* p_element = shm_mem->getElement( record_no );		
		if(shm_mem->getFieldValue(field_seq, &add_value[0] ) == 0 )
			return &add_value[0];
		else
			return NULL;
	}
	else
	{
		void* p_element = shm_mem->getElement( record_no );
		return (char*)p_element + shm_mem->p_field_info[field_seq].field_pos;
	}
}

void c_index::display( int seq )
{
	char out[200];
	int out_i;

	shm_mem->getElement(seq );
	for(int i = 0; i< shm_mem->p_share_mem_info->field_count; i++ )
	{
		switch( shm_mem->p_field_info[i].field_type )
		{
		case 1:
			shm_mem->getFieldValue( i, out );
			cout<<out<<endl;
			break;
		case 2:
			shm_mem->getFieldIntValue(i, &out_i );
			cout<<out_i<<endl;
			break;
		case 3:
			break;
		default:
			shm_mem->getFieldValue( i, out );
			cout<<out<<endl;
			break;
		}

	}
}

void c_index::recvSpace()
{
//如果该索引不用了, 可以将其释放掉
	g_index_key[index_no].m_buf.release();
	g_buf[index_no].release();
	g_list_buf[index_no].release();
//将set释放掉
	index_tree.clear();
//将key值去掉
	for( int i = 0 ; i < keySeq.size(); i++ )
		shm_mem->deleteKey( keySeq[i] );

}


//2006-03-12
void c_index::createIndex(bool (*p_func)(c_index*, char*))
{
	index_record_count = shm_mem->getRecordCount();
	cout<<"共享内存记录数为:"<<index_record_count<<endl;
	createIndex( 0, index_record_count, p_func );
	return ;
}

void c_index::createIndex( int begin_no, int end_no, bool (*p_func)(c_index*, char*) )
{
	INDEX_VALUE t_index;

	int field_seq;
//先第一条记录
//对共享内存进行遍历一次
	void *p_field, *p_element;
	char out_value[30];

	int i;
//取得记录数
	for( i = begin_no; i < end_no; i ++ )
	{
        p_element = shm_mem->getElement( i );
		if ( p_element == NULL )
		{
			continue;
		}

		//判断是否满足条件，满足才可以继续
		if ( !p_func(this, (char*)p_element) ) 
		{
			continue;
		}

		//构造t_index
		for( field_seq = 0; field_seq< keySeq.size();  field_seq++ )
		{
			t_index.key.setData( field_seq, (char*)p_element + shm_mem->p_field_info[keySeq[field_seq] ].field_pos );
		}

		//要在set中插入一条记录
		t_index.record_seq.append(i);
		pr = index_tree.insert( t_index );
		//pr.first->record_seq.append(i);

		if( singal_terminate.isTerminated() )
		{
			g_buf[index_no].recvSpace();
			cout<<"程序终止!"<<endl;
			singal_terminate.kill();
		}
	}

//收回空间
	g_buf[index_no].recvSpace();
	return;
}

int c_index::getKeySeqByAttrName( const char* event_attr_name )
{
	int seq = shm_mem->getFieldSeqByAttrName( event_attr_name );
	if( seq < 0 )
	{
		return -1;
	}
	else
	{
		for ( int i = 0 ; i < keySeq.size() ; i ++ )
		{
			if ( keySeq[i] == seq )
			{
				return i;
			}
		}
	}
	return -1;
}

//添加一个索引
INDEX_MANAGER* c_index_manager::appendIndex()
{
	if( index_count >= MAX_INDEX_COUNT )
	{
		cout<<"错误: 超过最大索引数, 最大为:"<<MAX_INDEX_COUNT<<endl;
		return NULL;
	}

	INDEX_MANAGER t_manager;
	t_manager.m_index = new c_index();
	t_manager.g_buf = &g_buf[index_count];
	t_manager.m_key_info = &g_index_key[index_count];
	t_manager.m_list_buf = &g_list_buf[index_count];
//置上索引序列， 以便于跟踪
	t_manager.m_index_no = index_count;

	t_manager.m_list_buf->record_size = sizeof( c_list );
	t_manager.m_list_buf->unit = 100;

	index_no = index_count;
	index_count++;
	index_group.push_back( t_manager );
//建立关键字类型
//	index_group[index_count-1].m_key = new c_key_value();

	return &index_group[index_count-1];
}

INDEX_MANAGER* c_index_manager::appendIndex(const char* mem_name, string p_key[], const int key_size)
{
	c_shm_mem* p_shm_mem = c_shm::getInstPtr()->get_mem( mem_name );
	if( p_shm_mem == NULL )
	{
		cout<<"没有找到该块共享内存:"<<mem_name<<endl;
		exit(1);
	}

	return appendIndex( p_shm_mem, p_key,  key_size);
}


INDEX_MANAGER* c_index_manager::appendIndex(c_shm_mem* p_shm_mem, string p_key[], const int key_size)
{
	if( index_count >= MAX_INDEX_COUNT )
	{
		cout<<"错误: 超过最大索引数, 最大为:"<<MAX_INDEX_COUNT<<endl;
		return NULL;
	}

	int jj = 0;
	string index_str = p_shm_mem->p_share_mem_info->mem_name;
	for( jj = 0;  jj < key_size; jj++ )
	{
		index_str += p_key[jj];
	}
	
	for( jj = 0; jj < indexString.size(); jj++ )
	{
		if( strcmp( index_str.c_str(), 	indexString[jj].index_string ) == 0 )
		{
			index_group[jj].refer_count++;
			return &index_group[jj];
		}
	}
	
	INDEX_MANAGER t_manager;
	t_manager.m_index = new c_index();
	t_manager.refer_count = 0;
	t_manager.g_buf = &g_buf[index_count];
	t_manager.m_key_info = &g_index_key[index_count];
	t_manager.m_list_buf = &g_list_buf[index_count];
//置上索引序列， 以便于跟踪
	t_manager.m_index_no = index_count;

	t_manager.m_list_buf->record_size = sizeof( c_list );
	t_manager.m_list_buf->unit = 100;

	index_no = index_count;
	
	//设置共享内存和key
	t_manager.setShm( p_shm_mem );

	if( key_size == 0 )
	{
		printf("没有设置索引主键\n"); fflush(stdout);
		return NULL;
	}
	else
	{
		int i = 0; 
		for( i = 0; i < key_size; i++ )
		{
			int field_seq = p_shm_mem->getFieldSeqByAttrName( p_key[i].c_str() );
			if( field_seq < 0 )
			{
				cout<<p_key[i].c_str()<<"该字段不存在，请检查"<<endl;
				exit(1);
			}
			else
			{
				t_manager.appendKey( field_seq );
			}
		}
	}

	t_manager.initKey();
	t_manager.m_index->createIndex();

	index_count++;

	INDEX_STRING t_index_str;
	strcpy( t_index_str.index_string, index_str.c_str() );

	indexString.push_back( t_index_str );
	
	index_group.push_back( t_manager );
//建立关键字类型
//	index_group[index_count-1].m_key = new c_key_value();

	return &index_group[index_count-1];
}

//获得索引
INDEX_MANAGER* c_index_manager::getIndex(int seq )
{
	if( seq< 0 || seq >= 	index_group.size() )
		return NULL;
	else
	{
		index_no = seq;
		return &index_group[seq];
	}
}